class _BasicCopy:
def __copy__(self):
- return self.__class__(self.value)
+ return self.__class__(self._value)
def __deepcopy__(self, memo):
copy = self.__copy__()
@staticmethod
def _extract_value(other):
if isinstance(other, _NumericValue):
- return other.value
+ return other._value
if other is True or other is False:
return other
raise TypeError("'{}' object is not a number object".format(other.__class__.__name__))
def __int__(self):
- return int(self.value)
+ return int(self._value)
def __float__(self):
- return float(self.value)
+ return float(self._value)
def __str__(self):
- return str(self.value)
+ return str(self._value)
def __lt__(self, other):
if not isinstance(other, numbers.Number):
raise TypeError('unorderable types: {}() < {}()'.format(self.__class__.__name__,
other.__class__.__name__))
- return self.value < float(other)
+ return self._value < float(other)
def __le__(self, other):
if not isinstance(other, numbers.Number):
raise TypeError('unorderable types: {}() <= {}()'.format(self.__class__.__name__,
other.__class__.__name__))
- return self.value <= float(other)
+ return self._value <= float(other)
def _spec_eq(self, other):
pass
if not isinstance(other, numbers.Number):
return False
- return self.value == complex(other)
+ return self._value == complex(other)
def __rmod__(self, other):
- return self._extract_value(other) % self.value
+ return self._extract_value(other) % self._value
def __mod__(self, other):
- return self.value % self._extract_value(other)
+ return self._value % self._extract_value(other)
def __rfloordiv__(self, other):
- return self._extract_value(other) // self.value
+ return self._extract_value(other) // self._value
def __floordiv__(self, other):
- return self.value // self._extract_value(other)
+ return self._value // self._extract_value(other)
def __round__(self, ndigits=None):
if ndigits is None:
- return round(self.value)
+ return round(self._value)
else:
- return round(self.value, ndigits)
+ return round(self._value, ndigits)
def __ceil__(self):
- return math.ceil(self.value)
+ return math.ceil(self._value)
def __floor__(self):
- return math.floor(self.value)
+ return math.floor(self._value)
def __trunc__(self):
- return int(self.value)
+ return int(self._value)
def __abs__(self):
- return abs(self.value)
+ return abs(self._value)
def __add__(self, other):
- return self.value + self._extract_value(other)
+ return self._value + self._extract_value(other)
def __radd__(self, other):
return self.__add__(other)
def __neg__(self):
- return -self.value
+ return -self._value
def __pos__(self):
- return +self.value
+ return +self._value
def __mul__(self, other):
- return self.value * self._extract_value(other)
+ return self._value * self._extract_value(other)
def __rmul__(self, other):
return self.__mul__(other)
def __truediv__(self, other):
- return self.value / self._extract_value(other)
+ return self._value / self._extract_value(other)
def __rtruediv__(self, other):
- return self._extract_value(other) / self.value
+ return self._extract_value(other) / self._value
def __pow__(self, exponent):
- return self.value ** self._extract_value(exponent)
+ return self._value ** self._extract_value(exponent)
def __rpow__(self, base):
- return self._extract_value(base) ** self.value
+ return self._extract_value(base) ** self._value
def __iadd__(self, other):
self.value = self + other
class _IntegralValue(_NumericValue, numbers.Integral):
def __lshift__(self, other):
- return self.value << self._extract_value(other)
+ return self._value << self._extract_value(other)
def __rlshift__(self, other):
- return self._extract_value(other) << self.value
+ return self._extract_value(other) << self._value
def __rshift__(self, other):
- return self.value >> self._extract_value(other)
+ return self._value >> self._extract_value(other)
def __rrshift__(self, other):
- return self._extract_value(other) >> self.value
+ return self._extract_value(other) >> self._value
def __and__(self, other):
- return self.value & self._extract_value(other)
+ return self._value & self._extract_value(other)
def __rand__(self, other):
- return self._extract_value(other) & self.value
+ return self._extract_value(other) & self._value
def __xor__(self, other):
- return self.value ^ self._extract_value(other)
+ return self._value ^ self._extract_value(other)
def __rxor__(self, other):
- return self._extract_value(other) ^ self.value
+ return self._extract_value(other) ^ self._value
def __or__(self, other):
- return self.value | self._extract_value(other)
+ return self._value | self._extract_value(other)
def __ror__(self, other):
- return self._extract_value(other) | self.value
+ return self._extract_value(other) | self._value
def __invert__(self):
- return ~self.value
+ return ~self._value
def __ilshift__(self, other):
self.value = self << other
def _spec_eq(self, other):
if isinstance(other, numbers.Number):
- return self.value == bool(other)
+ return self._value == bool(other)
def __bool__(self):
- return self.value
+ return self._value
def __str__(self):
- return str(self.value)
+ return str(self._value)
def _value_to_bool(self, value):
if isinstance(value, BoolValue):
- value = value.value
+ value = value._value
if not isinstance(value, bool):
raise TypeError("'{}' object is not a 'bool' or 'BoolValue' object".format(value.__class__))
return int(value)
@property
- def value(self):
+ def _value(self):
status, value = native_bt.value_bool_get(self._ptr)
assert(status == native_bt.VALUE_STATUS_OK)
return value > 0
- @value.setter
- def value(self, value):
+ def _set_value(self, value):
status = native_bt.value_bool_set(self._ptr, self._value_to_bool(value))
self._handle_status(status)
+ value = property(fset=_set_value)
+
class IntegerValue(_IntegralValue):
_NAME = 'Integer'
return value
@property
- def value(self):
+ def _value(self):
status, value = native_bt.value_integer_get(self._ptr)
assert(status == native_bt.VALUE_STATUS_OK)
return value
- @value.setter
- def value(self, value):
+ def _set_value(self, value):
status = native_bt.value_integer_set(self._ptr, self._value_to_int(value))
self._handle_status(status)
+ value = property(fset=_set_value)
+
class FloatValue(_RealValue):
_NAME = 'Floating point number'
return float(value)
@property
- def value(self):
+ def _value(self):
status, value = native_bt.value_float_get(self._ptr)
assert(status == native_bt.VALUE_STATUS_OK)
return value
- @value.setter
- def value(self, value):
+ def _set_value(self, value):
value = self._value_to_float(value)
status = native_bt.value_float_set(self._ptr, value)
self._handle_status(status)
+ value = property(fset=_set_value)
+
@functools.total_ordering
class StringValue(_BasicCopy, collections.abc.Sequence, _Value):
def _value_to_str(self, value):
if isinstance(value, self.__class__):
- value = value.value
+ value = value._value
utils._check_str(value)
return value
@property
- def value(self):
+ def _value(self):
status, value = native_bt.value_string_get(self._ptr)
assert(status == native_bt.VALUE_STATUS_OK)
return value
- @value.setter
- def value(self, value):
+ def _set_value(self, value):
status = native_bt.value_string_set(self._ptr, self._value_to_str(value))
self._handle_status(status)
+ value = property(fset=_set_value)
+
def _spec_eq(self, other):
try:
- return self.value == self._value_to_str(other)
+ return self._value == self._value_to_str(other)
except:
return
def __le__(self, other):
- return self.value <= self._value_to_str(other)
+ return self._value <= self._value_to_str(other)
def __lt__(self, other):
- return self.value < self._value_to_str(other)
+ return self._value < self._value_to_str(other)
def __bool__(self):
- return bool(self.value)
+ return bool(self._value)
def __str__(self):
- return self.value
+ return self._value
def __getitem__(self, index):
- return self.value[index]
+ return self._value[index]
def __len__(self):
- return len(self.value)
+ return len(self._value)
def __iadd__(self, value):
- curvalue = self.value
+ curvalue = self._value
curvalue += self._value_to_str(value)
self.value = curvalue
return self
for elem in self:
if isinstance(elem, StringValue):
- strings.append(repr(elem.value))
+ strings.append(repr(elem._value))
else:
strings.append(str(elem))
for key, elem in self.items():
if isinstance(elem, StringValue):
- value = repr(elem.value)
+ value = repr(elem._value)
else:
value = str(elem)
rvexc = None
comp_value = rhs
- if type(rhs) in (bt2.BoolValue, bt2.IntegerValue, bt2.FloatValue):
- comp_value = rhs.value
-
try:
r = op(self._def, rhs)
except Exception as e:
self.assertEqual(self._def.addr, addr_before)
def _test_unaryop_value_same(self, op):
- value_before = self._def.value
+ value_before = copy.copy(self._def)
self._unaryop(op)
- self.assertEqual(self._def.value, value_before)
+ self.assertEqual(self._def, value_before)
def _test_binop_type(self, op, rhs):
r, rv = self._binop(op, rhs)
self.assertEqual(self._def.addr, addr_before)
def _test_binop_lhs_value_same(self, op, rhs):
- value_before = self._def.value
+ value_before = copy.copy(self._def)
r, rv = self._binop(op, rhs)
- self.assertEqual(self._def.value, value_before)
+ self.assertEqual(self._def, value_before)
def _test_binop_invalid_unknown(self, op):
if op in _COMP_BINOPS:
self.assertFalse(b)
def test_create_false(self):
- self.assertFalse(self._f.value)
self.assertFalse(self._f)
def test_create_true(self):
- self.assertTrue(self._t.value)
self.assertTrue(self._t)
def test_create_from_vfalse(self):
b = bt2.BoolValue(self._f)
- self.assertFalse(b.value)
self.assertFalse(b)
def test_create_from_vtrue(self):
b = bt2.BoolValue(self._t)
- self.assertTrue(b.value)
self.assertTrue(b)
def test_create_from_int_non_zero(self):
def test_create_default(self):
i = bt2.IntegerValue()
- self.assertEqual(i.value, 0)
+ self.assertEqual(i, 0)
def test_create_pos(self):
- self.assertEqual(self._ip.value, self._pv)
self.assertEqual(self._ip, self._pv)
def test_create_neg(self):
- self.assertEqual(self._in.value, self._nv)
self.assertEqual(self._in, self._nv)
def test_create_pos_too_big(self):
def test_create_from_false(self):
i = bt2.IntegerValue(False)
- self.assertFalse(i.value)
self.assertFalse(i)
def test_create_from_true(self):
i = bt2.IntegerValue(True)
- self.assertTrue(i.value)
self.assertTrue(i)
def test_create_from_float(self):
raw = True
self._def.value = raw
self.assertEqual(self._def, raw)
- self.assertEqual(self._def.value, raw)
def test_assign_false(self):
raw = False
self._def.value = raw
self.assertEqual(self._def, raw)
- self.assertEqual(self._def.value, raw)
def test_assign_pos_int(self):
raw = 477
self._def.value = raw
self.assertEqual(self._def, raw)
- self.assertEqual(self._def.value, raw)
def test_assign_neg_int(self):
raw = -13
self._def.value = raw
self.assertEqual(self._def, raw)
- self.assertEqual(self._def.value, raw)
def test_assign_vint(self):
raw = 999
self._def.value = bt2.create_value(raw)
self.assertEqual(self._def, raw)
- self.assertEqual(self._def.value, raw)
def test_assign_vfloat(self):
raw = 123.456
self._def.value = bt2.create_value(raw)
self.assertEqual(self._def, int(raw))
- self.assertEqual(self._def.value, int(raw))
_inject_numeric_testing_methods(IntegerValueTestCase)
def test_create_default(self):
f = bt2.FloatValue()
- self.assertEqual(f.value, 0.0)
+ self.assertEqual(f, 0.0)
def test_create_pos(self):
- self.assertEqual(self._fp.value, self._pv)
self.assertEqual(self._fp, self._pv)
def test_create_neg(self):
- self.assertEqual(self._fn.value, self._nv)
self.assertEqual(self._fn, self._nv)
def test_create_from_vint(self):
def test_create_from_false(self):
f = bt2.FloatValue(False)
- self.assertFalse(f.value)
self.assertFalse(f)
def test_create_from_true(self):
f = bt2.FloatValue(True)
- self.assertTrue(f.value)
self.assertTrue(f)
def test_create_from_int(self):
raw = 17
f = bt2.FloatValue(raw)
- self.assertEqual(f.value, float(raw))
+ self.assertEqual(f, float(raw))
def test_create_from_vint(self):
raw = 17
f = bt2.FloatValue(bt2.create_value(raw))
- self.assertEqual(f.value, float(raw))
+ self.assertEqual(f, float(raw))
def test_create_from_vfloat(self):
raw = 17.17
f = bt2.FloatValue(bt2.create_value(raw))
- self.assertEqual(f.value, raw)
+ self.assertEqual(f, raw)
def test_create_from_unknown(self):
class A:
def test_assign_true(self):
self._def.value = True
self.assertTrue(self._def)
- self.assertTrue(self._def.value)
def test_assign_false(self):
self._def.value = False
self.assertFalse(self._def)
- self.assertFalse(self._def.value)
def test_assign_pos_int(self):
raw = 477
self._def.value = raw
self.assertEqual(self._def, float(raw))
- self.assertEqual(self._def.value, float(raw))
def test_assign_neg_int(self):
raw = -13
self._def.value = raw
self.assertEqual(self._def, float(raw))
- self.assertEqual(self._def.value, float(raw))
def test_assign_vint(self):
raw = 999
self._def.value = bt2.create_value(raw)
self.assertEqual(self._def, float(raw))
- self.assertEqual(self._def.value, float(raw))
def test_assign_float(self):
raw = -19.23
self._def.value = raw
self.assertEqual(self._def, raw)
- self.assertEqual(self._def.value, raw)
def test_assign_vfloat(self):
raw = 101.32
self._def.value = bt2.create_value(raw)
self.assertEqual(self._def, raw)
- self.assertEqual(self._def.value, raw)
def test_invalid_lshift(self):
self._test_invalid_op(lambda: self._def << 23)
def test_create_default(self):
s = bt2.StringValue()
- self.assertEqual(s.value, '')
+ self.assertEqual(s, '')
def test_create_from_str(self):
raw = 'liberté'
s = bt2.StringValue(raw)
- self.assertEqual(s.value, raw)
+ self.assertEqual(s, raw)
def test_create_from_vstr(self):
raw = 'liberté'
s = bt2.StringValue(bt2.create_value(raw))
- self.assertEqual(s.value, raw)
+ self.assertEqual(s, raw)
def test_create_from_unknown(self):
class A: