From b341ef319e551a1743f958d5627e5e3851adac2e Mon Sep 17 00:00:00 2001
From: Serhiy Storchaka <storchaka@gmail.com>
Date: Mon, 20 Jan 2025 12:30:14 +0200
Subject: [PATCH] Move some changes out to other PRs.

---
 Lib/test/test_asyncio/test_base_events.py     |  2 +-
 Lib/test/test_asyncio/test_events.py          |  5 ++--
 Lib/test/test_asyncio/test_futures.py         |  2 +-
 Lib/test/test_asyncio/test_locks.py           | 12 +++++-----
 Lib/test/test_asyncio/test_protocols.py       | 10 ++++----
 Lib/test/test_asyncio/test_queues.py          |  2 +-
 Lib/test/test_asyncio/test_sock_lowlevel.py   | 14 +++++------
 Lib/test/test_asyncio/test_streams.py         | 18 +++++++-------
 Lib/test/test_asyncio/test_tasks.py           |  4 ++--
 Lib/test/test_asyncio/test_windows_utils.py   |  4 ++--
 Lib/test/test_capi/test_abstract.py           | 12 +++++-----
 Lib/test/test_capi/test_misc.py               | 14 ++++++-----
 Lib/test/test_capi/test_sys.py                |  4 ++--
 .../test_ctypes/test_c_simple_type_meta.py    | 16 ++++++-------
 Lib/test/test_ctypes/test_loading.py          |  2 +-
 Lib/test/test_ctypes/test_repr.py             |  6 ++---
 Lib/test/test_email/test_contentmanager.py    |  2 +-
 Lib/test/test_email/test_defect_handling.py   |  4 ++--
 Lib/test/test_email/test_email.py             | 18 +++++++-------
 Lib/test/test_http_cookiejar.py               |  2 +-
 Lib/test/test_http_cookies.py                 |  2 +-
 Lib/test/test_httplib.py                      | 24 ++++++++++---------
 Lib/test/test_httpservers.py                  | 13 +++++-----
 Lib/test/test_import/__init__.py              | 14 +++++------
 .../extension/test_path_hook.py               |  2 +-
 Lib/test/test_importlib/frozen/test_loader.py |  6 ++---
 .../test_importlib/import_/test_caching.py    |  4 ++--
 .../test_importlib/import_/test_fromlist.py   | 16 ++++++-------
 .../test_importlib/import_/test_meta_path.py  |  2 +-
 Lib/test/test_importlib/import_/test_path.py  |  2 +-
 .../import_/test_relative_imports.py          |  6 ++---
 .../test_importlib/resources/test_path.py     |  2 +-
 Lib/test/test_importlib/source/test_finder.py |  8 +++----
 .../test_importlib/source/test_path_hook.py   |  6 ++---
 Lib/test/test_importlib/test_abc.py           | 12 ++++++----
 Lib/test/test_importlib/test_api.py           |  5 ++--
 Lib/test/test_importlib/test_lazy.py          |  4 ++--
 .../test_importlib/test_namespace_pkgs.py     |  4 ++--
 Lib/test/test_importlib/test_pkg_import.py    |  2 +-
 Lib/test/test_importlib/test_spec.py          |  8 +++----
 Lib/test/test_importlib/test_util.py          |  2 +-
 Lib/test/test_mailbox.py                      |  6 ++---
 Lib/test/test_poplib.py                       |  6 ++---
 Lib/test/test_urllib.py                       |  8 +++++--
 Lib/test/test_urllib2.py                      | 12 +++++-----
 Lib/test/test_urllib2_localnet.py             |  3 ++-
 Lib/test/test_urllibnet.py                    |  3 ++-
 Lib/test/test_urlparse.py                     |  7 +++---
 48 files changed, 180 insertions(+), 162 deletions(-)

diff --git a/Lib/test/test_asyncio/test_base_events.py b/Lib/test/test_asyncio/test_base_events.py
index 102c9be0ecf031..1e063c1352ecb9 100644
--- a/Lib/test/test_asyncio/test_base_events.py
+++ b/Lib/test/test_asyncio/test_base_events.py
@@ -1345,7 +1345,7 @@ def getaddrinfo_task(*args, **kwds):
         with self.assertRaises(OSError) as cm:
             self.loop.run_until_complete(coro)
 
