X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=tests%2Fbindings%2Fpython%2Fbt2%2Ftest_value.py;h=8a30c87f2ba1f29353d04ded3b7b3f76ad038543;hb=0235b0db7de5bcacdb3650c92461f2ce5eb2143d;hp=d5051f90d25c48fb762f977755843762fe2725e3;hpb=57081273d1191fc79edc101af619fab96b72460d;p=babeltrace.git diff --git a/tests/bindings/python/bt2/test_value.py b/tests/bindings/python/bt2/test_value.py index d5051f90..8a30c87f 100644 --- a/tests/bindings/python/bt2/test_value.py +++ b/tests/bindings/python/bt2/test_value.py @@ -1,20 +1,7 @@ +# SPDX-License-Identifier: GPL-2.0-only # # Copyright (C) 2019 EfficiOS Inc. # -# This program is free software; you can redistribute it and/or -# modify it under the terms of the GNU General Public License -# as published by the Free Software Foundation; only version 2 -# of the License. -# -# This program is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -# GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License -# along with this program; if not, write to the Free Software -# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -# from functools import partial, partialmethod import operator @@ -212,19 +199,23 @@ class _TestNumericValue(_TestCopySimple): # `vint` and `vfloat` mean a signed integer value object and a real # value object. - def _test_binop_invalid_unknown(self, op): - if op in _COMP_BINOPS: - self.skipTest('not testing') - - with self.assertRaises(TypeError): - op(self._def, object()) - - def _test_binop_invalid_none(self, op): - if op in _COMP_BINOPS: - self.skipTest('not testing') - - with self.assertRaises(TypeError): - op(self._def, None) + def _test_binop_unknown(self, op): + if op is operator.eq: + self.assertIs(op(self._def, object()), False) + elif op is operator.ne: + self.assertIs(op(self._def, object()), True) + else: + with self.assertRaises(TypeError): + op(self._def, object()) + + def _test_binop_none(self, op): + if op is operator.eq: + self.assertIs(op(self._def, None), False) + elif op is operator.ne: + self.assertIs(op(self._def, None), True) + else: + with self.assertRaises(TypeError): + op(self._def, None) def _test_binop_rhs_false(self, test_cb, op): test_cb(op, False) @@ -482,10 +473,14 @@ class _TestNumericValue(_TestCopySimple): self.assertEqual(str(self._def), str(self._def_value)) def test_eq_none(self): - self.assertFalse(self._def == None) + # Disable the "comparison to None" warning, as this is precisely what + # we want to test here. + self.assertFalse(self._def == None) # noqa: E711 def test_ne_none(self): - self.assertTrue(self._def != None) + # Disable the "comparison to None" warning, as this is precisely what + # we want to test here. + self.assertTrue(self._def != None) # noqa: E711 # This is a list of binary operators used for @@ -573,13 +568,13 @@ def _inject_numeric_testing_methods(cls): for name, binop in _BINOPS: setattr( cls, - test_binop_name('invalid_unknown'), - partialmethod(_TestNumericValue._test_binop_invalid_unknown, op=binop), + test_binop_name('unknown'), + partialmethod(_TestNumericValue._test_binop_unknown, op=binop), ) setattr( cls, - test_binop_name('invalid_none'), - partialmethod(_TestNumericValue._test_binop_invalid_none, op=binop), + test_binop_name('none'), + partialmethod(_TestNumericValue._test_binop_none, op=binop), ) setattr( cls, @@ -1082,8 +1077,22 @@ class CreateValueFuncTestCase(unittest.TestCase): with self.assertRaisesRegex( TypeError, "cannot create value object from 'A' object" - ) as cm: - v = bt2.create_value(a) + ): + bt2.create_value(a) + + +def _create_const_value(value): + class MySink(bt2._UserSinkComponent): + def _user_consume(self): + pass + + @classmethod + def _user_query(cls, priv_query_exec, obj, params, method_obj): + nonlocal value + return {'my_value': value} + + res = bt2.QueryExecutor(MySink, 'obj', None).query() + return res['my_value'] class BoolValueTestCase(_TestNumericValue, unittest.TestCase): @@ -1122,11 +1131,11 @@ class BoolValueTestCase(_TestNumericValue, unittest.TestCase): def test_create_from_int_non_zero(self): with self.assertRaises(TypeError): - b = bt2.BoolValue(23) + bt2.BoolValue(23) def test_create_from_int_zero(self): with self.assertRaises(TypeError): - b = bt2.BoolValue(0) + bt2.BoolValue(0) def test_assign_true(self): b = bt2.BoolValue() @@ -1160,10 +1169,14 @@ class BoolValueTestCase(_TestNumericValue, unittest.TestCase): self.assertEqual(str(self._def), str(self._def_value)) def test_eq_none(self): - self.assertFalse(self._def == None) + # Disable the "comparison to None" warning, as this is precisely what + # we want to test here. + self.assertFalse(self._def == None) # noqa: E711 def test_ne_none(self): - self.assertTrue(self._def != None) + # Disable the "comparison to None" warning, as this is precisely what + # we want to test here. + self.assertTrue(self._def != None) # noqa: E711 def test_vfalse_eq_false(self): self.assertEqual(self._f, False) @@ -1234,11 +1247,11 @@ class _TestIntegerValue(_TestNumericValue): pass with self._assert_expecting_int(): - i = self._CLS(A()) + self._CLS(A()) def test_create_from_varray(self): with self._assert_expecting_int(): - i = self._CLS(bt2.ArrayValue()) + self._CLS(bt2.ArrayValue()) def test_assign_true(self): raw = True @@ -1279,11 +1292,11 @@ class SignedIntegerValueTestCase(_TestIntegerValue, unittest.TestCase): def test_create_pos_too_big(self): with self._assert_expecting_int64(): - i = self._CLS(2 ** 63) + self._CLS(2 ** 63) def test_create_neg_too_big(self): with self._assert_expecting_int64(): - i = self._CLS(-(2 ** 63) - 1) + self._CLS(-(2 ** 63) - 1) def test_assign_neg_int(self): raw = -13 @@ -1306,11 +1319,11 @@ class UnsignedIntegerValueTestCase(_TestIntegerValue, unittest.TestCase): def test_create_pos_too_big(self): with self._assert_expecting_uint64(): - i = self._CLS(2 ** 64) + self._CLS(2 ** 64) def test_create_neg(self): with self._assert_expecting_uint64(): - i = self._CLS(-1) + self._CLS(-1) _inject_numeric_testing_methods(UnsignedIntegerValueTestCase) @@ -1349,10 +1362,6 @@ class RealValueTestCase(_TestNumericValue, unittest.TestCase): def test_create_neg(self): self.assertEqual(self._fn, self._nv) - def test_create_from_vint(self): - f = bt2.RealValue(self._fp) - self.assertEqual(f, self._pv) - def test_create_from_false(self): f = bt2.RealValue(False) self.assertFalse(f) @@ -1381,11 +1390,11 @@ class RealValueTestCase(_TestNumericValue, unittest.TestCase): pass with self._assert_expecting_float(): - f = bt2.RealValue(A()) + bt2.RealValue(A()) def test_create_from_varray(self): with self._assert_expecting_float(): - f = bt2.RealValue(bt2.ArrayValue()) + bt2.RealValue(bt2.ArrayValue()) def test_assign_true(self): self._def.value = True @@ -1446,6 +1455,7 @@ class StringValueTestCase(_TestCopySimple, unittest.TestCase): def setUp(self): self._def_value = 'Hello, World!' self._def = bt2.StringValue(self._def_value) + self._def_const = _create_const_value(self._def_value) self._def_new_value = 'Yes!' def tearDown(self): @@ -1473,11 +1483,11 @@ class StringValueTestCase(_TestCopySimple, unittest.TestCase): pass with self._assert_expecting_str(): - i = bt2.StringValue(A()) + bt2.StringValue(A()) def test_create_from_varray(self): with self._assert_expecting_str(): - i = bt2.StringValue(bt2.ArrayValue()) + bt2.StringValue(bt2.ArrayValue()) def test_assign_int(self): with self._assert_expecting_str(): @@ -1496,7 +1506,10 @@ class StringValueTestCase(_TestCopySimple, unittest.TestCase): def test_eq(self): self.assertEqual(self._def, self._def_value) - def test_eq(self): + def test_const_eq(self): + self.assertEqual(self._def_const, self._def_value) + + def test_eq_raw(self): self.assertNotEqual(self._def, 23) def test_lt_vstring(self): @@ -1535,6 +1548,15 @@ class StringValueTestCase(_TestCopySimple, unittest.TestCase): s1 = bt2.StringValue('allo') self.assertGreaterEqual('bateau', s1) + def test_in_string(self): + s1 = bt2.StringValue('beau grand bateau') + self.assertIn('bateau', s1) + + def test_in_vstring(self): + s1 = bt2.StringValue('beau grand bateau') + s2 = bt2.StringValue('bateau') + self.assertIn(s2, s1) + def test_bool_op(self): self.assertEqual(bool(self._def), bool(self._def_value)) @@ -1547,12 +1569,22 @@ class StringValueTestCase(_TestCopySimple, unittest.TestCase): def test_getitem(self): self.assertEqual(self._def[5], self._def_value[5]) - def test_append_str(self): + def test_const_getitem(self): + self.assertEqual(self._def_const[5], self._def_value[5]) + + def test_iadd_str(self): to_append = 'meow meow meow' self._def += to_append self._def_value += to_append self.assertEqual(self._def, self._def_value) + def test_const_iadd_str(self): + to_append = 'meow meow meow' + with self.assertRaises(TypeError): + self._def_const += to_append + + self.assertEqual(self._def_const, self._def_value) + def test_append_vstr(self): to_append = 'meow meow meow' self._def += bt2.create_value(to_append) @@ -1564,6 +1596,7 @@ class ArrayValueTestCase(_TestCopySimple, unittest.TestCase): def setUp(self): self._def_value = [None, False, True, -23, 0, 42, -42.4, 23.17, 'yes'] self._def = bt2.ArrayValue(copy.deepcopy(self._def_value)) + self._def_const = _create_const_value(copy.deepcopy(self._def_value)) def tearDown(self): del self._def @@ -1596,7 +1629,7 @@ class ArrayValueTestCase(_TestCopySimple, unittest.TestCase): pass with self._assert_type_error(): - a = bt2.ArrayValue(A()) + bt2.ArrayValue(A()) def test_bool_op_true(self): self.assertTrue(bool(self._def)) @@ -1610,9 +1643,16 @@ class ArrayValueTestCase(_TestCopySimple, unittest.TestCase): def test_eq_int(self): self.assertNotEqual(self._def, 23) + def test_const_eq(self): + a1 = _create_const_value([1, 2, 3]) + a2 = [1, 2, 3] + self.assertEqual(a1, a2) + def test_eq_diff_len(self): a1 = bt2.create_value([1, 2, 3]) a2 = bt2.create_value([1, 2]) + self.assertIs(type(a1), bt2.ArrayValue) + self.assertIs(type(a2), bt2.ArrayValue) self.assertNotEqual(a1, a2) def test_eq_diff_content_same_len(self): @@ -1658,6 +1698,10 @@ class ArrayValueTestCase(_TestCopySimple, unittest.TestCase): with self.assertRaises(IndexError): self._def[len(self._def)] = 23 + def test_const_setitem(self): + with self.assertRaises(TypeError): + self._def_const[2] = 19 + def test_append_none(self): self._def.append(None) self.assertIsNone(self._def[len(self._def) - 1]) @@ -1667,6 +1711,10 @@ class ArrayValueTestCase(_TestCopySimple, unittest.TestCase): self._def.append(raw) self.assertEqual(self._def[len(self._def) - 1], raw) + def test_const_append(self): + with self.assertRaises(AttributeError): + self._def_const.append(12194) + def test_append_vint(self): raw = 145 self._def.append(bt2.create_value(raw)) @@ -1686,6 +1734,10 @@ class ArrayValueTestCase(_TestCopySimple, unittest.TestCase): self.assertEqual(self._def[len(self._def) - 2], raw[1]) self.assertEqual(self._def[len(self._def) - 1], raw[2]) + def test_const_iadd(self): + with self.assertRaises(TypeError): + self._def_const += 12194 + def test_iadd_unknown(self): class A: pass @@ -1704,6 +1756,31 @@ class ArrayValueTestCase(_TestCopySimple, unittest.TestCase): for velem, elem in zip(self._def, self._def_value): self.assertEqual(velem, elem) + def test_const_iter(self): + for velem, elem in zip(self._def_const, self._def_value): + self.assertEqual(velem, elem) + + def test_const_get_item(self): + item1 = self._def_const[0] + item2 = self._def_const[2] + item3 = self._def_const[5] + item4 = self._def_const[7] + item5 = self._def_const[8] + + self.assertEqual(item1, None) + + self.assertIs(type(item2), bt2._BoolValueConst) + self.assertEqual(item2, True) + + self.assertIs(type(item3), bt2._SignedIntegerValueConst) + self.assertEqual(item3, 42) + + self.assertIs(type(item4), bt2._RealValueConst) + self.assertEqual(item4, 23.17) + + self.assertIs(type(item5), bt2._StringValueConst) + self.assertEqual(item5, 'yes') + class MapValueTestCase(_TestCopySimple, unittest.TestCase): def setUp(self): @@ -1719,6 +1796,7 @@ class MapValueTestCase(_TestCopySimple, unittest.TestCase): 'str': 'yes', } self._def = bt2.MapValue(copy.deepcopy(self._def_value)) + self._def_const = _create_const_value(self._def_value) def tearDown(self): del self._def @@ -1743,7 +1821,7 @@ class MapValueTestCase(_TestCopySimple, unittest.TestCase): pass with self.assertRaises(AttributeError): - m = bt2.MapValue(A()) + bt2.MapValue(A()) def test_bool_op_true(self): self.assertTrue(bool(self._def)) @@ -1754,6 +1832,11 @@ class MapValueTestCase(_TestCopySimple, unittest.TestCase): def test_len(self): self.assertEqual(len(self._def), len(self._def_value)) + def test_const_eq(self): + a1 = _create_const_value({'a': 1, 'b': 2, 'c': 3}) + a2 = {'a': 1, 'b': 2, 'c': 3} + self.assertEqual(a1, a2) + def test_eq_int(self): self.assertNotEqual(self._def, 23) @@ -1762,16 +1845,31 @@ class MapValueTestCase(_TestCopySimple, unittest.TestCase): a2 = bt2.create_value({'a': 1, 'b': 2}) self.assertNotEqual(a1, a2) + def test_const_eq_diff_len(self): + a1 = _create_const_value({'a': 1, 'b': 2, 'c': 3}) + a2 = _create_const_value({'a': 1, 'b': 2}) + self.assertNotEqual(a1, a2) + def test_eq_diff_content_same_len(self): a1 = bt2.create_value({'a': 1, 'b': 2, 'c': 3}) a2 = bt2.create_value({'a': 4, 'b': 2, 'c': 3}) self.assertNotEqual(a1, a2) + def test_const_eq_diff_content_same_len(self): + a1 = _create_const_value({'a': 1, 'b': 2, 'c': 3}) + a2 = _create_const_value({'a': 4, 'b': 2, 'c': 3}) + self.assertNotEqual(a1, a2) + def test_eq_same_content_diff_keys(self): a1 = bt2.create_value({'a': 1, 'b': 2, 'c': 3}) a2 = bt2.create_value({'a': 1, 'k': 2, 'c': 3}) self.assertNotEqual(a1, a2) + def test_const_eq_same_content_diff_keys(self): + a1 = _create_const_value({'a': 1, 'b': 2, 'c': 3}) + a2 = _create_const_value({'a': 1, 'k': 2, 'c': 3}) + self.assertNotEqual(a1, a2) + def test_eq_same_content_same_len(self): raw = {'3': 3, 'True': True, 'array': [1, 2.5, None, {'a': 17.6, 'b': None}]} a1 = bt2.MapValue(raw) @@ -1779,11 +1877,22 @@ class MapValueTestCase(_TestCopySimple, unittest.TestCase): self.assertEqual(a1, a2) self.assertEqual(a1, raw) + def test_const_eq_same_content_same_len(self): + raw = {'3': 3, 'True': True, 'array': [1, 2.5, None, {'a': 17.6, 'b': None}]} + a1 = _create_const_value(raw) + a2 = _create_const_value(copy.deepcopy(raw)) + self.assertEqual(a1, a2) + self.assertEqual(a1, raw) + def test_setitem_int(self): raw = 19 self._def['pos-int'] = raw self.assertEqual(self._def['pos-int'], raw) + def test_const_setitem_int(self): + with self.assertRaises(TypeError): + self._def_const['pos-int'] = 19 + def test_setitem_vint(self): raw = 19 self._def['pos-int'] = bt2.create_value(raw) @@ -1808,6 +1917,41 @@ class MapValueTestCase(_TestCopySimple, unittest.TestCase): val = self._def_value[vkey] self.assertEqual(vval, val) + def test_const_iter(self): + for vkey, vval in self._def_const.items(): + val = self._def_value[vkey] + self.assertEqual(vval, val) + + def test_get_item(self): + i = self._def['pos-float'] + self.assertIs(type(i), bt2.RealValue) + self.assertEqual(i, 23.17) + + def test_const_get_item(self): + item1 = self._def_const['none'] + item2 = self._def_const['true'] + item3 = self._def_const['pos-int'] + item4 = self._def_const['pos-float'] + item5 = self._def_const['str'] + + self.assertEqual(item1, None) + + self.assertIs(type(item2), bt2._BoolValueConst) + self.assertEqual(item2, True) + + self.assertIs(type(item3), bt2._SignedIntegerValueConst) + self.assertEqual(item3, 42) + + self.assertIs(type(item4), bt2._RealValueConst) + self.assertEqual(item4, 23.17) + + self.assertIs(type(item5), bt2._StringValueConst) + self.assertEqual(item5, 'yes') + def test_getitem_wrong_key(self): with self.assertRaises(KeyError): self._def['kilojoule'] + + +if __name__ == '__main__': + unittest.main()