X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=tests%2Fbindings%2Fpython%2Fbt2%2Ftest_value.py;h=e7f2ba2ab9201fffd75a0476289efc06dda877b5;hb=768f9bcbf4b5acd09dda85ab32c0ea30d8826136;hp=a2fbd6c2dc5bb57c5006b27b0633c4eb712425de;hpb=0c1a2e5ac0fcb6c41bb353e7caa672cb5dee33a7;p=babeltrace.git diff --git a/tests/bindings/python/bt2/test_value.py b/tests/bindings/python/bt2/test_value.py index a2fbd6c2..e7f2ba2a 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, @@ -1174,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) @@ -1293,11 +1292,11 @@ class SignedIntegerValueTestCase(_TestIntegerValue, unittest.TestCase): def test_create_pos_too_big(self): with self._assert_expecting_int64(): - self._CLS(2 ** 63) + self._CLS(2**63) def test_create_neg_too_big(self): with self._assert_expecting_int64(): - self._CLS(-(2 ** 63) - 1) + self._CLS(-(2**63) - 1) def test_assign_neg_int(self): raw = -13 @@ -1307,7 +1306,7 @@ class SignedIntegerValueTestCase(_TestIntegerValue, unittest.TestCase): def test_compare_big_int(self): # Larger than the IEEE 754 double-precision exact representation of # integers. - raw = (2 ** 53) + 1 + raw = (2**53) + 1 v = bt2.create_value(raw) self.assertEqual(v, raw) @@ -1320,7 +1319,7 @@ class UnsignedIntegerValueTestCase(_TestIntegerValue, unittest.TestCase): def test_create_pos_too_big(self): with self._assert_expecting_uint64(): - self._CLS(2 ** 64) + self._CLS(2**64) def test_create_neg(self): with self._assert_expecting_uint64(): @@ -1363,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)