-        self.assertStartsWith(str(cm.exception), 'Multiple exceptions: ')
+        self.assertTrue(str(cm.exception).startswith('Multiple exceptions: '))
         self.assertTrue(m_socket.socket.return_value.close.called)
 
         coro = self.loop.create_connection(
diff --git a/Lib/test/test_asyncio/test_events.py b/Lib/test/test_asyncio/test_events.py
index ada049e9c7d387..ed75b909317357 100644
--- a/Lib/test/test_asyncio/test_events.py
+++ b/Lib/test/test_asyncio/test_events.py
@@ -2184,7 +2184,7 @@ def test_subprocess_stderr(self):
 
         transp.close()
         self.assertEqual(b'OUT:test', proto.data[1])
-        self.assertStartsWith(proto.data[2], b'ERR:test')
+        self.assertTrue(proto.data[2].startswith(b'ERR:test'), proto.data[2])
         self.assertEqual(0, proto.returncode)
 
     @support.requires_subprocess()
@@ -2206,7 +2206,8 @@ def test_subprocess_stderr_redirect_to_stdout(self):
 
         stdin.write(b'test')
         self.loop.run_until_complete(proto.completed)
-        self.assertStartsWith(proto.data[1], b'OUT:testERR:test')
+        self.assertTrue(proto.data[1].startswith(b'OUT:testERR:test'),
+                        proto.data[1])
         self.assertEqual(b'', proto.data[2])
 
         transp.close()
diff --git a/Lib/test/test_asyncio/test_futures.py b/Lib/test/test_asyncio/test_futures.py
index 01d6230e6dd9a3..84b44011b9a844 100644
--- a/Lib/test/test_asyncio/test_futures.py
+++ b/Lib/test/test_asyncio/test_futures.py
@@ -242,7 +242,7 @@ def test_uninitialized(self):
 
     def test_future_cancel_message_getter(self):
         f = self._new_future(loop=self.loop)
-        self.assertHasAttr(f, '_cancel_message')
+        self.assertTrue(hasattr(f, '_cancel_message'))
         self.assertEqual(f._cancel_message, None)
 
         f.cancel('my message')
diff --git a/Lib/test/test_asyncio/test_locks.py b/Lib/test/test_asyncio/test_locks.py
index 3bb3e5c4ca0658..aabfcd418829b2 100644
--- a/Lib/test/test_asyncio/test_locks.py
+++ b/Lib/test/test_asyncio/test_locks.py
@@ -27,11 +27,11 @@ class LockTests(unittest.IsolatedAsyncioTestCase):
 
     async def test_repr(self):
         lock = asyncio.Lock()
-        self.assertEndsWith(repr(lock), '[unlocked]>')
+        self.assertTrue(repr(lock).endswith('[unlocked]>'))
         self.assertTrue(RGX_REPR.match(repr(lock)))
 
         await lock.acquire()
-        self.assertEndsWith(repr(lock), '[locked]>')
+        self.assertTrue(repr(lock).endswith('[locked]>'))
         self.assertTrue(RGX_REPR.match(repr(lock)))
 
     async def test_lock(self):
@@ -286,12 +286,12 @@ class EventTests(unittest.IsolatedAsyncioTestCase):
 
     def test_repr(self):
         ev = asyncio.Event()
-        self.assertEndsWith(repr(ev), '[unset]>')
+        self.assertTrue(repr(ev).endswith('[unset]>'))
         match = RGX_REPR.match(repr(ev))
         self.assertEqual(match.group('extras'), 'unset')
 
         ev.set()
-        self.assertEndsWith(repr(ev), '[set]>')
+        self.assertTrue(repr(ev).endswith('[set]>'))
         self.assertTrue(RGX_REPR.match(repr(ev)))
 
         ev._waiters.append(mock.Mock())
@@ -916,11 +916,11 @@ def test_initial_value_zero(self):
 
     async def test_repr(self):
         sem = asyncio.Semaphore()
-        self.assertEndsWith(repr(sem), '[unlocked, value:1]>')
+        self.assertTrue(repr(sem).endswith('[unlocked, value:1]>'))
         self.assertTrue(RGX_REPR.match(repr(sem)))
 
         await sem.acquire()
-        self.assertEndsWith(repr(sem), '[locked]>')
+        self.assertTrue(repr(sem).endswith('[locked]>'))
         self.assertTrue('waiters' not in repr(sem))
         self.assertTrue(RGX_REPR.match(repr(sem)))
 
diff --git a/Lib/test/test_asyncio/test_protocols.py b/Lib/test/test_asyncio/test_protocols.py
index 4484a031988533..a8627b5b5b87f2 100644
--- a/Lib/test/test_asyncio/test_protocols.py
+++ b/Lib/test/test_asyncio/test_protocols.py
@@ -19,7 +19,7 @@ def test_base_protocol(self):
         self.assertIsNone(p.connection_lost(f))
         self.assertIsNone(p.pause_writing())
         self.assertIsNone(p.resume_writing())
-        self.assertNotHasAttr(p, '__dict__')
+        self.assertFalse(hasattr(p, '__dict__'))
 
     def test_protocol(self):
         f = mock.Mock()
@@ -30,7 +30,7 @@ def test_protocol(self):
         self.assertIsNone(p.eof_received())
         self.assertIsNone(p.pause_writing())
         self.assertIsNone(p.resume_writing())
-        self.assertNotHasAttr(p, '__dict__')
+        self.assertFalse(hasattr(p, '__dict__'))
 
     def test_buffered_protocol(self):
         f = mock.Mock()
@@ -41,7 +41,7 @@ def test_buffered_protocol(self):
         self.assertIsNone(p.buffer_updated(150))
         self.assertIsNone(p.pause_writing())
         self.assertIsNone(p.resume_writing())
-        self.assertNotHasAttr(p, '__dict__')
+        self.assertFalse(hasattr(p, '__dict__'))
 
     def test_datagram_protocol(self):
         f = mock.Mock()
@@ -50,7 +50,7 @@ def test_datagram_protocol(self):
         self.assertIsNone(dp.connection_lost(f))
         self.assertIsNone(dp.error_received(f))
         self.assertIsNone(dp.datagram_received(f, f))
-        self.assertNotHasAttr(dp, '__dict__')
+        self.assertFalse(hasattr(dp, '__dict__'))
 
     def test_subprocess_protocol(self):
         f = mock.Mock()
@@ -60,7 +60,7 @@ def test_subprocess_protocol(self):
         self.assertIsNone(sp.pipe_data_received(1, f))
         self.assertIsNone(sp.pipe_connection_lost(1, f))
         self.assertIsNone(sp.process_exited())
-        self.assertNotHasAttr(sp, '__dict__')
+        self.assertFalse(hasattr(sp, '__dict__'))
 
 
 if __name__ == '__main__':
diff --git a/Lib/test/test_asyncio/test_queues.py b/Lib/test/test_asyncio/test_queues.py
index 090b9774c2289f..1a8d604faea1fd 100644
--- a/Lib/test/test_asyncio/test_queues.py
+++ b/Lib/test/test_asyncio/test_queues.py
@@ -18,7 +18,7 @@ async def _test_repr_or_str(self, fn, expect_id):
         appear in fn(Queue()).
         """
         q = asyncio.Queue()
-        self.assertStartsWith(fn(q), '<Queue')
+        self.assertTrue(fn(q).startswith('<Queue'), fn(q))
         id_is_present = hex(id(q)) in fn(q)
         self.assertEqual(expect_id, id_is_present)
 
diff --git a/Lib/test/test_asyncio/test_sock_lowlevel.py b/Lib/test/test_asyncio/test_sock_lowlevel.py
index 4f7b9a1dda6b78..5b1e5143820cad 100644
--- a/Lib/test/test_asyncio/test_sock_lowlevel.py
+++ b/Lib/test/test_asyncio/test_sock_lowlevel.py
@@ -110,7 +110,7 @@ def _basetest_sock_client_ops(self, httpd, sock):
         self.loop.run_until_complete(
             self.loop.sock_recv(sock, 1024))
         sock.close()
-        self.assertStartsWith(data, b'HTTP/1.0 200 OK')
+        self.assertTrue(data.startswith(b'HTTP/1.0 200 OK'))
 
     def _basetest_sock_recv_into(self, httpd, sock):
         # same as _basetest_sock_client_ops, but using sock_recv_into
@@ -127,7 +127,7 @@ def _basetest_sock_recv_into(self, httpd, sock):
             self.loop.run_until_complete(
                 self.loop.sock_recv_into(sock, buf[nbytes:]))
         sock.close()
-        self.assertStartsWith(data, b'HTTP/1.0 200 OK')
+        self.assertTrue(data.startswith(b'HTTP/1.0 200 OK'))
 
     def test_sock_client_ops(self):
         with test_utils.run_test_server() as httpd:
@@ -150,7 +150,7 @@ async def _basetest_sock_recv_racing(self, httpd, sock):
         # consume data
         await self.loop.sock_recv(sock, 1024)
 
-        self.assertStartsWith(data, b'HTTP/1.0 200 OK')
+        self.assertTrue(data.startswith(b'HTTP/1.0 200 OK'))
 
     async def _basetest_sock_recv_into_racing(self, httpd, sock):
         sock.setblocking(False)
@@ -168,7 +168,7 @@ async def _basetest_sock_recv_into_racing(self, httpd, sock):
             nbytes = await self.loop.sock_recv_into(sock, buf[:1024])
             # consume data
             await self.loop.sock_recv_into(sock, buf[nbytes:])
-            self.assertStartsWith(data, b'HTTP/1.0 200 OK')
+            self.assertTrue(data.startswith(b'HTTP/1.0 200 OK'))
 
         await task
 
@@ -217,7 +217,7 @@ async def recv_all():
             sock.shutdown(socket.SHUT_WR)
             data = await task
             # ProactorEventLoop could deliver hello, so endswith is necessary
-            self.assertEndsWith(data, b'world')
+            self.assertTrue(data.endswith(b'world'))
 
     # After the first connect attempt before the listener is ready,
     # the socket needs time to "recover" to make the next connect call.
@@ -298,7 +298,7 @@ async def _basetest_huge_content(self, address):
         data = await self.loop.sock_recv(sock, DATA_SIZE)
         # HTTP headers size is less than MTU,
         # they are sent by the first packet always
-        self.assertStartsWith(data, b'HTTP/1.0 200 OK')
+        self.assertTrue(data.startswith(b'HTTP/1.0 200 OK'))
         while data.find(b'\r\n\r\n') == -1:
             data += await self.loop.sock_recv(sock, DATA_SIZE)
         # Strip headers
@@ -351,7 +351,7 @@ async def _basetest_huge_content_recvinto(self, address):
         data = bytes(buf[:nbytes])
         # HTTP headers size is less than MTU,
         # they are sent by the first packet always
-        self.assertStartsWith(data, b'HTTP/1.0 200 OK')
+        self.assertTrue(data.startswith(b'HTTP/1.0 200 OK'))
         while data.find(b'\r\n\r\n') == -1:
             nbytes = await self.loop.sock_recv_into(sock, buf)
             data = bytes(buf[:nbytes])
diff --git a/Lib/test/test_asyncio/test_streams.py b/Lib/test/test_asyncio/test_streams.py
index 673c6b46c647f3..047ada8c5d23df 100644
--- a/Lib/test/test_asyncio/test_streams.py
+++ b/Lib/test/test_asyncio/test_streams.py
@@ -50,7 +50,7 @@ def _basetest_open_connection(self, open_connection_fut):
         self.assertEqual(data, b'HTTP/1.0 200 OK\r\n')
         f = reader.read()
         data = self.loop.run_until_complete(f)
-        self.assertEndsWith(data, b'\r\n\r\nTest message')
+        self.assertTrue(data.endswith(b'\r\n\r\nTest message'))
         writer.close()
         self.assertEqual(messages, [])
 
@@ -75,7 +75,7 @@ def _basetest_open_connection_no_loop_ssl(self, open_connection_fut):
         writer.write(b'GET / HTTP/1.0\r\n\r\n')
         f = reader.read()
         data = self.loop.run_until_complete(f)
-        self.assertEndsWith(data, b'\r\n\r\nTest message')
+        self.assertTrue(data.endswith(b'\r\n\r\nTest message'))
 
         writer.close()
         self.assertEqual(messages, [])
@@ -1002,7 +1002,7 @@ def test_wait_closed_on_close(self):
             self.assertEqual(data, b'HTTP/1.0 200 OK\r\n')
             f = rd.read()
             data = self.loop.run_until_complete(f)
-            self.assertEndsWith(data, b'\r\n\r\nTest message')
+            self.assertTrue(data.endswith(b'\r\n\r\nTest message'))
             self.assertFalse(wr.is_closing())
             wr.close()
             self.assertTrue(wr.is_closing())
@@ -1028,7 +1028,7 @@ async def inner(httpd):
             data = await rd.readline()
             self.assertEqual(data, b'HTTP/1.0 200 OK\r\n')
             data = await rd.read()
-            self.assertEndsWith(data, b'\r\n\r\nTest message')
+            self.assertTrue(data.endswith(b'\r\n\r\nTest message'))
             wr.close()
             await wr.wait_closed()
 
@@ -1048,7 +1048,7 @@ async def inner(httpd):
             data = await rd.readline()
             self.assertEqual(data, b'HTTP/1.0 200 OK\r\n')
             data = await rd.read()
-            self.assertEndsWith(data, b'\r\n\r\nTest message')
+            self.assertTrue(data.endswith(b'\r\n\r\nTest message'))
             wr.close()
             with self.assertRaises(ConnectionResetError):
                 wr.write(b'data')
@@ -1089,12 +1089,12 @@ async def inner(httpd):
             data = await rd.readline()
             self.assertEqual(data, b'HTTP/1.0 200 OK\r\n')
             data = await rd.read()
-            self.assertEndsWith(data, b'\r\n\r\nTest message')
+            self.assertTrue(data.endswith(b'\r\n\r\nTest message'))
             with self.assertWarns(ResourceWarning) as cm:
                 del wr
                 gc.collect()
                 self.assertEqual(len(cm.warnings), 1)
-                self.assertStartsWith(str(cm.warnings[0].message), "unclosed <StreamWriter")
+                self.assertTrue(str(cm.warnings[0].message).startswith("unclosed <StreamWriter"))
 
         messages = []
         self.loop.set_exception_handler(lambda loop, ctx: messages.append(ctx))
@@ -1112,7 +1112,7 @@ async def inner(httpd):
             data = await rd.readline()
             self.assertEqual(data, b'HTTP/1.0 200 OK\r\n')
             data = await rd.read()
-            self.assertEndsWith(data, b'\r\n\r\nTest message')
+            self.assertTrue(data.endswith(b'\r\n\r\nTest message'))
 
             # Make "loop is closed" occur first before "del wr" for this test.
             self.loop.stop()
@@ -1144,7 +1144,7 @@ async def inner(rd, wr):
                 del wr
                 gc.collect()
                 self.assertEqual(len(cm.warnings), 1)
-                self.assertStartsWith(str(cm.warnings[0].message), "unclosed <StreamWriter")
+                self.assertTrue(str(cm.warnings[0].message).startswith("unclosed <StreamWriter"))
 
         async def outer():
             srv = await asyncio.start_server(inner, socket_helper.HOSTv4, 0)
diff --git a/Lib/test/test_asyncio/test_tasks.py b/Lib/test/test_asyncio/test_tasks.py
index 7a052817766a07..b5363226ad79f4 100644
--- a/Lib/test/test_asyncio/test_tasks.py
+++ b/Lib/test/test_asyncio/test_tasks.py
@@ -110,7 +110,7 @@ def test_task_cancel_message_getter(self):
         async def coro():
             pass
         t = self.new_task(self.loop, coro())
-        self.assertHasAttr(t, '_cancel_message')
+        self.assertTrue(hasattr(t, '_cancel_message'))
         self.assertEqual(t._cancel_message, None)
 
         t.cancel('my message')
@@ -3131,7 +3131,7 @@ def new_task(self, coro):
 class GenericTaskTests(test_utils.TestCase):
 
     def test_future_subclass(self):
-        self.assertIsSubclass(asyncio.Task, asyncio.Future)
+        self.assertTrue(issubclass(asyncio.Task, asyncio.Future))
 
     @support.cpython_only
     def test_asyncio_module_compiled(self):
diff --git a/Lib/test/test_asyncio/test_windows_utils.py b/Lib/test/test_asyncio/test_windows_utils.py
index a6b207567c4f00..be70720707cea7 100644
--- a/Lib/test/test_asyncio/test_windows_utils.py
+++ b/Lib/test/test_asyncio/test_windows_utils.py
@@ -121,8 +121,8 @@ def test_popen(self):
         self.assertGreater(len(out), 0)
         self.assertGreater(len(err), 0)
         # allow for partial reads...
-        self.assertStartsWith(msg.upper().rstrip(), out)
-        self.assertStartsWith(b"stderr", err)
+        self.assertTrue(msg.upper().rstrip().startswith(out))
+        self.assertTrue(b"stderr".startswith(err))
 
         # The context manager calls wait() and closes resources
         with p:
diff --git a/Lib/test/test_capi/test_abstract.py b/Lib/test/test_capi/test_abstract.py
index 3de251bc5c241e..6a626813f23379 100644
--- a/Lib/test/test_capi/test_abstract.py
+++ b/Lib/test/test_capi/test_abstract.py
@@ -274,7 +274,7 @@ def test_object_setattr(self):
 
         # PyObject_SetAttr(obj, attr_name, NULL) removes the attribute
         xsetattr(obj, 'a', NULL)
-        self.assertNotHasAttr(obj, 'a')
+        self.assertFalse(hasattr(obj, 'a'))
         self.assertRaises(AttributeError, xsetattr, obj, 'b', NULL)
         self.assertRaises(RuntimeError, xsetattr, obj, 'evil', NULL)
 
@@ -294,7 +294,7 @@ def test_object_setattrstring(self):
 
         # PyObject_SetAttrString(obj, attr_name, NULL) removes the attribute
         setattrstring(obj, b'a', NULL)
-        self.assertNotHasAttr(obj, 'a')
+        self.assertFalse(hasattr(obj, 'a'))
         self.assertRaises(AttributeError, setattrstring, obj, b'b', NULL)
         self.assertRaises(RuntimeError, setattrstring, obj, b'evil', NULL)
 
@@ -311,10 +311,10 @@ def test_object_delattr(self):
         obj.a = 1
         setattr(obj, '\U0001f40d', 2)
         xdelattr(obj, 'a')
-        self.assertNotHasAttr(obj, 'a')
+        self.assertFalse(hasattr(obj, 'a'))
         self.assertRaises(AttributeError, xdelattr, obj, 'b')
         xdelattr(obj, '\U0001f40d')
-        self.assertNotHasAttr(obj, '\U0001f40d')
+        self.assertFalse(hasattr(obj, '\U0001f40d'))
 
         self.assertRaises(AttributeError, xdelattr, 42, 'numerator')
         self.assertRaises(RuntimeError, xdelattr, obj, 'evil')
@@ -328,10 +328,10 @@ def test_object_delattrstring(self):
         obj.a = 1
         setattr(obj, '\U0001f40d', 2)
         delattrstring(obj, b'a')
-        self.assertNotHasAttr(obj, 'a')
+        self.assertFalse(hasattr(obj, 'a'))
         self.assertRaises(AttributeError, delattrstring, obj, b'b')
         delattrstring(obj, '\U0001f40d'.encode())
-        self.assertNotHasAttr(obj, '\U0001f40d')
+        self.assertFalse(hasattr(obj, '\U0001f40d'))
 
         self.assertRaises(AttributeError, delattrstring, 42, b'numerator')
         self.assertRaises(RuntimeError, delattrstring, obj, b'evil')
diff --git a/Lib/test/test_capi/test_misc.py b/Lib/test/test_capi/test_misc.py
index c8946e5e1d8016..99d9a757759dcd 100644
--- a/Lib/test/test_capi/test_misc.py
+++ b/Lib/test/test_capi/test_misc.py
@@ -116,7 +116,8 @@ def test_no_FatalError_infinite_loop(self):
                    "after Python initialization and before Python finalization, "
                    "but it was called without an active thread state. "
                    "Are you trying to call the C API inside of a Py_BEGIN_ALLOW_THREADS block?").encode()
-        self.assertStartsWith(err.rstrip(), msg)
+        self.assertTrue(err.rstrip().startswith(msg),
+                        err)
 
     def test_memoryview_from_NULL_pointer(self):
         self.assertRaises(ValueError, _testcapi.make_memoryview_from_NULL_pointer)
@@ -719,7 +720,7 @@ def test_heaptype_with_setattro(self):
 
     def test_heaptype_with_custom_metaclass(self):
         metaclass = _testcapi.HeapCTypeMetaclass
-        self.assertIsSubclass(metaclass, type)
+        self.assertTrue(issubclass(metaclass, type))
 
         # Class creation from C
         t = _testcapi.pytype_fromspec_meta(metaclass)
@@ -735,7 +736,7 @@ def test_heaptype_with_custom_metaclass(self):
     def test_heaptype_with_custom_metaclass_null_new(self):
         metaclass = _testcapi.HeapCTypeMetaclassNullNew
 
-        self.assertIsSubclass(metaclass, type)
+        self.assertTrue(issubclass(metaclass, type))
 
         # Class creation from C
         t = _testcapi.pytype_fromspec_meta(metaclass)
@@ -750,7 +751,7 @@ def test_heaptype_with_custom_metaclass_null_new(self):
     def test_heaptype_with_custom_metaclass_custom_new(self):
         metaclass = _testcapi.HeapCTypeMetaclassCustomNew
 
-        self.assertIsSubclass(_testcapi.HeapCTypeMetaclassCustomNew, type)
+        self.assertTrue(issubclass(_testcapi.HeapCTypeMetaclassCustomNew, type))
 
         msg = "Metaclasses with custom tp_new are not supported."
         with self.assertRaisesRegex(TypeError, msg):
@@ -909,7 +910,8 @@ def test_export_symbols(self):
             names.append('Py_FrozenMain')
 
         for name in names:
-            self.assertHasAttr(ctypes.pythonapi, name)
+            with self.subTest(name=name):
+                self.assertTrue(hasattr(ctypes.pythonapi, name))
 
     def test_clear_managed_dict(self):
 
@@ -2363,7 +2365,7 @@ def test_mutate_exception(self):
 
         support.run_in_subinterp("import binascii; binascii.Error.foobar = 'foobar'")
 
-        self.assertNotHasAttr(binascii.Error, "foobar")
+        self.assertFalse(hasattr(binascii.Error, "foobar"))
 
     @unittest.skipIf(_testmultiphase is None, "test requires _testmultiphase module")
     # gh-117649: The free-threaded build does not currently support sharing
diff --git a/Lib/test/test_capi/test_sys.py b/Lib/test/test_capi/test_sys.py
index d3a9b378e7769a..54a8e026d883d4 100644
--- a/Lib/test/test_capi/test_sys.py
+++ b/Lib/test/test_capi/test_sys.py
@@ -51,7 +51,7 @@ def test_sys_setobject(self):
             self.assertEqual(setobject(b'newattr', value2), 0)
             self.assertIs(sys.newattr, value2)
             self.assertEqual(setobject(b'newattr', NULL), 0)
-            self.assertNotHasAttr(sys, 'newattr')
+            self.assertFalse(hasattr(sys, 'newattr'))
             self.assertEqual(setobject(b'newattr', NULL), 0)
         finally:
             with contextlib.suppress(AttributeError):
@@ -60,7 +60,7 @@ def test_sys_setobject(self):
             self.assertEqual(setobject('\U0001f40d'.encode(), value), 0)
             self.assertIs(getattr(sys, '\U0001f40d'), value)
             self.assertEqual(setobject('\U0001f40d'.encode(), NULL), 0)
-            self.assertNotHasAttr(sys, '\U0001f40d')
+            self.assertFalse(hasattr(sys, '\U0001f40d'))
         finally:
             with contextlib.suppress(AttributeError):
                 delattr(sys, '\U0001f40d')
diff --git a/Lib/test/test_ctypes/test_c_simple_type_meta.py b/Lib/test/test_ctypes/test_c_simple_type_meta.py
index e8f347a0d0c57b..eb77d6d7782478 100644
--- a/Lib/test/test_ctypes/test_c_simple_type_meta.py
+++ b/Lib/test/test_ctypes/test_c_simple_type_meta.py
@@ -54,9 +54,9 @@ class Sub2(Sub):
             pass
 
         self.assertIsInstance(POINTER(Sub2), p_meta)
-        self.assertIsSubclass(POINTER(Sub2), Sub2)
-        self.assertIsSubclass(POINTER(Sub2), POINTER(Sub))
-        self.assertIsSubclass(POINTER(Sub), POINTER(CtBase))
+        self.assertTrue(issubclass(POINTER(Sub2), Sub2))
+        self.assertTrue(issubclass(POINTER(Sub2), POINTER(Sub)))
+        self.assertTrue(issubclass(POINTER(Sub), POINTER(CtBase)))
 
     def test_creating_pointer_in_dunder_new_2(self):
         # A simpler variant of the above, used in `CoClass` of the `comtypes`
@@ -84,7 +84,7 @@ class Sub(CtBase):
             pass
 
         self.assertIsInstance(POINTER(Sub), p_meta)
-        self.assertIsSubclass(POINTER(Sub), Sub)
+        self.assertTrue(issubclass(POINTER(Sub), Sub))
 
     def test_creating_pointer_in_dunder_init_1(self):
         class ct_meta(type):
@@ -120,9 +120,9 @@ class Sub2(Sub):
             pass
 
         self.assertIsInstance(POINTER(Sub2), p_meta)
-        self.assertIsSubclass(POINTER(Sub2), Sub2)
-        self.assertIsSubclass(POINTER(Sub2), POINTER(Sub))
-        self.assertIsSubclass(POINTER(Sub), POINTER(CtBase))
+        self.assertTrue(issubclass(POINTER(Sub2), Sub2))
+        self.assertTrue(issubclass(POINTER(Sub2), POINTER(Sub)))
+        self.assertTrue(issubclass(POINTER(Sub), POINTER(CtBase)))
 
     def test_creating_pointer_in_dunder_init_2(self):
         class ct_meta(type):
@@ -149,4 +149,4 @@ class Sub(CtBase):
             pass
 
         self.assertIsInstance(POINTER(Sub), p_meta)
-        self.assertIsSubclass(POINTER(Sub), Sub)
+        self.assertTrue(issubclass(POINTER(Sub), Sub))
diff --git a/Lib/test/test_ctypes/test_loading.py b/Lib/test/test_ctypes/test_loading.py
index 13ed813ad98c31..fc1eecb77e17e3 100644
--- a/Lib/test/test_ctypes/test_loading.py
+++ b/Lib/test/test_ctypes/test_loading.py
@@ -135,7 +135,7 @@ def test_1703286_B(self):
                          'test specific to Windows')
     def test_load_hasattr(self):
         # bpo-34816: shouldn't raise OSError
-        self.assertNotHasAttr(ctypes.windll, 'test')
+        self.assertFalse(hasattr(ctypes.windll, 'test'))
 
     @unittest.skipUnless(os.name == "nt",
                          'test specific to Windows')
diff --git a/Lib/test/test_ctypes/test_repr.py b/Lib/test/test_ctypes/test_repr.py
index 8c85e6cbe70cea..e7587984a92c45 100644
--- a/Lib/test/test_ctypes/test_repr.py
+++ b/Lib/test/test_ctypes/test_repr.py
@@ -22,12 +22,12 @@ class ReprTest(unittest.TestCase):
     def test_numbers(self):
         for typ in subclasses:
             base = typ.__bases__[0]
-            self.assertStartsWith(repr(base(42)), base.__name__)
-            self.assertStartsWith(repr(typ(42)), "<X object at")
+            self.assertTrue(repr(base(42)).startswith(base.__name__))
+            self.assertEqual("<X object at", repr(typ(42))[:12])
 
     def test_char(self):
         self.assertEqual("c_char(b'x')", repr(c_char(b'x')))
-        self.assertStartsWith(repr(X(b'x')), "<X object at")
+        self.assertEqual("<X object at", repr(X(b'x'))[:12])
 
 
 if __name__ == "__main__":
diff --git a/Lib/test/test_email/test_contentmanager.py b/Lib/test/test_email/test_contentmanager.py
index dceb54f15e48f4..694cef4ba7e413 100644
--- a/Lib/test/test_email/test_contentmanager.py
+++ b/Lib/test/test_email/test_contentmanager.py
@@ -288,7 +288,7 @@ def test_get_message_non_rfc822_or_external_body_yields_bytes(self):
 
             The real body is in another message.
             """))
