[3.14] gh-71339: Use new assertion methods in tests (GH-129046) (GH-134498)

(cherry picked from commit 2602d8a)

Co-authored-by: Serhiy Storchaka <[email protected]>

Author: miss-islington

Lib/test/_test_embed_structseq.py

@@ -11,7 +11,7 @@ def check_structseq(self, obj_type):
         # ob_refcnt
         self.assertGreaterEqual(sys.getrefcount(obj_type), 1)
         # tp_base
-        self.assertTrue(issubclass(obj_type, tuple))
+        self.assertIsSubclass(obj_type, tuple)
         # tp_bases
         self.assertEqual(obj_type.__bases__, (tuple,))
         # tp_dict

Lib/test/datetimetester.py

@@ -183,7 +183,7 @@ class NotEnough(tzinfo):
             def __init__(self, offset, name):
                 self.__offset = offset
                 self.__name = name
-        self.assertTrue(issubclass(NotEnough, tzinfo))
+        self.assertIsSubclass(NotEnough, tzinfo)
         ne = NotEnough(3, "NotByALongShot")
         self.assertIsInstance(ne, tzinfo)
 
@@ -232,7 +232,7 @@ def test_pickling_subclass(self):
                 self.assertIs(type(derived), otype)
                 self.assertEqual(derived.utcoffset(None), offset)
                 self.assertEqual(derived.tzname(None), oname)
-                self.assertFalse(hasattr(derived, 'spam'))
+                self.assertNotHasAttr(derived, 'spam')
 
     def test_issue23600(self):
         DSTDIFF = DSTOFFSET = timedelta(hours=1)
@@ -813,7 +813,7 @@ def test_roundtrip(self):
 
             # Verify td -> string -> td identity.
             s = repr(td)
-            self.assertTrue(s.startswith('datetime.'))
+            self.assertStartsWith(s, 'datetime.')
             s = s[9:]
             td2 = eval(s)
             self.assertEqual(td, td2)
@@ -1231,7 +1231,7 @@ def test_roundtrip(self):
                    self.theclass.today()):
             # Verify dt -> string -> date identity.
             s = repr(dt)
-            self.assertTrue(s.startswith('datetime.'))
+            self.assertStartsWith(s, 'datetime.')
             s = s[9:]
             dt2 = eval(s)
             self.assertEqual(dt, dt2)
@@ -2218,7 +2218,7 @@ def test_roundtrip(self):
                    self.theclass.now()):
             # Verify dt -> string -> datetime identity.
             s = repr(dt)
-            self.assertTrue(s.startswith('datetime.'))
+            self.assertStartsWith(s, 'datetime.')
             s = s[9:]
             dt2 = eval(s)
             self.assertEqual(dt, dt2)
@@ -3672,7 +3672,7 @@ def test_roundtrip(self):
 
         # Verify t -> string -> time identity.
         s = repr(t)
-        self.assertTrue(s.startswith('datetime.'))
+        self.assertStartsWith(s, 'datetime.')
         s = s[9:]
         t2 = eval(s)
         self.assertEqual(t, t2)

Lib/test/mapping_tests.py

@@ -70,8 +70,8 @@ def test_read(self):
         if not d: self.fail("Full mapping must compare to True")
         # keys(), items(), iterkeys() ...
         def check_iterandlist(iter, lst, ref):
