Use Black stable to format python code

[babeltrace.git] / tests / bindings / python / bt2 / test_value.py

diff --git a/tests/bindings/python/bt2/test_value.py b/tests/bindings/python/bt2/test_value.py
index b8ecfe55e685b72dd474a6e86967f60c9bf3a5ad..e7f2ba2ab9201fffd75a0476289efc06dda877b5 100644 (file)
--- 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)
@@ -1691,10 +1686,6 @@ class ArrayValueTestCase(_TestCopySimple, unittest.TestCase):
         self._def[2] = None
         self.assertIsNone(self._def[2])
 
-    def test_setitem_none(self):
-        self._def[2] = None
-        self.assertIsNone(self._def[2])
-
     def test_setitem_index_wrong_type(self):
         with self._assert_type_error():
             self._def['yes'] = 23
@@ -1960,3 +1951,7 @@ class MapValueTestCase(_TestCopySimple, unittest.TestCase):
     def test_getitem_wrong_key(self):
         with self.assertRaises(KeyError):
             self._def['kilojoule']
+
+
+if __name__ == '__main__':
+    unittest.main()