-        self.assertStartsWith(raw_data_manager.get_content(m), b'To: foo@ex')
+        self.assertEqual(raw_data_manager.get_content(m)[:10], b'To: foo@ex')
 
     def test_set_text_plain(self):
         m = self._make_message()
diff --git a/Lib/test/test_email/test_defect_handling.py b/Lib/test/test_email/test_defect_handling.py
index 44e76c8ce5e03a..781f657418220c 100644
--- a/Lib/test/test_email/test_defect_handling.py
+++ b/Lib/test/test_email/test_defect_handling.py
@@ -57,7 +57,7 @@ def test_same_boundary_inner_outer(self):
             msg = self._str_msg(source)
         if self.raise_expected: return
         inner = msg.get_payload(0)
-        self.assertHasAttr(inner, 'defects')
+        self.assertTrue(hasattr(inner, 'defects'))
         self.assertEqual(len(self.get_defects(inner)), 1)
         self.assertIsInstance(self.get_defects(inner)[0],
                               errors.StartBoundaryNotFoundDefect)
@@ -151,7 +151,7 @@ def test_lying_multipart(self):
         with self._raise_point(errors.NoBoundaryInMultipartDefect):
             msg = self._str_msg(source)
         if self.raise_expected: return
-        self.assertHasAttr(msg, 'defects')
+        self.assertTrue(hasattr(msg, 'defects'))
         self.assertEqual(len(self.get_defects(msg)), 2)
         self.assertIsInstance(self.get_defects(msg)[0],
                               errors.NoBoundaryInMultipartDefect)