-            self.assertTrue(hasattr(iter, '__next__'))
-            self.assertTrue(hasattr(iter, '__iter__'))
+            self.assertHasAttr(iter, '__next__')
+            self.assertHasAttr(iter, '__iter__')
             x = list(iter)
             self.assertTrue(set(x)==set(lst)==set(ref))
         check_iterandlist(iter(d.keys()), list(d.keys()),

Lib/test/pickletester.py

@@ -3068,7 +3068,7 @@ def test_proto(self):
             pickled = self.dumps(None, proto)
             if proto >= 2:
                 proto_header = pickle.PROTO + bytes([proto])
-                self.assertTrue(pickled.startswith(proto_header))
+                self.assertStartsWith(pickled, proto_header)
             else:
                 self.assertEqual(count_opcode(pickle.PROTO, pickled), 0)
 
@@ -5007,7 +5007,7 @@ def test_default_dispatch_table(self):
         p = self.pickler_class(f, 0)
         with self.assertRaises(AttributeError):
             p.dispatch_table
-        self.assertFalse(hasattr(p, 'dispatch_table'))
+        self.assertNotHasAttr(p, 'dispatch_table')
 
     def test_class_dispatch_table(self):
         # A dispatch_table attribute can be specified class-wide

Lib/test/support/warnings_helper.py

@@ -23,8 +23,7 @@ def check_syntax_warning(testcase, statement, errtext='',
     testcase.assertEqual(len(warns), 1, warns)
 
     warn, = warns
-    testcase.assertTrue(issubclass(warn.category, SyntaxWarning),
-                        warn.category)
+    testcase.assertIsSubclass(warn.category, SyntaxWarning)
     if errtext:
         testcase.assertRegex(str(warn.message), errtext)
     testcase.assertEqual(warn.filename, '<testcase>')

Lib/test/test__osx_support.py

@@ -66,8 +66,8 @@ def test__find_build_tool(self):
                             'cc not found - check xcode-select')
 
     def test__get_system_version(self):
-        self.assertTrue(platform.mac_ver()[0].startswith(
-                                    _osx_support._get_system_version()))
+        self.assertStartsWith(platform.mac_ver()[0],
+                              _osx_support._get_system_version())
 
     def test__remove_original_values(self):
         config_vars = {

Lib/test/test_abstract_numbers.py

@@ -24,11 +24,11 @@ def not_implemented(*args, **kwargs):
 
 class TestNumbers(unittest.TestCase):
     def test_int(self):
-        self.assertTrue(issubclass(int, Integral))
-        self.assertTrue(issubclass(int, Rational))
-        self.assertTrue(issubclass(int, Real))
-        self.assertTrue(issubclass(int, Complex))
-        self.assertTrue(issubclass(int, Number))
+        self.assertIsSubclass(int, Integral)
+        self.assertIsSubclass(int, Rational)
+        self.assertIsSubclass(int, Real)
+        self.assertIsSubclass(int, Complex)
+        self.assertIsSubclass(int, Number)
 
         self.assertEqual(7, int(7).real)
         self.assertEqual(0, int(7).imag)
@@ -38,23 +38,23 @@ def test_int(self):
         self.assertEqual(1, int(7).denominator)
 
     def test_float(self):
-        self.assertFalse(issubclass(float, Integral))
-        self.assertFalse(issubclass(float, Rational))
-        self.assertTrue(issubclass(float, Real))
-        self.assertTrue(issubclass(float, Complex))
-        self.assertTrue(issubclass(float, Number))
+        self.assertNotIsSubclass(float, Integral)
+        self.assertNotIsSubclass(float, Rational)
+        self.assertIsSubclass(float, Real)
+        self.assertIsSubclass(float, Complex)
+        self.assertIsSubclass(float, Number)
 
         self.assertEqual(7.3, float(7.3).real)
         self.assertEqual(0, float(7.3).imag)
         self.assertEqual(7.3, float(7.3).conjugate())
         self.assertEqual(-7.3, float(-7.3).conjugate())
 
     def test_complex(self):
-        self.assertFalse(issubclass(complex, Integral))
-        self.assertFalse(issubclass(complex, Rational))
-        self.assertFalse(issubclass(complex, Real))
-        self.assertTrue(issubclass(complex, Complex))
-        self.assertTrue(issubclass(complex, Number))
+        self.assertNotIsSubclass(complex, Integral)
+        self.assertNotIsSubclass(complex, Rational)
+        self.assertNotIsSubclass(complex, Real)
+        self.assertIsSubclass(complex, Complex)
+        self.assertIsSubclass(complex, Number)
 
         c1, c2 = complex(3, 2), complex(4,1)
         # XXX: This is not ideal, but see the comment in math_trunc().

Lib/test/test_argparse.py

@@ -6805,7 +6805,7 @@ class TestImportStar(TestCase):
 
     def test(self):
         for name in argparse.__all__:
-            self.assertTrue(hasattr(argparse, name))
+            self.assertHasAttr(argparse, name)
 
     def test_all_exports_everything_but_modules(self):
         items = [

Lib/test/test_ast/test_ast.py

@@ -275,12 +275,12 @@ def test_alias(self):
         self.assertEqual(alias.end_col_offset, 17)
 
     def test_base_classes(self):
-        self.assertTrue(issubclass(ast.For, ast.stmt))
-        self.assertTrue(issubclass(ast.Name, ast.expr))
-        self.assertTrue(issubclass(ast.stmt, ast.AST))
-        self.assertTrue(issubclass(ast.expr, ast.AST))
-        self.assertTrue(issubclass(ast.comprehension, ast.AST))
-        self.assertTrue(issubclass(ast.Gt, ast.AST))
+        self.assertIsSubclass(ast.For, ast.stmt)
+        self.assertIsSubclass(ast.Name, ast.expr)
+        self.assertIsSubclass(ast.stmt, ast.AST)
+        self.assertIsSubclass(ast.expr, ast.AST)
+        self.assertIsSubclass(ast.comprehension, ast.AST)
+        self.assertIsSubclass(ast.Gt, ast.AST)
 
     def test_field_attr_existence(self):
         for name, item in ast.__dict__.items():
@@ -1101,7 +1101,7 @@ def test_copy_with_parents(self):
     def test_replace_interface(self):
         for klass in self.iter_ast_classes():
             with self.subTest(klass=klass):
-                self.assertTrue(hasattr(klass, '__replace__'))
+                self.assertHasAttr(klass, '__replace__')
 
             fields = set(klass._fields)
             with self.subTest(klass=klass, fields=fields):
@@ -1330,7 +1330,7 @@ def test_replace_reject_known_custom_instance_fields_commits(self):
         context = node.ctx
 
         # explicit rejection of known instance fields
-        self.assertTrue(hasattr(node, 'extra'))
+        self.assertHasAttr(node, 'extra')
         msg = "Name.__replace__ got an unexpected keyword argument 'extra'."
         with self.assertRaisesRegex(TypeError, re.escape(msg)):
             copy.replace(node, extra=1)
@@ -3071,7 +3071,7 @@ def test_FunctionDef(self):
         with self.assertWarnsRegex(DeprecationWarning,
                                    r"FunctionDef\.__init__ missing 1 required positional argument: 'name'"):
             node = ast.FunctionDef(args=args)
-        self.assertFalse(hasattr(node, "name"))
+        self.assertNotHasAttr(node, "name")
         self.assertEqual(node.decorator_list, [])
         node = ast.FunctionDef(name='foo', args=args)
         self.assertEqual(node.name, 'foo')

Lib/test/test_audit.py

@@ -134,7 +134,7 @@ def test_socket(self):
         self.assertEqual(events[0][0], "socket.gethostname")
         self.assertEqual(events[1][0], "socket.__new__")
         self.assertEqual(events[2][0], "socket.bind")
-        self.assertTrue(events[2][2].endswith("('127.0.0.1', 8080)"))
+        self.assertEndsWith(events[2][2], "('127.0.0.1', 8080)")
 
     def test_gc(self):
         returncode, events, stderr = self.run_python("test_gc")