diff --git a/django/test/testcases.py b/django/test/testcases.py
index b8d5737..6abbf3b 100644
--- a/django/test/testcases.py
+++ b/django/test/testcases.py
@@ -794,6 +794,26 @@ class TransactionTestCase(SimpleTestCase):
     # are not available, we allow queries to be run.
     allow_database_queries = True
 
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        if not cls.multi_db:
+            for alias in connections:
+                if alias != DEFAULT_DB_ALIAS:
+                    connection = connections[alias]
+                    connection.cursor = _CursorFailure(cls.__name__, connection.cursor)
+                    connection.chunked_cursor = _CursorFailure(cls.__name__, connection.chunked_cursor)
+
+    @classmethod
+    def tearDownClass(cls):
+        super().tearDownClass()
+        if not cls.multi_db:
+            for alias in connections:
+                if alias != DEFAULT_DB_ALIAS:
+                    connection = connections[alias]
+                    connection.cursor = connection.cursor.wrapped
+                    connection.chunked_cursor = connection.chunked_cursor.wrapped
+
     def _pre_setup(self):
         """Performs any pre-test setup. This includes:
 
@@ -943,14 +963,6 @@ class TransactionTestCase(SimpleTestCase):
             func(*args, **kwargs)
 
 
-def connections_support_transactions():
-    """
-    Returns True if all connections support transactions.
-    """
-    return all(conn.features.supports_transactions
-               for conn in connections.all())
-
-
 class TestCase(TransactionTestCase):
     """
     Similar to TransactionTestCase, but uses `transaction.atomic()` to achieve
@@ -981,9 +993,17 @@ class TestCase(TransactionTestCase):
             atomics[db_name].__exit__(None, None, None)
 
     @classmethod
+    def connections_support_transactions(cls):
+        """Return True if all connections support transactions."""
+        return all(
+            connections[db_name].features.supports_transactions
+            for db_name in cls._databases_names()
+        )
+
+    @classmethod
     def setUpClass(cls):
         super().setUpClass()
-        if not connections_support_transactions():
+        if not cls.connections_support_transactions():
             return
         cls.cls_atomics = cls._enter_atomics()
 
@@ -1006,7 +1026,7 @@ class TestCase(TransactionTestCase):
 
     @classmethod
     def tearDownClass(cls):
-        if connections_support_transactions():
+        if cls.connections_support_transactions():
             cls._rollback_atomics(cls.cls_atomics)
             for conn in connections.all():
                 conn.close()
@@ -1018,12 +1038,12 @@ class TestCase(TransactionTestCase):
         pass
 
     def _should_reload_connections(self):
-        if connections_support_transactions():
+        if self.connections_support_transactions():
             return False
         return super()._should_reload_connections()
 
     def _fixture_setup(self):
-        if not connections_support_transactions():
+        if not self.connections_support_transactions():
             # If the backend does not support transactions, we should reload
             # class data before each test
             self.setUpTestData()
@@ -1033,7 +1053,7 @@ class TestCase(TransactionTestCase):
         self.atomics = self._enter_atomics()
 
     def _fixture_teardown(self):
-        if not connections_support_transactions():
+        if not self.connections_support_transactions():
             return super()._fixture_teardown()
         try:
             for db_name in reversed(self._databases_names()):
diff --git a/tests/servers/tests.py b/tests/servers/tests.py
index b114b96..4f4d3fb 100644
--- a/tests/servers/tests.py
+++ b/tests/servers/tests.py
@@ -1,9 +1,7 @@
 """
 Tests for django.core.servers.
 """
-import errno
 import os
-import socket
 from urllib.error import HTTPError
 from urllib.parse import urlencode
 from urllib.request import urlopen
@@ -103,33 +101,7 @@ class LiveServerDatabase(LiveServerBase):
         )
 
 
-class LiveServerPort(LiveServerBase):
-
-    def test_port_bind(self):
-        """
-        Each LiveServerTestCase binds to a unique port or fails to start a
-        server thread when run concurrently (#26011).
-        """
-        TestCase = type("TestCase", (LiveServerBase,), {})
-        try:
-            TestCase.setUpClass()
-        except socket.error as e:
-            if e.errno == errno.EADDRINUSE:
-                # We're out of ports, LiveServerTestCase correctly fails with
-                # a socket error.
-                return
-            # Unexpected error.
-            raise
-        try:
-            # We've acquired a port, ensure our server threads acquired
-            # different addresses.
-            self.assertNotEqual(
-                self.live_server_url, TestCase.live_server_url,
-                "Acquired duplicate server addresses for server threads: %s" % self.live_server_url
-            )
-        finally:
-            if hasattr(TestCase, 'server_thread'):
-                TestCase.server_thread.terminate()
+# Remove for debugging purposes since this test isn't isolated
 
 
 class LiverServerThreadedTests(LiveServerBase):
diff --git a/tests/test_runner/tests.py b/tests/test_runner/tests.py
index 708a7c2..63194dc 100644
--- a/tests/test_runner/tests.py
+++ b/tests/test_runner/tests.py
@@ -14,7 +14,6 @@ from django.test import (
     TestCase, TransactionTestCase, skipUnlessDBFeature, testcases,
 )
 from django.test.runner import DiscoverRunner
-from django.test.testcases import connections_support_transactions
 from django.test.utils import dependency_ordered
 
 from .models import Person
@@ -229,7 +228,6 @@ class Sqlite3InMemoryTestDbs(TestCase):
                     # Transaction support should be properly initialized for the 'other' DB
                     self.assertTrue(other.features.supports_transactions, msg)
                     # And all the DBs should report that they support transactions
-                    self.assertTrue(connections_support_transactions(), msg)
 
 
 class DummyBackendTest(unittest.TestCase):
@@ -358,4 +356,3 @@ class EmptyDefaultDatabaseTest(unittest.TestCase):
         testcases.connections = db.ConnectionHandler({'default': {}})
         connection = testcases.connections[db.utils.DEFAULT_DB_ALIAS]
         self.assertEqual(connection.settings_dict['ENGINE'], 'django.db.backends.dummy')
-        connections_support_transactions()
diff --git a/tests/test_utils/tests.py b/tests/test_utils/tests.py
index 19ef405..242bea4 100644
--- a/tests/test_utils/tests.py
+++ b/tests/test_utils/tests.py
@@ -1022,11 +1022,11 @@ class TestBadSetUpTestData(TestCase):
             cls._in_atomic_block = connection.in_atomic_block
 
     @classmethod
-    def tearDownClass(Cls):
+    def tearDownClass(cls):
         # override to avoid a second cls._rollback_atomics() which would fail.
         # Normal setUpClass() methods won't have exception handling so this
         # method wouldn't typically be run.
-        pass
+        super(TestCase, cls).tearDownClass()
 
     @classmethod
     def setUpTestData(cls):