diff --git a/Lib/test/test_email/test_email.py b/Lib/test/test_email/test_email.py
index 17dd07f381ff13..2deb35721576b8 100644
--- a/Lib/test/test_email/test_email.py
+++ b/Lib/test/test_email/test_email.py
@@ -210,8 +210,8 @@ def test_make_boundary(self):
         self.assertEqual(msg.items()[0][1], 'multipart/form-data')
         # Trigger creation of boundary
         msg.as_string()
-        self.assertStartsWith(msg.items()[0][1],
-                              'multipart/form-data; boundary="==')
+        self.assertEqual(msg.items()[0][1][:33],
+                        'multipart/form-data; boundary="==')
         # XXX: there ought to be tests of the uniqueness of the boundary, too.
 
     def test_message_rfc822_only(self):
@@ -303,7 +303,7 @@ def test_as_string(self):
         self.assertEqual(text, str(msg))
         fullrepr = msg.as_string(unixfrom=True)
         lines = fullrepr.split('\n')
-        self.assertStartsWith(lines[0], 'From ')
+        self.assertTrue(lines[0].startswith('From '))
         self.assertEqual(text, NL.join(lines[1:]))
 
     def test_as_string_policy(self):
@@ -372,7 +372,7 @@ def test_as_bytes(self):
         self.assertEqual(data, bytes(msg))
         fullrepr = msg.as_bytes(unixfrom=True)
         lines = fullrepr.split(b'\n')
-        self.assertStartsWith(lines[0], b'From ')
+        self.assertTrue(lines[0].startswith(b'From '))
         self.assertEqual(data, b'\n'.join(lines[1:]))
 
     def test_as_bytes_policy(self):
@@ -2203,7 +2203,7 @@ def test_same_boundary_inner_outer(self):
         msg = self._msgobj('msg_15.txt')
         # XXX We can probably eventually do better
         inner = msg.get_payload(0)
-        self.assertHasAttr(inner, 'defects')
+        self.assertTrue(hasattr(inner, 'defects'))
         self.assertEqual(len(inner.defects), 1)
         self.assertIsInstance(inner.defects[0],
                               errors.StartBoundaryNotFoundDefect)
@@ -2315,7 +2315,7 @@ def test_no_separating_blank_line(self):
     # test_defect_handling
     def test_lying_multipart(self):
         msg = self._msgobj('msg_41.txt')
-        self.assertHasAttr(msg, 'defects')
+        self.assertTrue(hasattr(msg, 'defects'))
         self.assertEqual(len(msg.defects), 2)
         self.assertIsInstance(msg.defects[0],
                               errors.NoBoundaryInMultipartDefect)
@@ -3659,7 +3659,9 @@ def test_make_msgid_idstring(self):
     def test_make_msgid_default_domain(self):
         with patch('socket.getfqdn') as mock_getfqdn:
             mock_getfqdn.return_value = domain = 'pythontest.example.com'
-            self.assertEndsWith(email.utils.make_msgid(), '@' + domain + '>')
+            self.assertTrue(
+                email.utils.make_msgid().endswith(
+                    '@' + domain + '>'))
 
     def test_Generator_linend(self):
         # Issue 14645.
@@ -4126,7 +4128,7 @@ def test_CRLFLF_at_end_of_part(self):
             "--BOUNDARY--\n"
           )
         msg = email.message_from_string(m)
-        self.assertEndsWith(msg.get_payload(0).get_payload(), '\r\n')
+        self.assertTrue(msg.get_payload(0).get_payload().endswith('\r\n'))
 
 
 class Test8BitBytesHandling(TestEmailBase):
diff --git a/Lib/test/test_http_cookiejar.py b/Lib/test/test_http_cookiejar.py
index 6a3fe41adb74a2..dbf9ce10f76f91 100644
--- a/Lib/test/test_http_cookiejar.py
+++ b/Lib/test/test_http_cookiejar.py
@@ -1515,7 +1515,7 @@ def test_netscape_example_1(self):
         h = req.get_header("Cookie")
         self.assertIn("PART_NUMBER=ROCKET_LAUNCHER_0001", h)
         self.assertIn("CUSTOMER=WILE_E_COYOTE", h)
-        self.assertStartsWith(h, "SHIPPING=FEDEX;")
+        self.assertTrue(h.startswith("SHIPPING=FEDEX;"))
 
     def test_netscape_example_2(self):
         # Second Example transaction sequence:
diff --git a/Lib/test/test_http_cookies.py b/Lib/test/test_http_cookies.py
index 4ee33dba5d6309..7b3dc0fdaedc3b 100644
--- a/Lib/test/test_http_cookies.py
+++ b/Lib/test/test_http_cookies.py
@@ -180,7 +180,7 @@ def test_special_attrs(self):
         C = cookies.SimpleCookie('Customer="WILE_E_COYOTE"')
         C['Customer']['expires'] = 0
         # can't test exact output, it always depends on current date/time
-        self.assertEndsWith(C.output(), 'GMT')
+        self.assertTrue(C.output().endswith('GMT'))
 
         # loading 'expires'
         C = cookies.SimpleCookie()
diff --git a/Lib/test/test_httplib.py b/Lib/test/test_httplib.py
index 90109b2b88f5d8..7a7ec555a2dbbb 100644
--- a/Lib/test/test_httplib.py
+++ b/Lib/test/test_httplib.py
@@ -273,7 +273,7 @@ def test_ipv6host_header(self):
         sock = FakeSocket('')
         conn.sock = sock
         conn.request('GET', '/foo')
-        self.assertStartsWith(sock.data, expected)
+        self.assertTrue(sock.data.startswith(expected))
 
         expected = b'GET /foo HTTP/1.1\r\nHost: [2001:102A::]\r\n' \
                    b'Accept-Encoding: identity\r\n\r\n'
@@ -281,7 +281,7 @@ def test_ipv6host_header(self):
         sock = FakeSocket('')
         conn.sock = sock
         conn.request('GET', '/foo')
-        self.assertStartsWith(sock.data, expected)
+        self.assertTrue(sock.data.startswith(expected))
 
         expected = b'GET /foo HTTP/1.1\r\nHost: [fe80::]\r\n' \
                    b'Accept-Encoding: identity\r\n\r\n'
@@ -289,7 +289,7 @@ def test_ipv6host_header(self):
         sock = FakeSocket('')
         conn.sock = sock
         conn.request('GET', '/foo')
-        self.assertStartsWith(sock.data, expected)
+        self.assertTrue(sock.data.startswith(expected))
 
         expected = b'GET /foo HTTP/1.1\r\nHost: [fe80::]:81\r\n' \
                    b'Accept-Encoding: identity\r\n\r\n'
@@ -297,7 +297,7 @@ def test_ipv6host_header(self):
         sock = FakeSocket('')
         conn.sock = sock
         conn.request('GET', '/foo')
-        self.assertStartsWith(sock.data, expected)
+        self.assertTrue(sock.data.startswith(expected))
 
     def test_malformed_headers_coped_with(self):
         # Issue 19996
@@ -335,9 +335,9 @@ def test_parse_all_octets(self):
         self.assertIsNotNone(resp.getheader('obs-text'))
         self.assertIn('obs-text', resp.msg)
         for folded in (resp.getheader('obs-fold'), resp.msg['obs-fold']):
-            self.assertStartsWith(folded, 'text')
+            self.assertTrue(folded.startswith('text'))
             self.assertIn(' folded with space', folded)
-            self.assertEndsWith(folded, 'folded with tab')
+            self.assertTrue(folded.endswith('folded with tab'))
 
     def test_invalid_headers(self):
         conn = client.HTTPConnection('example.com')
@@ -1000,7 +1000,8 @@ def test_send_file(self):
             sock = FakeSocket(body)
             conn.sock = sock
             conn.request('GET', '/foo', body)
-            self.assertStartsWith(sock.data, expected)
+            self.assertTrue(sock.data.startswith(expected), '%r != %r' %
+                    (sock.data[:len(expected)], expected))
 
     def test_send(self):
         expected = b'this is a test this is only a test'
@@ -1544,7 +1545,7 @@ def mypeek(n=-1):
                 # then unbounded peek
                 p2 = resp.peek()
                 self.assertGreaterEqual(len(p2), len(p))
-                self.assertStartsWith(p2, p)
+                self.assertTrue(p2.startswith(p))
                 next = resp.read(len(p2))
                 self.assertEqual(next, p2)
             else:
@@ -1569,7 +1570,7 @@ def _verify_readline(self, readline, expected, limit=5):
             line = readline(limit)
             if line and line != b"foo":
                 if len(line) < 5:
-                    self.assertEndsWith(line, b"\n")
+                    self.assertTrue(line.endswith(b"\n"))
             all.append(line)
             if not line:
                 break
@@ -1764,7 +1765,7 @@ def test_client_constants(self):
         ]
         for const in expected:
             with self.subTest(constant=const):
-                self.assertHasAttr(client, const)
+                self.assertTrue(hasattr(client, const))
 
 
 class SourceAddressTest(TestCase):
@@ -2406,7 +2407,8 @@ def test_tunnel_connect_single_send_connection_setup(self):
                 msg=f'unexpected number of send calls: {mock_send.mock_calls}')
         proxy_setup_data_sent = mock_send.mock_calls[0][1][0]
         self.assertIn(b'CONNECT destination.com', proxy_setup_data_sent)
-        self.assertEndsWith(proxy_setup_data_sent, b'\r\n\r\n',
+        self.assertTrue(
+                proxy_setup_data_sent.endswith(b'\r\n\r\n'),
                 msg=f'unexpected proxy data sent {proxy_setup_data_sent!r}')
 
     def test_connect_put_request(self):
diff --git a/Lib/test/test_httpservers.py b/Lib/test/test_httpservers.py
index ccd60019d07764..1c370dcafa9fea 100644
--- a/Lib/test/test_httpservers.py
+++ b/Lib/test/test_httpservers.py
@@ -335,7 +335,8 @@ def test_get(self):
             self.con.request('GET', '/')
             self.con.getresponse()
 
-        self.assertEndsWith(err.getvalue(), '"GET / HTTP/1.1" 200 -\n')
+        self.assertTrue(
+            err.getvalue().endswith('"GET / HTTP/1.1" 200 -\n'))
 
     def test_err(self):
         self.con = http.client.HTTPConnection(self.HOST, self.PORT)
@@ -346,8 +347,8 @@ def test_err(self):
             self.con.getresponse()
 
         lines = err.getvalue().split('\n')
-        self.assertEndsWith(lines[0], 'code 404, message File not found')
-        self.assertEndsWith(lines[1], '"ERROR / HTTP/1.1" 404 -')
+        self.assertTrue(lines[0].endswith('code 404, message File not found'))
+        self.assertTrue(lines[1].endswith('"ERROR / HTTP/1.1" 404 -'))
 
 
 class SimpleHTTPServerTestCase(BaseTestCase):
@@ -471,7 +472,7 @@ def test_get_dir_redirect_location_domain_injection_bug(self):
         response = self.request(attack_url)
         self.check_status_and_reason(response, HTTPStatus.MOVED_PERMANENTLY)
         location = response.getheader('Location')
-        self.assertNotStartsWith(location, '//')
+        self.assertFalse(location.startswith('//'), msg=location)
         self.assertEqual(location, expected_location,
                 msg='Expected Location header to start with a single / and '
                 'end with a / as this is a directory redirect.')
@@ -494,7 +495,7 @@ def test_get_dir_redirect_location_domain_injection_bug(self):
         # We're just ensuring that the scheme and domain make it through, if
         # there are or aren't multiple slashes at the start of the path that
         # follows that isn't important in this Location: header.
-        self.assertStartsWith(location, 'https://pypi.org/')
+        self.assertTrue(location.startswith('https://pypi.org/'), msg=location)
 
     def test_get(self):
         #constructs the path relative to the root directory of the HTTPServer
@@ -1093,7 +1094,7 @@ def test_extra_space(self):
             b'Host: dummy\r\n'
             b'\r\n'
         )
-        self.assertStartsWith(result[0], b'HTTP/1.1 400 ')
+        self.assertTrue(result[0].startswith(b'HTTP/1.1 400 '))
         self.verify_expected_headers(result[1:result.index(b'\r\n')])
         self.assertFalse(self.handler.get_called)
 
diff --git a/Lib/test/test_import/__init__.py b/Lib/test/test_import/__init__.py
index 654b9f5bd7ab50..1e706023c795b6 100644
--- a/Lib/test/test_import/__init__.py
+++ b/Lib/test/test_import/__init__.py
@@ -539,7 +539,7 @@ def test_import_name_binding(self):
         import test as x
         import test.support
         self.assertIs(x, test, x.__name__)
-        self.assertHasAttr(test.support, "__file__")
+        self.assertTrue(hasattr(test.support, "__file__"))
 
         # import x.y.z as w binds z as w
         import test.support as y
@@ -610,7 +610,7 @@ def test_file_to_source(self):
         sys.path.insert(0, os.curdir)
         try:
             mod = __import__(TESTFN)
-            self.assertEndsWith(mod.__file__, '.py')
+            self.assertTrue(mod.__file__.endswith('.py'))
             os.remove(source)
             del sys.modules[TESTFN]
             make_legacy_pyc(source)
@@ -1443,7 +1443,7 @@ def test_UNC_path(self):
             self.fail("could not import 'test_unc_path' from %r: %r"
                       % (unc, e))
         self.assertEqual(mod.testdata, 'test_unc_path')
-        self.assertStartsWith(mod.__file__, unc)
+        self.assertTrue(mod.__file__.startswith(unc), mod.__file__)
         unload("test_unc_path")
 
 
@@ -1456,7 +1456,7 @@ def tearDown(self):
     def test_relimport_star(self):
         # This will import * from .test_import.
         from .. import relimport
-        self.assertHasAttr(relimport, "RelativeImportTests")
+        self.assertTrue(hasattr(relimport, "RelativeImportTests"))
 
     def test_issue3221(self):
         # Note for mergers: the 'absolute' tests from the 2.x branch
@@ -1786,7 +1786,7 @@ def test_frozen_importlib_is_bootstrap(self):
         self.assertIs(mod, _bootstrap)
         self.assertEqual(mod.__name__, 'importlib._bootstrap')
         self.assertEqual(mod.__package__, 'importlib')
-        self.assertEndsWith(mod.__file__, '_bootstrap.py')
+        self.assertTrue(mod.__file__.endswith('_bootstrap.py'), mod.__file__)
 
     def test_frozen_importlib_external_is_bootstrap_external(self):
         from importlib import _bootstrap_external
@@ -1794,7 +1794,7 @@ def test_frozen_importlib_external_is_bootstrap_external(self):
         self.assertIs(mod, _bootstrap_external)
         self.assertEqual(mod.__name__, 'importlib._bootstrap_external')
         self.assertEqual(mod.__package__, 'importlib')
-        self.assertEndsWith(mod.__file__, '_bootstrap_external.py')
+        self.assertTrue(mod.__file__.endswith('_bootstrap_external.py'), mod.__file__)
 
     def test_there_can_be_only_one(self):
         # Issue #15386 revealed a tricky loophole in the bootstrapping
@@ -2800,7 +2800,7 @@ def check_common(self, loaded):
         self.assertEqual(mod.__file__, self.FILE)
         self.assertEqual(mod.__spec__.origin, self.ORIGIN)
         if not isolated:
-            self.assertIsSubclass(mod.error, Exception)
+            self.assertTrue(issubclass(mod.error, Exception))
         self.assertEqual(mod.int_const, 1969)
         self.assertEqual(mod.str_const, 'something different')
         self.assertIsInstance(mod._module_initialized, float)
diff --git a/Lib/test/test_importlib/extension/test_path_hook.py b/Lib/test/test_importlib/extension/test_path_hook.py
index 941dcd5432ce46..314a635c77e082 100644
--- a/Lib/test/test_importlib/extension/test_path_hook.py
+++ b/Lib/test/test_importlib/extension/test_path_hook.py
@@ -21,7 +21,7 @@ def hook(self, entry):
     def test_success(self):
         # Path hook should handle a directory where a known extension module
         # exists.
-        self.assertHasAttr(self.hook(util.EXTENSIONS.path), 'find_spec')
+        self.assertTrue(hasattr(self.hook(util.EXTENSIONS.path), 'find_spec'))
 
 
 (Frozen_PathHooksTests,
diff --git a/Lib/test/test_importlib/frozen/test_loader.py b/Lib/test/test_importlib/frozen/test_loader.py
index c808bb73291a7c..1112c0664ad477 100644
--- a/Lib/test/test_importlib/frozen/test_loader.py
+++ b/Lib/test/test_importlib/frozen/test_loader.py
@@ -61,7 +61,7 @@ def exec_module(self, name, origname=None):
             module.main()
 
         self.assertTrue(module.initialized)
-        self.assertHasAttr(module, '__spec__')
+        self.assertTrue(hasattr(module, '__spec__'))
         self.assertEqual(module.__spec__.origin, 'frozen')
         return module, stdout.getvalue()
 
@@ -72,7 +72,7 @@ def test_module(self):
         for attr, value in check.items():
             self.assertEqual(getattr(module, attr), value)
         self.assertEqual(output, 'Hello world!\n')
-        self.assertHasAttr(module, '__spec__')
+        self.assertTrue(hasattr(module, '__spec__'))
         self.assertEqual(module.__spec__.loader_state.origname, name)
 
     def test_package(self):
@@ -136,7 +136,7 @@ def test_get_code(self):
             exec(code, mod.__dict__)
         with captured_stdout() as stdout:
             mod.main()
-        self.assertHasAttr(mod, 'initialized')
+        self.assertTrue(hasattr(mod, 'initialized'))
         self.assertEqual(stdout.getvalue(), 'Hello world!\n')
 
     def test_get_source(self):
diff --git a/Lib/test/test_importlib/import_/test_caching.py b/Lib/test/test_importlib/import_/test_caching.py
index 718e7d041b0860..aedf0fd4f9db02 100644
--- a/Lib/test/test_importlib/import_/test_caching.py
+++ b/Lib/test/test_importlib/import_/test_caching.py
@@ -78,7 +78,7 @@ def test_using_cache_for_assigning_to_attribute(self):
             with self.create_mock('pkg.__init__', 'pkg.module') as importer:
                 with util.import_state(meta_path=[importer]):
                     module = self.__import__('pkg.module')
-                    self.assertHasAttr(module, 'module')
+                    self.assertTrue(hasattr(module, 'module'))
                     self.assertEqual(id(module.module),
                                     id(sys.modules['pkg.module']))
 
@@ -88,7 +88,7 @@ def test_using_cache_for_fromlist(self):
         with self.create_mock('pkg.__init__', 'pkg.module') as importer:
             with util.import_state(meta_path=[importer]):
                 module = self.__import__('pkg', fromlist=['module'])
-                self.assertHasAttr(module, 'module')
+                self.assertTrue(hasattr(module, 'module'))
                 self.assertEqual(id(module.module),
                                  id(sys.modules['pkg.module']))
 
diff --git a/Lib/test/test_importlib/import_/test_fromlist.py b/Lib/test/test_importlib/import_/test_fromlist.py
index feccc7be09a98c..4b4b9bc3f5e04a 100644
--- a/Lib/test/test_importlib/import_/test_fromlist.py
+++ b/Lib/test/test_importlib/import_/test_fromlist.py
@@ -63,7 +63,7 @@ def test_nonexistent_object(self):
             with util.import_state(meta_path=[importer]):
                 module = self.__import__('module', fromlist=['non_existent'])
                 self.assertEqual(module.__name__, 'module')
-                self.assertNotHasAttr(module, 'non_existent')
+                self.assertFalse(hasattr(module, 'non_existent'))
 
     def test_module_from_package(self):
         # [module]
@@ -71,7 +71,7 @@ def test_module_from_package(self):
             with util.import_state(meta_path=[importer]):
                 module = self.__import__('pkg', fromlist=['module'])
                 self.assertEqual(module.__name__, 'pkg')
-                self.assertHasAttr(module, 'module')
+                self.assertTrue(hasattr(module, 'module'))
                 self.assertEqual(module.module.__name__, 'pkg.module')
 
     def test_nonexistent_from_package(self):
@@ -79,7 +79,7 @@ def test_nonexistent_from_package(self):
             with util.import_state(meta_path=[importer]):
                 module = self.__import__('pkg', fromlist=['non_existent'])
                 self.assertEqual(module.__name__, 'pkg')
-                self.assertNotHasAttr(module, 'non_existent')
+                self.assertFalse(hasattr(module, 'non_existent'))
 
     def test_module_from_package_triggers_ModuleNotFoundError(self):
         # If a submodule causes an ModuleNotFoundError because it tries
@@ -107,7 +107,7 @@ def basic_star_test(self, fromlist=['*']):
                 mock['pkg'].__all__ = ['module']
                 module = self.__import__('pkg', fromlist=fromlist)
                 self.assertEqual(module.__name__, 'pkg')
-                self.assertHasAttr(module, 'module')
+                self.assertTrue(hasattr(module, 'module'))
                 self.assertEqual(module.module.__name__, 'pkg.module')
 
     def test_using_star(self):
@@ -125,8 +125,8 @@ def test_star_with_others(self):
                 mock['pkg'].__all__ = ['module1']
                 module = self.__import__('pkg', fromlist=['module2', '*'])
                 self.assertEqual(module.__name__, 'pkg')
-                self.assertHasAttr(module, 'module1')
-                self.assertHasAttr(module, 'module2')
+                self.assertTrue(hasattr(module, 'module1'))
+                self.assertTrue(hasattr(module, 'module2'))
                 self.assertEqual(module.module1.__name__, 'pkg.module1')
                 self.assertEqual(module.module2.__name__, 'pkg.module2')
 
@@ -136,7 +136,7 @@ def test_nonexistent_in_all(self):
                 importer['pkg'].__all__ = ['non_existent']
                 module = self.__import__('pkg', fromlist=['*'])
                 self.assertEqual(module.__name__, 'pkg')
-                self.assertNotHasAttr(module, 'non_existent')
+                self.assertFalse(hasattr(module, 'non_existent'))
 
     def test_star_in_all(self):
         with util.mock_spec('pkg.__init__') as importer:
@@ -144,7 +144,7 @@ def test_star_in_all(self):
                 importer['pkg'].__all__ = ['*']
                 module = self.__import__('pkg', fromlist=['*'])
                 self.assertEqual(module.__name__, 'pkg')
-                self.assertNotHasAttr(module, '*')
+                self.assertFalse(hasattr(module, '*'))
 
     def test_invalid_type(self):
         with util.mock_spec('pkg.__init__') as importer:
diff --git a/Lib/test/test_importlib/import_/test_meta_path.py b/Lib/test/test_importlib/import_/test_meta_path.py
index 4c00f60681acf1..8689017ba43112 100644
--- a/Lib/test/test_importlib/import_/test_meta_path.py
+++ b/Lib/test/test_importlib/import_/test_meta_path.py
@@ -43,7 +43,7 @@ def test_empty(self):
                 self.assertIsNone(importlib._bootstrap._find_spec('nothing',
                                                                   None))
                 self.assertEqual(len(w), 1)
-                self.assertIsSubclass(w[-1].category, ImportWarning)
+                self.assertTrue(issubclass(w[-1].category, ImportWarning))
 
 
 (Frozen_CallingOrder,
diff --git a/Lib/test/test_importlib/import_/test_path.py b/Lib/test/test_importlib/import_/test_path.py
index bcd5ad6e76005a..89b52fbd1e1aff 100644
--- a/Lib/test/test_importlib/import_/test_path.py
+++ b/Lib/test/test_importlib/import_/test_path.py
@@ -80,7 +80,7 @@ def test_empty_path_hooks(self):
                 self.assertIsNone(self.find('os'))
                 self.assertIsNone(sys.path_importer_cache[path_entry])
                 self.assertEqual(len(w), 1)
-                self.assertIsSubclass(w[-1].category, ImportWarning)
+                self.assertTrue(issubclass(w[-1].category, ImportWarning))
 
     def test_path_importer_cache_empty_string(self):
         # The empty string should create a finder using the cwd.
diff --git a/Lib/test/test_importlib/import_/test_relative_imports.py b/Lib/test/test_importlib/import_/test_relative_imports.py
index e535d119763148..99c24f1fd9487c 100644
--- a/Lib/test/test_importlib/import_/test_relative_imports.py
+++ b/Lib/test/test_importlib/import_/test_relative_imports.py
@@ -81,7 +81,7 @@ def callback(global_):
             self.__import__('pkg')  # For __import__().
             module = self.__import__('', global_, fromlist=['mod2'], level=1)
             self.assertEqual(module.__name__, 'pkg')
-            self.assertHasAttr(module, 'mod2')
+            self.assertTrue(hasattr(module, 'mod2'))
             self.assertEqual(module.mod2.attr, 'pkg.mod2')
         self.relative_import_test(create, globals_, callback)
 
@@ -107,7 +107,7 @@ def callback(global_):
             module = self.__import__('', global_, fromlist=['module'],
                              level=1)
             self.assertEqual(module.__name__, 'pkg')
-            self.assertHasAttr(module, 'module')
+            self.assertTrue(hasattr(module, 'module'))
             self.assertEqual(module.module.attr, 'pkg.module')
         self.relative_import_test(create, globals_, callback)
 
@@ -131,7 +131,7 @@ def callback(global_):
             module = self.__import__('', global_, fromlist=['subpkg2'],
                                             level=2)
             self.assertEqual(module.__name__, 'pkg')
-            self.assertHasAttr(module, 'subpkg2')
+            self.assertTrue(hasattr(module, 'subpkg2'))
             self.assertEqual(module.subpkg2.attr, 'pkg.subpkg2.__init__')
         self.relative_import_test(create, globals_, callback)
 
diff --git a/Lib/test/test_importlib/resources/test_path.py b/Lib/test/test_importlib/resources/test_path.py
index 903911f57b3306..378dc7a2baeb23 100644
--- a/Lib/test/test_importlib/resources/test_path.py
+++ b/Lib/test/test_importlib/resources/test_path.py
@@ -20,7 +20,7 @@ def test_reading(self):
         target = resources.files(self.data) / 'utf-8.file'
         with resources.as_file(target) as path:
             self.assertIsInstance(path, pathlib.Path)
-            self.assertEndsWith(path.name, "utf-8.file")
+            self.assertTrue(path.name.endswith("utf-8.file"), repr(path))
             self.assertEqual('Hello, UTF-8 world!\n', path.read_text(encoding='utf-8'))
 
 
diff --git a/Lib/test/test_importlib/source/test_finder.py b/Lib/test/test_importlib/source/test_finder.py
index 4de736a6bf3b2d..8c06c4da1f5cba 100644
--- a/Lib/test/test_importlib/source/test_finder.py
+++ b/Lib/test/test_importlib/source/test_finder.py
@@ -73,7 +73,7 @@ def run_test(self, test, create=None, *, compile_=None, unlink=None):
                         if error.errno != errno.ENOENT:
                             raise
             loader = self.import_(mapping['.root'], test)
-            self.assertHasAttr(loader, 'load_module')
+            self.assertTrue(hasattr(loader, 'load_module'))
             return loader
 
     def test_module(self):
@@ -100,7 +100,7 @@ def test_module_in_package(self):
         with util.create_modules('pkg.__init__', 'pkg.sub') as mapping:
             pkg_dir = os.path.dirname(mapping['pkg.__init__'])
             loader = self.import_(pkg_dir, 'pkg.sub')
-            self.assertHasAttr(loader, 'load_module')
+            self.assertTrue(hasattr(loader, 'load_module'))
 
     # [sub package]
     def test_package_in_package(self):
@@ -108,7 +108,7 @@ def test_package_in_package(self):
         with context as mapping:
             pkg_dir = os.path.dirname(mapping['pkg.__init__'])
             loader = self.import_(pkg_dir, 'pkg.sub')
-            self.assertHasAttr(loader, 'load_module')
+            self.assertTrue(hasattr(loader, 'load_module'))
 
     # [package over modules]
     def test_package_over_module(self):
@@ -129,7 +129,7 @@ def test_empty_string_for_dir(self):
             file.write("# test file for importlib")
         try:
             loader = self._find(finder, 'mod', loader_only=True)
-            self.assertHasAttr(loader, 'load_module')
+            self.assertTrue(hasattr(loader, 'load_module'))
         finally:
             os.unlink('mod.py')
 
diff --git a/Lib/test/test_importlib/source/test_path_hook.py b/Lib/test/test_importlib/source/test_path_hook.py
index 6e1c23e6a9842b..f274330e0b333b 100644
--- a/Lib/test/test_importlib/source/test_path_hook.py
+++ b/Lib/test/test_importlib/source/test_path_hook.py
@@ -15,12 +15,12 @@ def path_hook(self):
 
     def test_success(self):
         with util.create_modules('dummy') as mapping:
-            self.assertHasAttr(self.path_hook()(mapping['.root']),
-                               'find_spec')
+            self.assertTrue(hasattr(self.path_hook()(mapping['.root']),
+                                    'find_spec'))
 
     def test_empty_string(self):
         # The empty string represents the cwd.
-        self.assertHasAttr(self.path_hook()(''), 'find_spec')
+        self.assertTrue(hasattr(self.path_hook()(''), 'find_spec'))
 
 
 (Frozen_PathHookTest,
diff --git a/Lib/test/test_importlib/test_abc.py b/Lib/test/test_importlib/test_abc.py
index b1ab52f966ffdb..92a77e079e57e7 100644
--- a/Lib/test/test_importlib/test_abc.py
+++ b/Lib/test/test_importlib/test_abc.py
@@ -43,12 +43,14 @@ def setUp(self):
     def test_subclasses(self):
         # Test that the expected subclasses inherit.
         for subclass in self.subclasses:
-            self.assertIsSubclass(subclass, self.__test)
+            self.assertTrue(issubclass(subclass, self.__test),
+                "{0} is not a subclass of {1}".format(subclass, self.__test))
 
     def test_superclasses(self):
         # Test that the class inherits from the expected superclasses.
         for superclass in self.superclasses:
-            self.assertIsSubclass(self.__test, superclass)
+            self.assertTrue(issubclass(self.__test, superclass),
+               "{0} is not a superclass of {1}".format(superclass, self.__test))
 
 
 class MetaPathFinder(InheritanceTests):
@@ -422,14 +424,14 @@ def test_source_to_code_source(self):
         # Since compile() can handle strings, so should source_to_code().
         source = 'attr = 42'
         module = self.source_to_module(source)
-        self.assertHasAttr(module, 'attr')
+        self.assertTrue(hasattr(module, 'attr'))
         self.assertEqual(module.attr, 42)
 
     def test_source_to_code_bytes(self):
         # Since compile() can handle bytes, so should source_to_code().
         source = b'attr = 42'
         module = self.source_to_module(source)
-        self.assertHasAttr(module, 'attr')
+        self.assertTrue(hasattr(module, 'attr'))
         self.assertEqual(module.attr, 42)
 
     def test_source_to_code_path(self):
@@ -763,7 +765,7 @@ def test_package_settings(self):
                     warnings.simplefilter('ignore', DeprecationWarning)
                     module = self.loader.load_module(self.name)
                 self.verify_module(module)
-                self.assertNotHasAttr(module, '__path__')
+                self.assertFalse(hasattr(module, '__path__'))
 
     def test_get_source_encoding(self):
         # Source is considered encoded in UTF-8 by default unless otherwise
diff --git a/Lib/test/test_importlib/test_api.py b/Lib/test/test_importlib/test_api.py
index 1bc531a2fe34e7..6035b2ca72efb9 100644
--- a/Lib/test/test_importlib/test_api.py
+++ b/Lib/test/test_importlib/test_api.py
@@ -430,7 +430,8 @@ def test_everyone_has___loader__(self):
         for name, module in sys.modules.items():
             if isinstance(module, types.ModuleType):
                 with self.subTest(name=name):
-                    self.assertHasAttr(module, '__loader__')
+                    self.assertTrue(hasattr(module, '__loader__'),
+                                    '{!r} lacks a __loader__ attribute'.format(name))
                     if self.machinery.BuiltinImporter.find_spec(name):
                         self.assertIsNot(module.__loader__, None)
                     elif self.machinery.FrozenImporter.find_spec(name):
@@ -440,7 +441,7 @@ def test_everyone_has___spec__(self):
         for name, module in sys.modules.items():
             if isinstance(module, types.ModuleType):
                 with self.subTest(name=name):
-                    self.assertHasAttr(module, '__spec__')
+                    self.assertTrue(hasattr(module, '__spec__'))
                     if self.machinery.BuiltinImporter.find_spec(name):
                         self.assertIsNot(module.__spec__, None)
                     elif self.machinery.FrozenImporter.find_spec(name):
diff --git a/Lib/test/test_importlib/test_lazy.py b/Lib/test/test_importlib/test_lazy.py
index e48fad8898f0ef..5c6e0303528906 100644
--- a/Lib/test/test_importlib/test_lazy.py
+++ b/Lib/test/test_importlib/test_lazy.py
@@ -125,12 +125,12 @@ def test_delete_eventual_attr(self):
         # Deleting an attribute should stay deleted.
         module = self.new_module()
         del module.attr
-        self.assertNotHasAttr(module, 'attr')
+        self.assertFalse(hasattr(module, 'attr'))
 
     def test_delete_preexisting_attr(self):
         module = self.new_module()
         del module.__name__
-        self.assertNotHasAttr(module, '__name__')
+        self.assertFalse(hasattr(module, '__name__'))
 
     def test_module_substitution_error(self):
         with test_util.uncache(TestingImporter.module_name):
diff --git a/Lib/test/test_importlib/test_namespace_pkgs.py b/Lib/test/test_importlib/test_namespace_pkgs.py
index 6ca0978f9bca69..cbbdada3b010a7 100644
--- a/Lib/test/test_importlib/test_namespace_pkgs.py
+++ b/Lib/test/test_importlib/test_namespace_pkgs.py
@@ -80,7 +80,7 @@ def test_cant_import_other(self):
 
     def test_simple_repr(self):
         import foo.one
-        self.assertStartsWith(repr(foo), "<module 'foo' (namespace) from [")
+        self.assertTrue(repr(foo).startswith("<module 'foo' (namespace) from ["))
 
 
 class DynamicPathNamespacePackage(NamespacePackageTest):
@@ -301,7 +301,7 @@ def test_missing_directory(self):
 
     def test_missing_directory2(self):
         import foo
-        self.assertNotHasAttr(foo, 'one')
+        self.assertFalse(hasattr(foo, 'one'))
 
     def test_present_directory(self):
         import bar.two
diff --git a/Lib/test/test_importlib/test_pkg_import.py b/Lib/test/test_importlib/test_pkg_import.py
index 5ffae6222bacb8..66f5f8bc253a85 100644
--- a/Lib/test/test_importlib/test_pkg_import.py
+++ b/Lib/test/test_importlib/test_pkg_import.py
@@ -55,7 +55,7 @@ def test_package_import__semantics(self):
         except SyntaxError: pass
         else: raise RuntimeError('Failed to induce SyntaxError') # self.fail()?
         self.assertNotIn(self.module_name, sys.modules)
-        self.assertNotHasAttr(sys.modules[self.package_name], 'foo')
+        self.assertFalse(hasattr(sys.modules[self.package_name], 'foo'))
 
         # ...make up a variable name that isn't bound in __builtins__
         var = 'a'
diff --git a/Lib/test/test_importlib/test_spec.py b/Lib/test/test_importlib/test_spec.py
index aebeabaf83f75d..02318926f35eee 100644
--- a/Lib/test/test_importlib/test_spec.py
+++ b/Lib/test/test_importlib/test_spec.py
@@ -237,7 +237,7 @@ def test_exec(self):
         self.spec.loader = NewLoader()
         module = self.util.module_from_spec(self.spec)
         sys.modules[self.name] = module
-        self.assertNotHasAttr(module, 'eggs')
+        self.assertFalse(hasattr(module, 'eggs'))
         self.bootstrap._exec(self.spec, module)
 
         self.assertEqual(module.eggs, 1)
@@ -348,9 +348,9 @@ def test_reload_init_module_attrs(self):
         self.assertIs(loaded.__loader__, self.spec.loader)
         self.assertEqual(loaded.__package__, self.spec.parent)
         self.assertIs(loaded.__spec__, self.spec)
-        self.assertNotHasAttr(loaded, '__path__')
-        self.assertNotHasAttr(loaded, '__file__')
-        self.assertNotHasAttr(loaded, '__cached__')
+        self.assertFalse(hasattr(loaded, '__path__'))
+        self.assertFalse(hasattr(loaded, '__file__'))
+        self.assertFalse(hasattr(loaded, '__cached__'))
 
 
 (Frozen_ModuleSpecMethodsTests,
diff --git a/Lib/test/test_importlib/test_util.py b/Lib/test/test_importlib/test_util.py
index 6332548291987b..0bdd1b4b82e544 100644
--- a/Lib/test/test_importlib/test_util.py
+++ b/Lib/test/test_importlib/test_util.py
@@ -321,7 +321,7 @@ def test_length(self):
 
     def test_incorporates_rn(self):
         # The magic number uses \r\n to come out wrong when splitting on lines.
-        self.assertEndsWith(self.util.MAGIC_NUMBER, b'\r\n')
+        self.assertTrue(self.util.MAGIC_NUMBER.endswith(b'\r\n'))
 
 
 (Frozen_MagicNumberTests,
diff --git a/Lib/test/test_mailbox.py b/Lib/test/test_mailbox.py
index 0169948e453438..3ecb5eab26d4b9 100644
--- a/Lib/test/test_mailbox.py
+++ b/Lib/test/test_mailbox.py
@@ -1303,12 +1303,12 @@ def test_message_separator(self):
         self._box.add('From: foo\n\n0')  # No newline at the end
         with open(self._path, encoding='utf-8') as f:
             data = f.read()
-            self.assertEndsWith(data, '0\n\n')
+            self.assertEqual(data[-3:], '0\n\n')
 
         self._box.add('From: foo\n\n0\n')  # Newline at the end
         with open(self._path, encoding='utf-8') as f:
             data = f.read()
-            self.assertEndsWith(data, '0\n\n')
+            self.assertEqual(data[-3:], '0\n\n')
 
 
 class TestMMDF(_TestMboxMMDF, unittest.TestCase):
@@ -2357,7 +2357,7 @@ def test_empty_maildir(self):
         # Test for regression on bug #117490:
         # Make sure the boxes attribute actually gets set.
         self.mbox = mailbox.Maildir(os_helper.TESTFN)
-        #self.assertHasAttr(self.mbox, "boxes")
+        #self.assertTrue(hasattr(self.mbox, "boxes"))
         #self.assertEqual(len(self.mbox.boxes), 0)
         self.assertIsNone(self.mbox.next())
         self.assertIsNone(self.mbox.next())
diff --git a/Lib/test/test_poplib.py b/Lib/test/test_poplib.py
index 96aa3ffe9b0033..869f9431b928bb 100644
--- a/Lib/test/test_poplib.py
+++ b/Lib/test/test_poplib.py
@@ -257,7 +257,7 @@ def handle_error(self):
 
 class TestPOP3Class(TestCase):
     def assertOK(self, resp):
-        self.assertStartsWith(resp, b"+OK")
+        self.assertTrue(resp.startswith(b"+OK"))
 
     def setUp(self):
         self.server = DummyPOP3Server((HOST, PORT))
@@ -293,7 +293,7 @@ def test_list(self):
         self.assertEqual(self.client.list()[1:],
                          ([b'1 1', b'2 2', b'3 3', b'4 4', b'5 5'],
                           25))
-        self.assertEndsWith(self.client.list('1'), b"OK 1 1")
+        self.assertTrue(self.client.list('1').endswith(b"OK 1 1"))
 
     def test_retr(self):
         expected = (b'+OK 116 bytes',
@@ -428,7 +428,7 @@ def test_context(self):
                                         context=ctx)
         self.assertIsInstance(self.client.sock, ssl.SSLSocket)
         self.assertIs(self.client.sock.context, ctx)
-        self.assertStartsWith(self.client.noop(), b'+OK')
+        self.assertTrue(self.client.noop().startswith(b'+OK'))
 
     def test_stls(self):
         self.assertRaises(poplib.error_proto, self.client.stls)
diff --git a/Lib/test/test_urllib.py b/Lib/test/test_urllib.py
index 946ca4e07d5457..4842428d6fd103 100644
--- a/Lib/test/test_urllib.py
+++ b/Lib/test/test_urllib.py
@@ -120,7 +120,9 @@ def test_interface(self):
         # Make sure object returned by urlopen() has the specified methods
         for attr in ("read", "readline", "readlines", "fileno",
                      "close", "info", "geturl", "getcode", "__iter__"):
-            self.assertHasAttr(self.returned_obj, attr)
+            self.assertTrue(hasattr(self.returned_obj, attr),
+                         "object returned by urlopen() lacks %s attribute" %
+                         attr)
 
     def test_read(self):
         self.assertEqual(self.text, self.returned_obj.read())
@@ -541,7 +543,9 @@ def test_interface(self):
         # Make sure object returned by urlopen() has the specified methods
         for attr in ("read", "readline", "readlines",
                      "close", "info", "geturl", "getcode", "__iter__"):
-            self.assertHasAttr(self.text_url_resp, attr)
+            self.assertTrue(hasattr(self.text_url_resp, attr),
+                         "object returned by urlopen() lacks %s attribute" %
+                         attr)
 
     def test_info(self):
         self.assertIsInstance(self.text_url_resp.info(), email.message.Message)
diff --git a/Lib/test/test_urllib2.py b/Lib/test/test_urllib2.py
index e56cd19160cc4b..44e6af8c6b6868 100644
--- a/Lib/test/test_urllib2.py
+++ b/Lib/test/test_urllib2.py
@@ -1197,15 +1197,15 @@ def test_errors(self):
         r = MockResponse(200, "OK", {}, "", url)
         newr = h.http_response(req, r)
         self.assertIs(r, newr)
-        self.assertNotHasAttr(o, "proto")  # o.error not called
+        self.assertFalse(hasattr(o, "proto"))  # o.error not called
         r = MockResponse(202, "Accepted", {}, "", url)
         newr = h.http_response(req, r)
         self.assertIs(r, newr)
-        self.assertNotHasAttr(o, "proto")  # o.error not called
+        self.assertFalse(hasattr(o, "proto"))  # o.error not called
         r = MockResponse(206, "Partial content", {}, "", url)
         newr = h.http_response(req, r)
         self.assertIs(r, newr)
-        self.assertNotHasAttr(o, "proto")  # o.error not called
+        self.assertFalse(hasattr(o, "proto"))  # o.error not called
         # anything else calls o.error (and MockOpener returns None, here)
         r = MockResponse(502, "Bad gateway", {}, "", url)
         self.assertIsNone(h.http_response(req, r))
@@ -1420,7 +1420,7 @@ def http_open(self, req):
                 response = opener.open('http://example.com/')
                 expected = b'GET ' + result + b' '
                 request = handler.last_buf
-                self.assertStartsWith(request, expected)
+                self.assertTrue(request.startswith(expected), repr(request))
 
     def test_redirect_head_request(self):
         from_url = "http://example.com/a.html"
@@ -1910,9 +1910,9 @@ def test_HTTPError_interface(self):
         url = code = fp = None
         hdrs = 'Content-Length: 42'
         err = urllib.error.HTTPError(url, code, msg, hdrs, fp)
-        self.assertHasAttr(err, 'reason')
+        self.assertTrue(hasattr(err, 'reason'))
         self.assertEqual(err.reason, 'something bad happened')
-        self.assertHasAttr(err, 'headers')
+        self.assertTrue(hasattr(err, 'headers'))
         self.assertEqual(err.headers, 'Content-Length: 42')
         expected_errmsg = 'HTTP Error %s: %s' % (err.code, err.msg)
         self.assertEqual(str(err), expected_errmsg)
diff --git a/Lib/test/test_urllib2_localnet.py b/Lib/test/test_urllib2_localnet.py
index 9186436183aae1..9cb15d61c2ad4d 100644
--- a/Lib/test/test_urllib2_localnet.py
+++ b/Lib/test/test_urllib2_localnet.py
@@ -606,7 +606,8 @@ def test_basic(self):
         handler = self.start_server()
         with urllib.request.urlopen("http://localhost:%s" % handler.port) as open_url:
             for attr in ("read", "close", "info", "geturl"):
-                self.assertHasAttr(open_url, attr)
+                self.assertTrue(hasattr(open_url, attr), "object returned from "
+                             "urlopen lacks the %s attribute" % attr)
             self.assertTrue(open_url.read(), "calling 'read' failed")
 
     def test_info(self):
diff --git a/Lib/test/test_urllibnet.py b/Lib/test/test_urllibnet.py
index 1a42c35dc49b9e..ce4e60e3a8011d 100644
--- a/Lib/test/test_urllibnet.py
+++ b/Lib/test/test_urllibnet.py
@@ -71,7 +71,8 @@ def test_basic(self):
         with self.urlopen(self.url) as open_url:
             for attr in ("read", "readline", "readlines", "fileno", "close",
                          "info", "geturl"):
-                self.assertHasAttr(open_url, attr)
+                self.assertTrue(hasattr(open_url, attr), "object returned from "
+                                "urlopen lacks the %s attribute" % attr)
             self.assertTrue(open_url.read(), "calling 'read' failed")
 
     def test_readlines(self):
diff --git a/Lib/test/test_urlparse.py b/Lib/test/test_urlparse.py
index 56b2a743640568..4516bdea6adb19 100644
--- a/Lib/test/test_urlparse.py
+++ b/Lib/test/test_urlparse.py
@@ -1164,13 +1164,14 @@ def test_parse_fragments(self):
                 with self.subTest(url=url, function=func):
                     result = func(url, allow_fragments=False)
                     self.assertEqual(result.fragment, "")
-                    self.assertEndsWith(getattr(result, attr),
-                                        "#" + expected_frag)
+                    self.assertTrue(
+                            getattr(result, attr).endswith("#" + expected_frag))
                     self.assertEqual(func(url, "", False).fragment, "")
 
                     result = func(url, allow_fragments=True)
                     self.assertEqual(result.fragment, expected_frag)
-                    self.assertNotEndsWith(getattr(result, attr), expected_frag)
+                    self.assertFalse(
+                            getattr(result, attr).endswith(expected_frag))
                     self.assertEqual(func(url, "", True).fragment,
                                      expected_frag)
                     self.assertEqual(func(url).fragment, expected_frag)