Refs #33476 -- Reformatted code with Black.

7 files changed, 653 insertions, 563 deletions

diff --git a/tests/test_utils/models.py b/tests/test_utils/models.py
index 57518aef90..4d91c03a03 100644
--- a/tests/test_utils/models.py
+++ b/tests/test_utils/models.py
@@ -7,10 +7,12 @@ class Car(models.Model):
 
 class Person(models.Model):
     name = models.CharField(max_length=100)
-    cars = models.ManyToManyField(Car, through='PossessedCar')
+    cars = models.ManyToManyField(Car, through="PossessedCar")
     data = models.BinaryField(null=True)
 
 
 class PossessedCar(models.Model):
     car = models.ForeignKey(Car, models.CASCADE)
-    belongs_to = models.ForeignKey(Person, models.CASCADE, related_name='possessed_cars')
+    belongs_to = models.ForeignKey(
+        Person, models.CASCADE, related_name="possessed_cars"
+    )
diff --git a/tests/test_utils/test_serializemixin.py b/tests/test_utils/test_serializemixin.py
index 662ba71ca0..e15334a867 100644
--- a/tests/test_utils/test_serializemixin.py
+++ b/tests/test_utils/test_serializemixin.py
@@ -9,6 +9,7 @@ class TestSerializeMixin(SimpleTestCase):
             "base class."
         )
         with self.assertRaisesMessage(ValueError, msg):
+
             class ExampleTests(SerializeMixin, SimpleTestCase):
                 pass
 
diff --git a/tests/test_utils/test_simpletestcase.py b/tests/test_utils/test_simpletestcase.py
index 76ec37e80f..c6aa314944 100644
--- a/tests/test_utils/test_simpletestcase.py
+++ b/tests/test_utils/test_simpletestcase.py
@@ -9,18 +9,18 @@ from django.test import SimpleTestCase
 class ErrorTestCase(SimpleTestCase):
     def raising_test(self):
         self._pre_setup.assert_called_once_with()
-        raise Exception('debug() bubbles up exceptions before cleanup.')
+        raise Exception("debug() bubbles up exceptions before cleanup.")
 
     def simple_test(self):
         self._pre_setup.assert_called_once_with()
 
-    @unittest.skip('Skip condition.')
+    @unittest.skip("Skip condition.")
     def skipped_test(self):
         pass
 
 
-@mock.patch.object(ErrorTestCase, '_post_teardown')
-@mock.patch.object(ErrorTestCase, '_pre_setup')
+@mock.patch.object(ErrorTestCase, "_post_teardown")
+@mock.patch.object(ErrorTestCase, "_pre_setup")
 class DebugInvocationTests(SimpleTestCase):
     def get_runner(self):
         return unittest.TextTestRunner(stream=StringIO())
@@ -33,58 +33,60 @@ class DebugInvocationTests(SimpleTestCase):
     def test_run_cleanup(self, _pre_setup, _post_teardown):
         """Simple test run: catches errors and runs cleanup."""
         test_suite = unittest.TestSuite()
-        test_suite.addTest(ErrorTestCase('raising_test'))
+        test_suite.addTest(ErrorTestCase("raising_test"))
         result = self.get_runner()._makeResult()
         self.assertEqual(result.errors, [])
         test_suite.run(result)
         self.assertEqual(len(result.errors), 1)
         _, traceback = result.errors[0]
-        self.assertIn('Exception: debug() bubbles up exceptions before cleanup.', traceback)
+        self.assertIn(
+            "Exception: debug() bubbles up exceptions before cleanup.", traceback
+        )
         _pre_setup.assert_called_once_with()
         _post_teardown.assert_called_once_with()
 
     def test_run_pre_setup_error(self, _pre_setup, _post_teardown):
-        _pre_setup.side_effect = Exception('Exception in _pre_setup.')
+        _pre_setup.side_effect = Exception("Exception in _pre_setup.")
         test_suite = unittest.TestSuite()
-        test_suite.addTest(ErrorTestCase('simple_test'))
+        test_suite.addTest(ErrorTestCase("simple_test"))
         result = self.get_runner()._makeResult()
         self.assertEqual(result.errors, [])
         test_suite.run(result)
         self.assertEqual(len(result.errors), 1)
         _, traceback = result.errors[0]
-        self.assertIn('Exception: Exception in _pre_setup.', traceback)
+        self.assertIn("Exception: Exception in _pre_setup.", traceback)
         # pre-setup is called but not post-teardown.
         _pre_setup.assert_called_once_with()
         self.assertFalse(_post_teardown.called)
 
     def test_run_post_teardown_error(self, _pre_setup, _post_teardown):
-        _post_teardown.side_effect = Exception('Exception in _post_teardown.')
+        _post_teardown.side_effect = Exception("Exception in _post_teardown.")
         test_suite = unittest.TestSuite()
-        test_suite.addTest(ErrorTestCase('simple_test'))
+        test_suite.addTest(ErrorTestCase("simple_test"))
         result = self.get_runner()._makeResult()
         self.assertEqual(result.errors, [])
         test_suite.run(result)
         self.assertEqual(len(result.errors), 1)
         _, traceback = result.errors[0]
-        self.assertIn('Exception: Exception in _post_teardown.', traceback)
+        self.assertIn("Exception: Exception in _post_teardown.", traceback)
         # pre-setup and post-teardwn are called.
         _pre_setup.assert_called_once_with()
         _post_teardown.assert_called_once_with()
 
     def test_run_skipped_test_no_cleanup(self, _pre_setup, _post_teardown):
         test_suite = unittest.TestSuite()
-        test_suite.addTest(ErrorTestCase('skipped_test'))
+        test_suite.addTest(ErrorTestCase("skipped_test"))
         try:
             test_suite.run(self.get_runner()._makeResult())
         except unittest.SkipTest:
-            self.fail('SkipTest should not be raised at this stage.')
+            self.fail("SkipTest should not be raised at this stage.")
         self.assertFalse(_post_teardown.called)
         self.assertFalse(_pre_setup.called)
 
     def test_debug_cleanup(self, _pre_setup, _post_teardown):
         """Simple debug run without errors."""
         test_suite = unittest.TestSuite()
-        test_suite.addTest(ErrorTestCase('simple_test'))
+        test_suite.addTest(ErrorTestCase("simple_test"))
         test_suite.debug()
         _pre_setup.assert_called_once_with()
         _post_teardown.assert_called_once_with()
@@ -92,8 +94,8 @@ class DebugInvocationTests(SimpleTestCase):
     def test_debug_bubbles_error(self, _pre_setup, _post_teardown):
         """debug() bubbles up exceptions before cleanup."""
         test_suite = unittest.TestSuite()
-        test_suite.addTest(ErrorTestCase('raising_test'))
-        msg = 'debug() bubbles up exceptions before cleanup.'
+        test_suite.addTest(ErrorTestCase("raising_test"))
+        msg = "debug() bubbles up exceptions before cleanup."
         with self.assertRaisesMessage(Exception, msg):
             # This is the same as test_suite.debug().
             result = _DebugResult()
@@ -105,10 +107,10 @@ class DebugInvocationTests(SimpleTestCase):
 
     def test_debug_bubbles_pre_setup_error(self, _pre_setup, _post_teardown):
         """debug() bubbles up exceptions during _pre_setup."""
-        msg = 'Exception in _pre_setup.'
+        msg = "Exception in _pre_setup."
         _pre_setup.side_effect = Exception(msg)
         test_suite = unittest.TestSuite()
-        test_suite.addTest(ErrorTestCase('simple_test'))
+        test_suite.addTest(ErrorTestCase("simple_test"))
         with self.assertRaisesMessage(Exception, msg):
             # This is the same as test_suite.debug().
             result = _DebugResult()
@@ -120,10 +122,10 @@ class DebugInvocationTests(SimpleTestCase):
 
     def test_debug_bubbles_post_teardown_error(self, _pre_setup, _post_teardown):
         """debug() bubbles up exceptions during _post_teardown."""
-        msg = 'Exception in _post_teardown.'
+        msg = "Exception in _post_teardown."
         _post_teardown.side_effect = Exception(msg)
         test_suite = unittest.TestSuite()
-        test_suite.addTest(ErrorTestCase('simple_test'))
+        test_suite.addTest(ErrorTestCase("simple_test"))
         with self.assertRaisesMessage(Exception, msg):
             # This is the same as test_suite.debug().
             result = _DebugResult()
@@ -135,8 +137,8 @@ class DebugInvocationTests(SimpleTestCase):
 
     def test_debug_skipped_test_no_cleanup(self, _pre_setup, _post_teardown):
         test_suite = unittest.TestSuite()
-        test_suite.addTest(ErrorTestCase('skipped_test'))
-        with self.assertRaisesMessage(unittest.SkipTest, 'Skip condition.'):
+        test_suite.addTest(ErrorTestCase("skipped_test"))
+        with self.assertRaisesMessage(unittest.SkipTest, "Skip condition."):
             # This is the same as test_suite.debug().
             result = _DebugResult()
             test_suite.run(result, debug=True)
diff --git a/tests/test_utils/test_testcase.py b/tests/test_utils/test_testcase.py
index dbf609b8fe..ca142186a1 100644
--- a/tests/test_utils/test_testcase.py
+++ b/tests/test_utils/test_testcase.py
@@ -8,9 +8,8 @@ from .models import Car, Person, PossessedCar
 
 
 class TestTestCase(TestCase):
-
-    @skipUnlessDBFeature('can_defer_constraint_checks')
-    @skipUnlessDBFeature('supports_foreign_keys')
+    @skipUnlessDBFeature("can_defer_constraint_checks")
+    @skipUnlessDBFeature("supports_foreign_keys")
     def test_fixture_teardown_checks_constraints(self):
         rollback_atomics = self._rollback_atomics
         self._rollback_atomics = lambda connection: None  # noop
@@ -29,9 +28,9 @@ class TestTestCase(TestCase):
             "ensure proper test isolation and silence this failure."
         )
         with self.assertRaisesMessage(DatabaseOperationForbidden, message):
-            connections['other'].connect()
+            connections["other"].connect()
         with self.assertRaisesMessage(DatabaseOperationForbidden, message):
-            connections['other'].temporary_connection()
+            connections["other"].temporary_connection()
 
     def test_disallowed_database_queries(self):
         message = (
@@ -40,12 +39,12 @@ class TestTestCase(TestCase):
             "ensure proper test isolation and silence this failure."
         )
         with self.assertRaisesMessage(DatabaseOperationForbidden, message):
-            Car.objects.using('other').get()
+            Car.objects.using("other").get()
 
     def test_reset_sequences(self):
         old_reset_sequences = self.reset_sequences
         self.reset_sequences = True
-        msg = 'reset_sequences cannot be used on TestCase instances'
+        msg = "reset_sequences cannot be used on TestCase instances"
         try:
             with self.assertRaisesMessage(TypeError, msg):
                 self._fixture_setup()
@@ -58,6 +57,7 @@ def assert_no_queries(test):
     def inner(self):
         with self.assertNumQueries(0):
             test(self)
+
     return inner
 
 
@@ -67,14 +67,14 @@ class TestDataTests(TestCase):
 
     @classmethod
     def setUpTestData(cls):
-        cls.jim_douglas = Person.objects.create(name='Jim Douglas')
-        cls.car = Car.objects.create(name='1963 Volkswagen Beetle')
+        cls.jim_douglas = Person.objects.create(name="Jim Douglas")
+        cls.car = Car.objects.create(name="1963 Volkswagen Beetle")
         cls.herbie = cls.jim_douglas.possessed_cars.create(
             car=cls.car,
             belongs_to=cls.jim_douglas,
         )
 
-        cls.person_binary = Person.objects.create(name='Person', data=b'binary data')
+        cls.person_binary = Person.objects.create(name="Person", data=b"binary data")
         cls.person_binary_get = Person.objects.get(pk=cls.person_binary.pk)
 
     @assert_no_queries
@@ -95,8 +95,8 @@ class TestDataTests(TestCase):
 
     @assert_no_queries
     def test_binaryfield_data_type(self):
-        self.assertEqual(bytes(self.person_binary.data), b'binary data')
-        self.assertEqual(bytes(self.person_binary_get.data), b'binary data')
+        self.assertEqual(bytes(self.person_binary.data), b"binary data")
+        self.assertEqual(bytes(self.person_binary_get.data), b"binary data")
         self.assertEqual(
             type(self.person_binary_get.data),
             type(self.__class__.person_binary_get.data),
@@ -119,7 +119,7 @@ class TestDataTests(TestCase):
 
     def test_repr(self):
         self.assertEqual(
-            repr(TestData('attr', 'value')),
+            repr(TestData("attr", "value")),
             "<TestData: name='attr', data='value'>",
         )
 
@@ -129,16 +129,17 @@ class SetupTestDataIsolationTests(TestCase):
     In-memory data isolation is respected for model instances assigned to class
     attributes during setUpTestData.
     """
+
     @classmethod
     def setUpTestData(cls):
-        cls.car = Car.objects.create(name='Volkswagen Beetle')
+        cls.car = Car.objects.create(name="Volkswagen Beetle")
 
     def test_book_name_deutsh(self):
-        self.assertEqual(self.car.name, 'Volkswagen Beetle')
-        self.car.name = 'VW sKäfer'
+        self.assertEqual(self.car.name, "Volkswagen Beetle")
+        self.car.name = "VW sKäfer"
         self.car.save()
 
     def test_book_name_french(self):
-        self.assertEqual(self.car.name, 'Volkswagen Beetle')
-        self.car.name = 'Volkswagen Coccinelle'
+        self.assertEqual(self.car.name, "Volkswagen Beetle")
+        self.car.name = "Volkswagen Coccinelle"
         self.car.save()
diff --git a/tests/test_utils/test_transactiontestcase.py b/tests/test_utils/test_transactiontestcase.py
index f1f53e4da5..0032e2ee0c 100644
--- a/tests/test_utils/test_transactiontestcase.py
+++ b/tests/test_utils/test_transactiontestcase.py
@@ -12,7 +12,8 @@ class TestSerializedRollbackInhibitsPostMigrate(TransactionTestCase):
     TransactionTestCase._fixture_teardown() inhibits the post_migrate signal
     for test classes with serialized_rollback=True.
     """
-    available_apps = ['test_utils']
+
+    available_apps = ["test_utils"]
     serialized_rollback = True
 
     def setUp(self):
@@ -21,23 +22,27 @@ class TestSerializedRollbackInhibitsPostMigrate(TransactionTestCase):
         self.available_apps = None
 
     def tearDown(self):
-        self.available_apps = ['test_utils']
+        self.available_apps = ["test_utils"]
 
-    @mock.patch('django.test.testcases.call_command')
+    @mock.patch("django.test.testcases.call_command")
     def test(self, call_command):
         # with a mocked call_command(), this doesn't have any effect.
         self._fixture_teardown()
         call_command.assert_called_with(
-            'flush', interactive=False, allow_cascade=False,
-            reset_sequences=False, inhibit_post_migrate=True,
-            database='default', verbosity=0,
+            "flush",
+            interactive=False,
+            allow_cascade=False,
+            reset_sequences=False,
+            inhibit_post_migrate=True,
+            database="default",
+            verbosity=0,
         )
 
 
 @override_settings(DEBUG=True)  # Enable query logging for test_queries_cleared
 class TransactionTestCaseDatabasesTests(TestCase):
     available_apps = []
-    databases = {'default', 'other'}
+    databases = {"default", "other"}
 
     def test_queries_cleared(self):
         """
@@ -46,11 +51,13 @@ class TransactionTestCaseDatabasesTests(TestCase):
         assertNumQueries() to fail.
         """
         for alias in self.databases:
-            self.assertEqual(len(connections[alias].queries_log), 0, 'Failed for alias %s' % alias)
+            self.assertEqual(
+                len(connections[alias].queries_log), 0, "Failed for alias %s" % alias
+            )
 
 
 class DisallowedDatabaseQueriesTests(TransactionTestCase):
-    available_apps = ['test_utils']
+    available_apps = ["test_utils"]
 
     def test_disallowed_database_queries(self):
         message = (
@@ -60,4 +67,4 @@ class DisallowedDatabaseQueriesTests(TransactionTestCase):
             "isolation and silence this failure."
         )
         with self.assertRaisesMessage(DatabaseOperationForbidden, message):
-            Car.objects.using('other').get()
+            Car.objects.using("other").get()
diff --git a/tests/test_utils/tests.py b/tests/test_utils/tests.py
index 0da45d9f64..72183838b7 100644
--- a/tests/test_utils/tests.py
+++ b/tests/test_utils/tests.py
@@ -11,23 +11,39 @@ from django.contrib.staticfiles.storage import staticfiles_storage
 from django.core.exceptions import ImproperlyConfigured
 from django.core.files.storage import default_storage
 from django.db import (
-    IntegrityError, connection, connections, models, router, transaction,
+    IntegrityError,
+    connection,
+    connections,
+    models,
+    router,
+    transaction,
 )
 from django.forms import (
-    CharField, EmailField, Form, IntegerField, ValidationError,
+    CharField,
+    EmailField,
+    Form,
+    IntegerField,
+    ValidationError,
     formset_factory,
 )
 from django.http import HttpResponse
 from django.template.loader import render_to_string
 from django.test import (
-    SimpleTestCase, TestCase, TransactionTestCase, skipIfDBFeature,
+    SimpleTestCase,
+    TestCase,
+    TransactionTestCase,
+    skipIfDBFeature,
     skipUnlessDBFeature,
 )
 from django.test.html import HTMLParseError, parse_html
 from django.test.testcases import DatabaseOperationForbidden
 from django.test.utils import (
-    CaptureQueriesContext, TestContextDecorator, ignore_warnings, isolate_apps,
-    override_settings, setup_test_environment,
+    CaptureQueriesContext,
+    TestContextDecorator,
+    ignore_warnings,
+    isolate_apps,
+    override_settings,
+    setup_test_environment,
 )
 from django.urls import NoReverseMatch, path, reverse, reverse_lazy
 from django.utils.deprecation import RemovedInDjango50Warning
@@ -47,7 +63,7 @@ class SkippingTestCase(SimpleTestCase):
                 with self.assertRaises(expected_exc):
                     func()
         except unittest.SkipTest:
-            self.fail('%s should not result in a skipped test.' % func.__name__)
+            self.fail("%s should not result in a skipped test." % func.__name__)
 
     def test_skip_unless_db_feature(self):
         """
@@ -76,23 +92,24 @@ class SkippingTestCase(SimpleTestCase):
         self._assert_skipping(test_func4, unittest.SkipTest)
 
         class SkipTestCase(SimpleTestCase):
-            @skipUnlessDBFeature('missing')
+            @skipUnlessDBFeature("missing")
             def test_foo(self):
                 pass
 
         self._assert_skipping(
-            SkipTestCase('test_foo').test_foo,
+            SkipTestCase("test_foo").test_foo,
             ValueError,
             "skipUnlessDBFeature cannot be used on test_foo (test_utils.tests."
             "SkippingTestCase.test_skip_unless_db_feature.<locals>.SkipTestCase) "
             "as SkippingTestCase.test_skip_unless_db_feature.<locals>.SkipTestCase "
-            "doesn't allow queries against the 'default' database."
+            "doesn't allow queries against the 'default' database.",
         )
 
     def test_skip_if_db_feature(self):
         """
         Testing the django.test.skipIfDBFeature decorator.
         """
+
         @skipIfDBFeature("__class__")
         def test_func():
             raise ValueError
@@ -120,17 +137,17 @@ class SkippingTestCase(SimpleTestCase):
         self._assert_skipping(test_func5, ValueError)
 
         class SkipTestCase(SimpleTestCase):
-            @skipIfDBFeature('missing')
+            @skipIfDBFeature("missing")
             def test_foo(self):
                 pass
 
         self._assert_skipping(
-            SkipTestCase('test_foo').test_foo,
+            SkipTestCase("test_foo").test_foo,
             ValueError,
             "skipIfDBFeature cannot be used on test_foo (test_utils.tests."
             "SkippingTestCase.test_skip_if_db_feature.<locals>.SkipTestCase) "
             "as SkippingTestCase.test_skip_if_db_feature.<locals>.SkipTestCase "
-            "doesn't allow queries against the 'default' database."
+            "doesn't allow queries against the 'default' database.",
         )
 
 
@@ -152,27 +169,27 @@ class SkippingClassTestCase(TestCase):
             pass
 
         test_suite = unittest.TestSuite()
-        test_suite.addTest(NotSkippedTests('test_dummy'))
+        test_suite.addTest(NotSkippedTests("test_dummy"))
         try:
-            test_suite.addTest(SkippedTests('test_will_be_skipped'))
-            test_suite.addTest(SkippedTestsSubclass('test_will_be_skipped'))
+            test_suite.addTest(SkippedTests("test_will_be_skipped"))
+            test_suite.addTest(SkippedTestsSubclass("test_will_be_skipped"))
         except unittest.SkipTest:
-            self.fail('SkipTest should not be raised here.')
+            self.fail("SkipTest should not be raised here.")
         result = unittest.TextTestRunner(stream=StringIO()).run(test_suite)
         self.assertEqual(result.testsRun, 3)
         self.assertEqual(len(result.skipped), 2)
-        self.assertEqual(result.skipped[0][1], 'Database has feature(s) __class__')
-        self.assertEqual(result.skipped[1][1], 'Database has feature(s) __class__')
+        self.assertEqual(result.skipped[0][1], "Database has feature(s) __class__")
+        self.assertEqual(result.skipped[1][1], "Database has feature(s) __class__")
 
     def test_missing_default_databases(self):
-        @skipIfDBFeature('missing')
+        @skipIfDBFeature("missing")
         class MissingDatabases(SimpleTestCase):
             def test_assertion_error(self):
                 pass
 
         suite = unittest.TestSuite()
         try:
-            suite.addTest(MissingDatabases('test_assertion_error'))
+            suite.addTest(MissingDatabases("test_assertion_error"))
         except unittest.SkipTest:
             self.fail("SkipTest should not be raised at this stage")
         runner = unittest.TextTestRunner(stream=StringIO())
@@ -186,9 +203,8 @@ class SkippingClassTestCase(TestCase):
             runner.run(suite)
 
 
-@override_settings(ROOT_URLCONF='test_utils.urls')
+@override_settings(ROOT_URLCONF="test_utils.urls")
 class AssertNumQueriesTests(TestCase):
-
     def test_assert_num_queries(self):
         def test_func():
             raise ValueError
@@ -197,29 +213,26 @@ class AssertNumQueriesTests(TestCase):
             self.assertNumQueries(2, test_func)
 
     def test_assert_num_queries_with_client(self):
-        person = Person.objects.create(name='test')
+        person = Person.objects.create(name="test")
 
         self.assertNumQueries(
-            1,
-            self.client.get,
-            "/test_utils/get_person/%s/" % person.pk
+            1, self.client.get, "/test_utils/get_person/%s/" % person.pk
         )
 
         self.assertNumQueries(
-            1,
-            self.client.get,
-            "/test_utils/get_person/%s/" % person.pk
+            1, self.client.get, "/test_utils/get_person/%s/" % person.pk
         )
 
         def test_func():
             self.client.get("/test_utils/get_person/%s/" % person.pk)
             self.client.get("/test_utils/get_person/%s/" % person.pk)
+
         self.assertNumQueries(2, test_func)
 
 
 @unittest.skipUnless(
-    connection.vendor != 'sqlite' or not connection.is_in_memory_db(),
-    'For SQLite in-memory tests, closing the connection destroys the database.'
+    connection.vendor != "sqlite" or not connection.is_in_memory_db(),
+    "For SQLite in-memory tests, closing the connection destroys the database.",
 )
 class AssertNumQueriesUponConnectionTests(TransactionTestCase):
     available_apps = []
@@ -236,9 +249,11 @@ class AssertNumQueriesUponConnectionTests(TransactionTestCase):
                 # Avoid infinite recursion. Creating a cursor calls
                 # ensure_connection() which is currently mocked by this method.
                 with connection.cursor() as cursor:
-                    cursor.execute('SELECT 1' + connection.features.bare_select_suffix)
+                    cursor.execute("SELECT 1" + connection.features.bare_select_suffix)
 
-        ensure_connection = 'django.db.backends.base.base.BaseDatabaseWrapper.ensure_connection'
+        ensure_connection = (
+            "django.db.backends.base.base.BaseDatabaseWrapper.ensure_connection"
+        )
         with mock.patch(ensure_connection, side_effect=make_configuration_query):
             with self.assertNumQueries(1):
                 list(Car.objects.all())
@@ -247,47 +262,45 @@ class AssertNumQueriesUponConnectionTests(TransactionTestCase):
 class AssertQuerysetEqualTests(TestCase):
     @classmethod
     def setUpTestData(cls):
-        cls.p1 = Person.objects.create(name='p1')
-        cls.p2 = Person.objects.create(name='p2')
+        cls.p1 = Person.objects.create(name="p1")
+        cls.p2 = Person.objects.create(name="p2")
 
     def test_empty(self):
-        self.assertQuerysetEqual(Person.objects.filter(name='p3'), [])
+        self.assertQuerysetEqual(Person.objects.filter(name="p3"), [])
 
     def test_ordered(self):
         self.assertQuerysetEqual(
-            Person.objects.all().order_by('name'),
+            Person.objects.all().order_by("name"),
             [self.p1, self.p2],
         )
 
     def test_unordered(self):
         self.assertQuerysetEqual(
-            Person.objects.all().order_by('name'),
-            [self.p2, self.p1],
-            ordered=False
+            Person.objects.all().order_by("name"), [self.p2, self.p1], ordered=False
         )
 
     def test_queryset(self):
         self.assertQuerysetEqual(
-            Person.objects.all().order_by('name'),
-            Person.objects.all().order_by('name'),
+            Person.objects.all().order_by("name"),
+            Person.objects.all().order_by("name"),
         )
 
     def test_flat_values_list(self):
         self.assertQuerysetEqual(
-            Person.objects.all().order_by('name').values_list('name', flat=True),
-            ['p1', 'p2'],
+            Person.objects.all().order_by("name").values_list("name", flat=True),
+            ["p1", "p2"],
         )
 
     def test_transform(self):
         self.assertQuerysetEqual(
-            Person.objects.all().order_by('name'),
+            Person.objects.all().order_by("name"),
             [self.p1.pk, self.p2.pk],
-            transform=lambda x: x.pk
+            transform=lambda x: x.pk,
         )
 
     def test_repr_transform(self):
         self.assertQuerysetEqual(
-            Person.objects.all().order_by('name'),
+            Person.objects.all().order_by("name"),
             [repr(self.p1), repr(self.p2)],
             transform=repr,
         )
@@ -296,8 +309,8 @@ class AssertQuerysetEqualTests(TestCase):
         # Using an unordered queryset with more than one ordered value
         # is an error.
         msg = (
-            'Trying to compare non-ordered queryset against more than one '
-            'ordered value.'
+            "Trying to compare non-ordered queryset against more than one "
+            "ordered value."
         )
         with self.assertRaisesMessage(ValueError, msg):
             self.assertQuerysetEqual(
@@ -305,55 +318,53 @@ class AssertQuerysetEqualTests(TestCase):
                 [self.p1, self.p2],
             )
         # No error for one value.
-        self.assertQuerysetEqual(Person.objects.filter(name='p1'), [self.p1])
+        self.assertQuerysetEqual(Person.objects.filter(name="p1"), [self.p1])
 
     def test_repeated_values(self):
         """
         assertQuerysetEqual checks the number of appearance of each item
         when used with option ordered=False.
         """
-        batmobile = Car.objects.create(name='Batmobile')
-        k2000 = Car.objects.create(name='K 2000')
-        PossessedCar.objects.bulk_create([
-            PossessedCar(car=batmobile, belongs_to=self.p1),
-            PossessedCar(car=batmobile, belongs_to=self.p1),
-            PossessedCar(car=k2000, belongs_to=self.p1),
-            PossessedCar(car=k2000, belongs_to=self.p1),
-            PossessedCar(car=k2000, belongs_to=self.p1),
-            PossessedCar(car=k2000, belongs_to=self.p1),
-        ])
+        batmobile = Car.objects.create(name="Batmobile")
+        k2000 = Car.objects.create(name="K 2000")
+        PossessedCar.objects.bulk_create(
+            [
+                PossessedCar(car=batmobile, belongs_to=self.p1),
+                PossessedCar(car=batmobile, belongs_to=self.p1),
+                PossessedCar(car=k2000, belongs_to=self.p1),
+                PossessedCar(car=k2000, belongs_to=self.p1),
+                PossessedCar(car=k2000, belongs_to=self.p1),
+                PossessedCar(car=k2000, belongs_to=self.p1),
+            ]
+        )
         with self.assertRaises(AssertionError):
             self.assertQuerysetEqual(
-                self.p1.cars.all(),
-                [batmobile, k2000],
-                ordered=False
+                self.p1.cars.all(), [batmobile, k2000], ordered=False
             )
         self.assertQuerysetEqual(
-            self.p1.cars.all(),
-            [batmobile] * 2 + [k2000] * 4,
-            ordered=False
+            self.p1.cars.all(), [batmobile] * 2 + [k2000] * 4, ordered=False
         )
 
     def test_maxdiff(self):
-        names = ['Joe Smith %s' % i for i in range(20)]
+        names = ["Joe Smith %s" % i for i in range(20)]
         Person.objects.bulk_create([Person(name=name) for name in names])
-        names.append('Extra Person')
+        names.append("Extra Person")
 
         with self.assertRaises(AssertionError) as ctx:
             self.assertQuerysetEqual(
-                Person.objects.filter(name__startswith='Joe'),
+                Person.objects.filter(name__startswith="Joe"),
                 names,
                 ordered=False,
                 transform=lambda p: p.name,
             )
-        self.assertIn('Set self.maxDiff to None to see it.', str(ctx.exception))
+        self.assertIn("Set self.maxDiff to None to see it.", str(ctx.exception))
 
         original = self.maxDiff
         self.maxDiff = None
         try:
             with self.assertRaises(AssertionError) as ctx:
                 self.assertQuerysetEqual(
-                    Person.objects.filter(name__startswith='Joe'),
+                    Person.objects.filter(name__startswith="Joe"),
                     names,
                     ordered=False,
                     transform=lambda p: p.name,
@@ -361,23 +372,22 @@ class AssertQuerysetEqualTests(TestCase):
         finally:
             self.maxDiff = original
         exception_msg = str(ctx.exception)
-        self.assertNotIn('Set self.maxDiff to None to see it.', exception_msg)
+        self.assertNotIn("Set self.maxDiff to None to see it.", exception_msg)
         for name in names:
             self.assertIn(name, exception_msg)
 
 
-@override_settings(ROOT_URLCONF='test_utils.urls')
+@override_settings(ROOT_URLCONF="test_utils.urls")
 class CaptureQueriesContextManagerTests(TestCase):
-
     @classmethod
     def setUpTestData(cls):
-        cls.person_pk = str(Person.objects.create(name='test').pk)
+        cls.person_pk = str(Person.objects.create(name="test").pk)
 
     def test_simple(self):
         with CaptureQueriesContext(connection) as captured_queries:
             Person.objects.get(pk=self.person_pk)
         self.assertEqual(len(captured_queries), 1)
-        self.assertIn(self.person_pk, captured_queries[0]['sql'])
+        self.assertIn(self.person_pk, captured_queries[0]["sql"])
 
         with CaptureQueriesContext(connection) as captured_queries:
             pass
@@ -387,7 +397,7 @@ class CaptureQueriesContextManagerTests(TestCase):
         with CaptureQueriesContext(connection) as captured_queries:
             Person.objects.get(pk=self.person_pk)
             self.assertEqual(len(captured_queries), 1)
-            self.assertIn(self.person_pk, captured_queries[0]['sql'])
+            self.assertIn(self.person_pk, captured_queries[0]["sql"])
 
     def test_nested(self):
         with CaptureQueriesContext(connection) as captured_queries:
@@ -406,24 +416,23 @@ class CaptureQueriesContextManagerTests(TestCase):
         with CaptureQueriesContext(connection) as captured_queries:
             self.client.get("/test_utils/get_person/%s/" % self.person_pk)
         self.assertEqual(len(captured_queries), 1)
-        self.assertIn(self.person_pk, captured_queries[0]['sql'])
+        self.assertIn(self.person_pk, captured_queries[0]["sql"])
 
         with CaptureQueriesContext(connection) as captured_queries:
             self.client.get("/test_utils/get_person/%s/" % self.person_pk)
         self.assertEqual(len(captured_queries), 1)
-        self.assertIn(self.person_pk, captured_queries[0]['sql'])
+        self.assertIn(self.person_pk, captured_queries[0]["sql"])
 
         with CaptureQueriesContext(connection) as captured_queries:
             self.client.get("/test_utils/get_person/%s/" % self.person_pk)
             self.client.get("/test_utils/get_person/%s/" % self.person_pk)
         self.assertEqual(len(captured_queries), 2)
-        self.assertIn(self.person_pk, captured_queries[0]['sql'])
-        self.assertIn(self.person_pk, captured_queries[1]['sql'])
+        self.assertIn(self.person_pk, captured_queries[0]["sql"])
+        self.assertIn(self.person_pk, captured_queries[1]["sql"])
 
 
-@override_settings(ROOT_URLCONF='test_utils.urls')
+@override_settings(ROOT_URLCONF="test_utils.urls")
 class AssertNumQueriesContextManagerTests(TestCase):
-
     def test_simple(self):
         with self.assertNumQueries(0):
             pass
@@ -436,9 +445,7 @@ class AssertNumQueriesContextManagerTests(TestCase):
             Person.objects.count()
 
     def test_failure(self):
-        msg = (
-            '1 != 2 : 1 queries executed, 2 expected\nCaptured queries were:\n1.'
-        )
+        msg = "1 != 2 : 1 queries executed, 2 expected\nCaptured queries were:\n1."
         with self.assertRaisesMessage(AssertionError, msg):
             with self.assertNumQueries(2):
                 Person.objects.count()
@@ -461,60 +468,59 @@ class AssertNumQueriesContextManagerTests(TestCase):
             self.client.get("/test_utils/get_person/%s/" % person.pk)
 
 
-@override_settings(ROOT_URLCONF='test_utils.urls')
+@override_settings(ROOT_URLCONF="test_utils.urls")
 class AssertTemplateUsedContextManagerTests(SimpleTestCase):
-
     def test_usage(self):
-        with self.assertTemplateUsed('template_used/base.html'):
-            render_to_string('template_used/base.html')
+        with self.assertTemplateUsed("template_used/base.html"):
+            render_to_string("template_used/base.html")
 
-        with self.assertTemplateUsed(template_name='template_used/base.html'):
-            render_to_string('template_used/base.html')
+        with self.assertTemplateUsed(template_name="template_used/base.html"):
+            render_to_string("template_used/base.html")
 
-        with self.assertTemplateUsed('template_used/base.html'):
-            render_to_string('template_used/include.html')
+        with self.assertTemplateUsed("template_used/base.html"):
+            render_to_string("template_used/include.html")
 
-        with self.assertTemplateUsed('template_used/base.html'):
-            render_to_string('template_used/extends.html')
+        with self.assertTemplateUsed("template_used/base.html"):
+            render_to_string("template_used/extends.html")
 
-        with self.assertTemplateUsed('template_used/base.html'):
-            render_to_string('template_used/base.html')
-            render_to_string('template_used/base.html')
+        with self.assertTemplateUsed("template_used/base.html"):
+            render_to_string("template_used/base.html")
+            render_to_string("template_used/base.html")
 
     def test_nested_usage(self):
-        with self.assertTemplateUsed('template_used/base.html'):
-            with self.assertTemplateUsed('template_used/include.html'):
-                render_to_string('template_used/include.html')
+        with self.assertTemplateUsed("template_used/base.html"):
+            with self.assertTemplateUsed("template_used/include.html"):
+                render_to_string("template_used/include.html")
 
-        with self.assertTemplateUsed('template_used/extends.html'):
-            with self.assertTemplateUsed('template_used/base.html'):
-                render_to_string('template_used/extends.html')
+        with self.assertTemplateUsed("template_used/extends.html"):
+            with self.assertTemplateUsed("template_used/base.html"):
+                render_to_string("template_used/extends.html")
 
-        with self.assertTemplateUsed('template_used/base.html'):
-            with self.assertTemplateUsed('template_used/alternative.html'):
-                render_to_string('template_used/alternative.html')
-            render_to_string('template_used/base.html')
+        with self.assertTemplateUsed("template_used/base.html"):
+            with self.assertTemplateUsed("template_used/alternative.html"):
+                render_to_string("template_used/alternative.html")
+            render_to_string("template_used/base.html")
 
-        with self.assertTemplateUsed('template_used/base.html'):
-            render_to_string('template_used/extends.html')
-            with self.assertTemplateNotUsed('template_used/base.html'):
-                render_to_string('template_used/alternative.html')
-            render_to_string('template_used/base.html')
+        with self.assertTemplateUsed("template_used/base.html"):
+            render_to_string("template_used/extends.html")
+            with self.assertTemplateNotUsed("template_used/base.html"):
+                render_to_string("template_used/alternative.html")
+            render_to_string("template_used/base.html")
 
     def test_not_used(self):
-        with self.assertTemplateNotUsed('template_used/base.html'):
+        with self.assertTemplateNotUsed("template_used/base.html"):
             pass
-        with self.assertTemplateNotUsed('template_used/alternative.html'):
+        with self.assertTemplateNotUsed("template_used/alternative.html"):
             pass
 
     def test_error_message(self):
-        msg = 'No templates used to render the response'
+        msg = "No templates used to render the response"
         with self.assertRaisesMessage(AssertionError, msg):
-            with self.assertTemplateUsed('template_used/base.html'):
+            with self.assertTemplateUsed("template_used/base.html"):
                 pass
 
         with self.assertRaisesMessage(AssertionError, msg):
-            with self.assertTemplateUsed(template_name='template_used/base.html'):
+            with self.assertTemplateUsed(template_name="template_used/base.html"):
                 pass
 
         msg2 = (
@@ -522,23 +528,27 @@ class AssertTemplateUsedContextManagerTests(SimpleTestCase):
             "the response. Actual template(s) used: template_used/alternative.html"
         )
         with self.assertRaisesMessage(AssertionError, msg2):
-            with self.assertTemplateUsed('template_used/base.html'):
-                render_to_string('template_used/alternative.html')
+            with self.assertTemplateUsed("template_used/base.html"):
+                render_to_string("template_used/alternative.html")
 
-        with self.assertRaisesMessage(AssertionError, 'No templates used to render the response'):
-            response = self.client.get('/test_utils/no_template_used/')
-            self.assertTemplateUsed(response, 'template_used/base.html')
+        with self.assertRaisesMessage(
+            AssertionError, "No templates used to render the response"
+        ):
+            response = self.client.get("/test_utils/no_template_used/")
+            self.assertTemplateUsed(response, "template_used/base.html")
 
     def test_msg_prefix(self):
-        msg_prefix = 'Prefix'
-        msg = f'{msg_prefix}: No templates used to render the response'
+        msg_prefix = "Prefix"
+        msg = f"{msg_prefix}: No templates used to render the response"
         with self.assertRaisesMessage(AssertionError, msg):
-            with self.assertTemplateUsed('template_used/base.html', msg_prefix=msg_prefix):
+            with self.assertTemplateUsed(
+                "template_used/base.html", msg_prefix=msg_prefix
+            ):
                 pass
 
         with self.assertRaisesMessage(AssertionError, msg):
             with self.assertTemplateUsed(
-                template_name='template_used/base.html',
+                template_name="template_used/base.html",
                 msg_prefix=msg_prefix,
             ):
                 pass
@@ -549,40 +559,42 @@ class AssertTemplateUsedContextManagerTests(SimpleTestCase):
             f"template_used/alternative.html"
         )
         with self.assertRaisesMessage(AssertionError, msg):
-            with self.assertTemplateUsed('template_used/base.html', msg_prefix=msg_prefix):
-                render_to_string('template_used/alternative.html')
+            with self.assertTemplateUsed(
+                "template_used/base.html", msg_prefix=msg_prefix
+            ):
+                render_to_string("template_used/alternative.html")
 
     def test_count(self):
-        with self.assertTemplateUsed('template_used/base.html', count=2):
-            render_to_string('template_used/base.html')
-            render_to_string('template_used/base.html')
+        with self.assertTemplateUsed("template_used/base.html", count=2):
+            render_to_string("template_used/base.html")
+            render_to_string("template_used/base.html")
 
         msg = (
             "Template 'template_used/base.html' was expected to be rendered "
             "3 time(s) but was actually rendered 2 time(s)."
         )
         with self.assertRaisesMessage(AssertionError, msg):
-            with self.assertTemplateUsed('template_used/base.html', count=3):
-                render_to_string('template_used/base.html')
-                render_to_string('template_used/base.html')
+            with self.assertTemplateUsed("template_used/base.html", count=3):
+                render_to_string("template_used/base.html")
+                render_to_string("template_used/base.html")
 
     def test_failure(self):
-        msg = 'response and/or template_name argument must be provided'
+        msg = "response and/or template_name argument must be provided"
         with self.assertRaisesMessage(TypeError, msg):
             with self.assertTemplateUsed():
                 pass
 
-        msg = 'No templates used to render the response'
+        msg = "No templates used to render the response"
         with self.assertRaisesMessage(AssertionError, msg):
-            with self.assertTemplateUsed(''):
+            with self.assertTemplateUsed(""):
                 pass
 
         with self.assertRaisesMessage(AssertionError, msg):
-            with self.assertTemplateUsed(''):
-                render_to_string('template_used/base.html')
+            with self.assertTemplateUsed(""):
+                render_to_string("template_used/base.html")
 
         with self.assertRaisesMessage(AssertionError, msg):
-            with self.assertTemplateUsed(template_name=''):
+            with self.assertTemplateUsed(template_name=""):
                 pass
 
         msg = (
@@ -591,125 +603,139 @@ class AssertTemplateUsedContextManagerTests(SimpleTestCase):
             "template_used/alternative.html"
         )
         with self.assertRaisesMessage(AssertionError, msg):
-            with self.assertTemplateUsed('template_used/base.html'):
-                render_to_string('template_used/alternative.html')
+            with self.assertTemplateUsed("template_used/base.html"):
+                render_to_string("template_used/alternative.html")
 
     def test_assert_used_on_http_response(self):
         response = HttpResponse()
-        msg = '%s() is only usable on responses fetched using the Django test Client.'
-        with self.assertRaisesMessage(ValueError, msg % 'assertTemplateUsed'):
-            self.assertTemplateUsed(response, 'template.html')
-        with self.assertRaisesMessage(ValueError, msg % 'assertTemplateNotUsed'):
-            self.assertTemplateNotUsed(response, 'template.html')
+        msg = "%s() is only usable on responses fetched using the Django test Client."
+        with self.assertRaisesMessage(ValueError, msg % "assertTemplateUsed"):
+            self.assertTemplateUsed(response, "template.html")
+        with self.assertRaisesMessage(ValueError, msg % "assertTemplateNotUsed"):
+            self.assertTemplateNotUsed(response, "template.html")
 
 
 class HTMLEqualTests(SimpleTestCase):
     def test_html_parser(self):
-        element = parse_html('<div><p>Hello</p></div>')
+        element = parse_html("<div><p>Hello</p></div>")
         self.assertEqual(len(element.children), 1)
-        self.assertEqual(element.children[0].name, 'p')
-        self.assertEqual(element.children[0].children[0], 'Hello')
+        self.assertEqual(element.children[0].name, "p")
+        self.assertEqual(element.children[0].children[0], "Hello")
 
-        parse_html('<p>')
-        parse_html('<p attr>')
-        dom = parse_html('<p>foo')
+        parse_html("<p>")
+        parse_html("<p attr>")
+        dom = parse_html("<p>foo")
         self.assertEqual(len(dom.children), 1)
-        self.assertEqual(dom.name, 'p')
-        self.assertEqual(dom[0], 'foo')
+        self.assertEqual(dom.name, "p")
+        self.assertEqual(dom[0], "foo")
 
     def test_parse_html_in_script(self):
         parse_html('<script>var a = "<p" + ">";</script>')
-        parse_html('''
+        parse_html(
+            """
             <script>
             var js_sha_link='<p>***</p>';
             </script>
-        ''')
+        """
+        )
 
         # script content will be parsed to text
-        dom = parse_html('''
+        dom = parse_html(
+            """
             <script><p>foo</p> '</scr'+'ipt>' <span>bar</span></script>
-        ''')
+        """
+        )
         self.assertEqual(len(dom.children), 1)
         self.assertEqual(dom.children[0], "<p>foo</p> '</scr'+'ipt>' <span>bar</span>")
 
     def test_self_closing_tags(self):
         self_closing_tags = [
-            'area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'link',
-            'meta', 'param', 'source', 'track', 'wbr',
+            "area",
+            "base",
+            "br",
+            "col",
+            "embed",
+            "hr",
+            "img",
+            "input",
+            "link",
+            "meta",
+            "param",
+            "source",
+            "track",
+            "wbr",
             # Deprecated tags
-            'frame', 'spacer',
+            "frame",
+            "spacer",
         ]
         for tag in self_closing_tags:
             with self.subTest(tag):
-                dom = parse_html('<p>Hello <%s> world</p>' % tag)
+                dom = parse_html("<p>Hello <%s> world</p>" % tag)
                 self.assertEqual(len(dom.children), 3)
-                self.assertEqual(dom[0], 'Hello')
+                self.assertEqual(dom[0], "Hello")
                 self.assertEqual(dom[1].name, tag)
-                self.assertEqual(dom[2], 'world')
+                self.assertEqual(dom[2], "world")
 
-                dom = parse_html('<p>Hello <%s /> world</p>' % tag)
+                dom = parse_html("<p>Hello <%s /> world</p>" % tag)
                 self.assertEqual(len(dom.children), 3)
-                self.assertEqual(dom[0], 'Hello')
+                self.assertEqual(dom[0], "Hello")
                 self.assertEqual(dom[1].name, tag)
-                self.assertEqual(dom[2], 'world')
+                self.assertEqual(dom[2], "world")
 
     def test_simple_equal_html(self):
-        self.assertHTMLEqual('', '')
-        self.assertHTMLEqual('<p></p>', '<p></p>')
-        self.assertHTMLEqual('<p></p>', ' <p> </p> ')
-        self.assertHTMLEqual(
-            '<div><p>Hello</p></div>',
-            '<div><p>Hello</p></div>')
-        self.assertHTMLEqual(
-            '<div><p>Hello</p></div>',
-            '<div> <p>Hello</p> </div>')
-        self.assertHTMLEqual(
-            '<div>\n<p>Hello</p></div>',
-            '<div><p>Hello</p></div>\n')
+        self.assertHTMLEqual("", "")
+        self.assertHTMLEqual("<p></p>", "<p></p>")
+        self.assertHTMLEqual("<p></p>", " <p> </p> ")
+        self.assertHTMLEqual("<div><p>Hello</p></div>", "<div><p>Hello</p></div>")
+        self.assertHTMLEqual("<div><p>Hello</p></div>", "<div> <p>Hello</p> </div>")
+        self.assertHTMLEqual("<div>\n<p>Hello</p></div>", "<div><p>Hello</p></div>\n")
         self.assertHTMLEqual(
-            '<div><p>Hello\nWorld !</p></div>',
-            '<div><p>Hello World\n!</p></div>')
-        self.assertHTMLEqual(
-            '<div><p>Hello\nWorld !</p></div>',
-            '<div><p>Hello World\n!</p></div>')
+            "<div><p>Hello\nWorld !</p></div>", "<div><p>Hello World\n!</p></div>"
+        )
         self.assertHTMLEqual(
-            '<p>Hello  World   !</p>',
-            '<p>Hello World\n\n!</p>')
-        self.assertHTMLEqual('<p> </p>', '<p></p>')
-        self.assertHTMLEqual('<p/>', '<p></p>')
-        self.assertHTMLEqual('<p />', '<p></p>')
-        self.assertHTMLEqual('<input checked>', '<input checked="checked">')
-        self.assertHTMLEqual('<p>Hello', '<p> Hello')
-        self.assertHTMLEqual('<p>Hello</p>World', '<p>Hello</p> World')
+            "<div><p>Hello\nWorld !</p></div>", "<div><p>Hello World\n!</p></div>"
+        )
+        self.assertHTMLEqual("<p>Hello  World   !</p>", "<p>Hello World\n\n!</p>")
+        self.assertHTMLEqual("<p> </p>", "<p></p>")
+        self.assertHTMLEqual("<p/>", "<p></p>")
+        self.assertHTMLEqual("<p />", "<p></p>")
+        self.assertHTMLEqual("<input checked>", '<input checked="checked">')
+        self.assertHTMLEqual("<p>Hello", "<p> Hello")
+        self.assertHTMLEqual("<p>Hello</p>World", "<p>Hello</p> World")
 
     def test_ignore_comments(self):
         self.assertHTMLEqual(
-            '<div>Hello<!-- this is a comment --> World!</div>',
-            '<div>Hello World!</div>')
+            "<div>Hello<!-- this is a comment --> World!</div>",
+            "<div>Hello World!</div>",
+        )
 
     def test_unequal_html(self):
-        self.assertHTMLNotEqual('<p>Hello</p>', '<p>Hello!</p>')
-        self.assertHTMLNotEqual('<p>foo&#20;bar</p>', '<p>foo&nbsp;bar</p>')
-        self.assertHTMLNotEqual('<p>foo bar</p>', '<p>foo &nbsp;bar</p>')
-        self.assertHTMLNotEqual('<p>foo nbsp</p>', '<p>foo &nbsp;</p>')
-        self.assertHTMLNotEqual('<p>foo #20</p>', '<p>foo &#20;</p>')
+        self.assertHTMLNotEqual("<p>Hello</p>", "<p>Hello!</p>")
+        self.assertHTMLNotEqual("<p>foo&#20;bar</p>", "<p>foo&nbsp;bar</p>")
+        self.assertHTMLNotEqual("<p>foo bar</p>", "<p>foo &nbsp;bar</p>")
+        self.assertHTMLNotEqual("<p>foo nbsp</p>", "<p>foo &nbsp;</p>")
+        self.assertHTMLNotEqual("<p>foo #20</p>", "<p>foo &#20;</p>")
         self.assertHTMLNotEqual(
-            '<p><span>Hello</span><span>World</span></p>',
-            '<p><span>Hello</span>World</p>')
+            "<p><span>Hello</span><span>World</span></p>",
+            "<p><span>Hello</span>World</p>",
+        )
         self.assertHTMLNotEqual(
-            '<p><span>Hello</span>World</p>',
-            '<p><span>Hello</span><span>World</span></p>')
+            "<p><span>Hello</span>World</p>",
+            "<p><span>Hello</span><span>World</span></p>",
+        )
 
     def test_attributes(self):
         self.assertHTMLEqual(
-            '<input type="text" id="id_name" />',
-            '<input id="id_name" type="text" />')
+            '<input type="text" id="id_name" />', '<input id="id_name" type="text" />'
+        )
         self.assertHTMLEqual(
-            '''<input type='text' id="id_name" />''',
-            '<input id="id_name" type="text" />')
+            """<input type='text' id="id_name" />""",
+            '<input id="id_name" type="text" />',
+        )
         self.assertHTMLNotEqual(
             '<input type="text" id="id_name" />',
-            '<input type="password" id="id_name" />')
+            '<input type="password" id="id_name" />',
+        )
 
     def test_class_attribute(self):
         pairs = [
@@ -726,19 +752,19 @@ class HTMLEqualTests(SimpleTestCase):
                 self.assertHTMLEqual(html1, html2)
 
     def test_boolean_attribute(self):
-        html1 = '<input checked>'
+        html1 = "<input checked>"
         html2 = '<input checked="">'
         html3 = '<input checked="checked">'
         self.assertHTMLEqual(html1, html2)
         self.assertHTMLEqual(html1, html3)
         self.assertHTMLEqual(html2, html3)
         self.assertHTMLNotEqual(html1, '<input checked="invalid">')
-        self.assertEqual(str(parse_html(html1)), '<input checked>')
-        self.assertEqual(str(parse_html(html2)), '<input checked>')
-        self.assertEqual(str(parse_html(html3)), '<input checked>')
+        self.assertEqual(str(parse_html(html1)), "<input checked>")
+        self.assertEqual(str(parse_html(html2)), "<input checked>")
+        self.assertEqual(str(parse_html(html3)), "<input checked>")
 
     def test_non_boolean_attibutes(self):
-        html1 = '<input value>'
+        html1 = "<input value>"
         html2 = '<input value="">'
         html3 = '<input value="value">'
         self.assertHTMLEqual(html1, html2)
@@ -748,24 +774,24 @@ class HTMLEqualTests(SimpleTestCase):
 
     def test_normalize_refs(self):
         pairs = [
-            ('&#39;', '&#x27;'),
-            ('&#39;', "'"),
-            ('&#x27;', '&#39;'),
-            ('&#x27;', "'"),
-            ("'", '&#39;'),
-            ("'", '&#x27;'),
-            ('&amp;', '&#38;'),
-            ('&amp;', '&#x26;'),
-            ('&amp;', '&'),
-            ('&#38;', '&amp;'),
-            ('&#38;', '&#x26;'),
-            ('&#38;', '&'),
-            ('&#x26;', '&amp;'),
-            ('&#x26;', '&#38;'),
-            ('&#x26;', '&'),
-            ('&', '&amp;'),
-            ('&', '&#38;'),
-            ('&', '&#x26;'),
+            ("&#39;", "&#x27;"),
+            ("&#39;", "'"),
+            ("&#x27;", "&#39;"),
+            ("&#x27;", "'"),
+            ("'", "&#39;"),
+            ("'", "&#x27;"),
+            ("&amp;", "&#38;"),
+            ("&amp;", "&#x26;"),
+            ("&amp;", "&"),
+            ("&#38;", "&amp;"),
+            ("&#38;", "&#x26;"),
+            ("&#38;", "&"),
+            ("&#x26;", "&amp;"),
+            ("&#x26;", "&#38;"),
+            ("&#x26;", "&"),
+            ("&", "&amp;"),
+            ("&", "&#38;"),
+            ("&", "&#x26;"),
         ]
         for pair in pairs:
             with self.subTest(repr(pair)):
@@ -792,7 +818,8 @@ class HTMLEqualTests(SimpleTestCase):
             <label for="id_birthday">Birthday:</label></th><td>
             <input type="text" name="birthday" value="1940-10-9" id="id_birthday" />
         </td></tr>
-        """)
+        """,
+        )
 
         self.assertHTMLEqual(
             """<!DOCTYPE html>
@@ -807,7 +834,8 @@ class HTMLEqualTests(SimpleTestCase):
             This is a valid paragraph
             <div> this is a div AFTER the p</div>
         </body>
-        </html>""", """
+        </html>""",
+            """
         <html>
         <head>
             <link rel="stylesheet">
@@ -821,122 +849,125 @@ class HTMLEqualTests(SimpleTestCase):
             </p> <!-- this is invalid HTML parsing, but it should make no
             difference in most cases -->
         </body>
-        </html>""")
+        </html>""",
+        )
 
     def test_html_contain(self):
         # equal html contains each other
-        dom1 = parse_html('<p>foo')
-        dom2 = parse_html('<p>foo</p>')
+        dom1 = parse_html("<p>foo")
+        dom2 = parse_html("<p>foo</p>")
         self.assertIn(dom1, dom2)
         self.assertIn(dom2, dom1)
 
-        dom2 = parse_html('<div><p>foo</p></div>')
+        dom2 = parse_html("<div><p>foo</p></div>")
         self.assertIn(dom1, dom2)
         self.assertNotIn(dom2, dom1)
 
-        self.assertNotIn('<p>foo</p>', dom2)
-        self.assertIn('foo', dom2)
+        self.assertNotIn("<p>foo</p>", dom2)
+        self.assertIn("foo", dom2)
 
         # when a root element is used ...
-        dom1 = parse_html('<p>foo</p><p>bar</p>')
-        dom2 = parse_html('<p>foo</p><p>bar</p>')
+        dom1 = parse_html("<p>foo</p><p>bar</p>")
+        dom2 = parse_html("<p>foo</p><p>bar</p>")
         self.assertIn(dom1, dom2)
-        dom1 = parse_html('<p>foo</p>')
+        dom1 = parse_html("<p>foo</p>")
         self.assertIn(dom1, dom2)
-        dom1 = parse_html('<p>bar</p>')
+        dom1 = parse_html("<p>bar</p>")
         self.assertIn(dom1, dom2)
-        dom1 = parse_html('<div><p>foo</p><p>bar</p></div>')
+        dom1 = parse_html("<div><p>foo</p><p>bar</p></div>")
         self.assertIn(dom2, dom1)
 
     def test_count(self):
         # equal html contains each other one time
-        dom1 = parse_html('<p>foo')
-        dom2 = parse_html('<p>foo</p>')
+        dom1 = parse_html("<p>foo")
+        dom2 = parse_html("<p>foo</p>")
         self.assertEqual(dom1.count(dom2), 1)
         self.assertEqual(dom2.count(dom1), 1)
 
-        dom2 = parse_html('<p>foo</p><p>bar</p>')
+        dom2 = parse_html("<p>foo</p><p>bar</p>")
         self.assertEqual(dom2.count(dom1), 1)
 
-        dom2 = parse_html('<p>foo foo</p><p>foo</p>')
-        self.assertEqual(dom2.count('foo'), 3)
+        dom2 = parse_html("<p>foo foo</p><p>foo</p>")
+        self.assertEqual(dom2.count("foo"), 3)
 
         dom2 = parse_html('<p class="bar">foo</p>')
-        self.assertEqual(dom2.count('bar'), 0)
-        self.assertEqual(dom2.count('class'), 0)
-        self.assertEqual(dom2.count('p'), 0)
-        self.assertEqual(dom2.count('o'), 2)
+        self.assertEqual(dom2.count("bar"), 0)
+        self.assertEqual(dom2.count("class"), 0)
+        self.assertEqual(dom2.count("p"), 0)
+        self.assertEqual(dom2.count("o"), 2)
 
-        dom2 = parse_html('<p>foo</p><p>foo</p>')
+        dom2 = parse_html("<p>foo</p><p>foo</p>")
         self.assertEqual(dom2.count(dom1), 2)
 
         dom2 = parse_html('<div><p>foo<input type=""></p><p>foo</p></div>')
         self.assertEqual(dom2.count(dom1), 1)
 
-        dom2 = parse_html('<div><div><p>foo</p></div></div>')
+        dom2 = parse_html("<div><div><p>foo</p></div></div>")
         self.assertEqual(dom2.count(dom1), 1)
 
-        dom2 = parse_html('<p>foo<p>foo</p></p>')
+        dom2 = parse_html("<p>foo<p>foo</p></p>")
         self.assertEqual(dom2.count(dom1), 1)
 
-        dom2 = parse_html('<p>foo<p>bar</p></p>')
+        dom2 = parse_html("<p>foo<p>bar</p></p>")
         self.assertEqual(dom2.count(dom1), 0)
 
         # HTML with a root element contains the same HTML with no root element.
-        dom1 = parse_html('<p>foo</p><p>bar</p>')
-        dom2 = parse_html('<div><p>foo</p><p>bar</p></div>')
+        dom1 = parse_html("<p>foo</p><p>bar</p>")
+        dom2 = parse_html("<div><p>foo</p><p>bar</p></div>")
         self.assertEqual(dom2.count(dom1), 1)
 
         # Target of search is a sequence of child elements and appears more
         # than once.
-        dom2 = parse_html('<div><p>foo</p><p>bar</p><p>foo</p><p>bar</p></div>')
+        dom2 = parse_html("<div><p>foo</p><p>bar</p><p>foo</p><p>bar</p></div>")
         self.assertEqual(dom2.count(dom1), 2)
 
         # Searched HTML has additional children.
-        dom1 = parse_html('<a/><b/>')
-        dom2 = parse_html('<a/><b/><c/>')
+        dom1 = parse_html("<a/><b/>")
+        dom2 = parse_html("<a/><b/><c/>")
         self.assertEqual(dom2.count(dom1), 1)
 
         # No match found in children.
-        dom1 = parse_html('<b/><a/>')
+        dom1 = parse_html("<b/><a/>")
         self.assertEqual(dom2.count(dom1), 0)
 
         # Target of search found among children and grandchildren.
-        dom1 = parse_html('<b/><b/>')
-        dom2 = parse_html('<a><b/><b/></a><b/><b/>')
+        dom1 = parse_html("<b/><b/>")
+        dom2 = parse_html("<a><b/><b/></a><b/><b/>")
         self.assertEqual(dom2.count(dom1), 2)
 
     def test_root_element_escaped_html(self):
-        html = '&lt;br&gt;'
+        html = "&lt;br&gt;"
         parsed = parse_html(html)
         self.assertEqual(str(parsed), html)
 
     def test_parsing_errors(self):
         with self.assertRaises(AssertionError):
-            self.assertHTMLEqual('<p>', '')
+            self.assertHTMLEqual("<p>", "")
         with self.assertRaises(AssertionError):
-            self.assertHTMLEqual('', '<p>')
+            self.assertHTMLEqual("", "<p>")
         error_msg = (
             "First argument is not valid HTML:\n"
             "('Unexpected end tag `div` (Line 1, Column 6)', (1, 6))"
         )
         with self.assertRaisesMessage(AssertionError, error_msg):
-            self.assertHTMLEqual('< div></ div>', '<div></div>')
+            self.assertHTMLEqual("< div></ div>", "<div></div>")
         with self.assertRaises(HTMLParseError):
-            parse_html('</p>')
+            parse_html("</p>")
 
     def test_escaped_html_errors(self):
-        msg = '<p>\n<foo>\n</p> != <p>\n&lt;foo&gt;\n</p>\n'
+        msg = "<p>\n<foo>\n</p> != <p>\n&lt;foo&gt;\n</p>\n"
         with self.assertRaisesMessage(AssertionError, msg):
-            self.assertHTMLEqual('<p><foo></p>', '<p>&lt;foo&gt;</p>')
+            self.assertHTMLEqual("<p><foo></p>", "<p>&lt;foo&gt;</p>")
         with self.assertRaisesMessage(AssertionError, msg):
-            self.assertHTMLEqual('<p><foo></p>', '<p>&#60;foo&#62;</p>')
+            self.assertHTMLEqual("<p><foo></p>", "<p>&#60;foo&#62;</p>")
 
     def test_contains_html(self):
-        response = HttpResponse('''<body>
+        response = HttpResponse(
+            """<body>
         This is a form: <form method="get">
             <input type="text" name="Hello" />
-        </form></body>''')
+        </form></body>"""
+        )
 
         self.assertNotContains(response, "<input name='Hello' type='text'>")
         self.assertContains(response, '<form method="get">')
@@ -944,20 +975,22 @@ class HTMLEqualTests(SimpleTestCase):
         self.assertContains(response, "<input name='Hello' type='text'>", html=True)
         self.assertNotContains(response, '<form method="get">', html=True)
 
-        invalid_response = HttpResponse('''<body <bad>>''')
+        invalid_response = HttpResponse("""<body <bad>>""")
 
         with self.assertRaises(AssertionError):
-            self.assertContains(invalid_response, '<p></p>')
+            self.assertContains(invalid_response, "<p></p>")
 
         with self.assertRaises(AssertionError):
             self.assertContains(response, '<p "whats" that>')
 
     def test_unicode_handling(self):
-        response = HttpResponse('<p class="help">Some help text for the title (with Unicode ŠĐĆŽćžšđ)</p>')
+        response = HttpResponse(
+            '<p class="help">Some help text for the title (with Unicode ŠĐĆŽćžšđ)</p>'
+        )
         self.assertContains(
             response,
             '<p class="help">Some help text for the title (with Unicode ŠĐĆŽćžšđ)</p>',
-            html=True
+            html=True,
         )
 
 
@@ -1027,11 +1060,13 @@ class XMLEqualTests(SimpleTestCase):
         xml1 = "<elem attr1='a' />"
         xml2 = "<elem attr2='b' attr1='a' />"
 
-        msg = '''{xml1} != {xml2}
+        msg = """{xml1} != {xml2}
 - <elem attr1='a' />
 + <elem attr2='b' attr1='a' />
 ?      ++++++++++
-'''.format(xml1=repr(xml1), xml2=repr(xml2))
+""".format(
+            xml1=repr(xml1), xml2=repr(xml2)
+        )
 
         with self.assertRaisesMessage(AssertionError, msg):
             self.assertXMLEqual(xml1, xml2)
@@ -1090,7 +1125,7 @@ class XMLEqualTests(SimpleTestCase):
 
 
 class SkippingExtraTests(TestCase):
-    fixtures = ['should_not_be_loaded.json']
+    fixtures = ["should_not_be_loaded.json"]
 
     # HACK: This depends on internals of our TestCase subclasses
     def __call__(self, result=None):
@@ -1104,7 +1139,6 @@ class SkippingExtraTests(TestCase):
 
 
 class AssertRaisesMsgTest(SimpleTestCase):
-
     def test_assert_raises_message(self):
         msg = "'Expected message' not found in 'Unexpected message'"
         # context manager form of assertRaisesMessage()
@@ -1121,33 +1155,36 @@ class AssertRaisesMsgTest(SimpleTestCase):
 
     def test_special_re_chars(self):
         """assertRaisesMessage shouldn't interpret RE special chars."""
+
         def func1():
             raise ValueError("[.*x+]y?")
+
         with self.assertRaisesMessage(ValueError, "[.*x+]y?"):
             func1()
 
 
 class AssertWarnsMessageTests(SimpleTestCase):
-
     def test_context_manager(self):
-        with self.assertWarnsMessage(UserWarning, 'Expected message'):
-            warnings.warn('Expected message', UserWarning)
+        with self.assertWarnsMessage(UserWarning, "Expected message"):
+            warnings.warn("Expected message", UserWarning)
 
     def test_context_manager_failure(self):
         msg = "Expected message' not found in 'Unexpected message'"
         with self.assertRaisesMessage(AssertionError, msg):
-            with self.assertWarnsMessage(UserWarning, 'Expected message'):
-                warnings.warn('Unexpected message', UserWarning)
+            with self.assertWarnsMessage(UserWarning, "Expected message"):
+                warnings.warn("Unexpected message", UserWarning)
 
     def test_callable(self):
         def func():
-            warnings.warn('Expected message', UserWarning)
-        self.assertWarnsMessage(UserWarning, 'Expected message', func)
+            warnings.warn("Expected message", UserWarning)
+
+        self.assertWarnsMessage(UserWarning, "Expected message", func)
 
     def test_special_re_chars(self):
         def func1():
-            warnings.warn('[.*x+]y?', UserWarning)
-        with self.assertWarnsMessage(UserWarning, '[.*x+]y?'):
+            warnings.warn("[.*x+]y?", UserWarning)
+
+        with self.assertWarnsMessage(UserWarning, "[.*x+]y?"):
             func1()
 
 
@@ -1160,72 +1197,85 @@ class AssertNoLogsTest(SimpleTestCase):
         cls.addClassCleanup(logging.config.dictConfig, settings.LOGGING)
 
     def setUp(self):
-        self.logger = logging.getLogger('django')
+        self.logger = logging.getLogger("django")
 
     @override_settings(DEBUG=True)
     def test_fails_when_log_emitted(self):
         msg = "Unexpected logs found: ['INFO:django:FAIL!']"
         with self.assertRaisesMessage(AssertionError, msg):
-            with self.assertNoLogs('django', 'INFO'):
-                self.logger.info('FAIL!')
+            with self.assertNoLogs("django", "INFO"):
+                self.logger.info("FAIL!")
 
     @override_settings(DEBUG=True)
     def test_text_level(self):
-        with self.assertNoLogs('django', 'INFO'):
-            self.logger.debug('DEBUG logs are ignored.')
+        with self.assertNoLogs("django", "INFO"):
+            self.logger.debug("DEBUG logs are ignored.")
 
     @override_settings(DEBUG=True)
     def test_int_level(self):
-        with self.assertNoLogs('django', logging.INFO):
-            self.logger.debug('DEBUG logs are ignored.')
+        with self.assertNoLogs("django", logging.INFO):
+            self.logger.debug("DEBUG logs are ignored.")
 
     @override_settings(DEBUG=True)
     def test_default_level(self):
-        with self.assertNoLogs('django'):
-            self.logger.debug('DEBUG logs are ignored.')
+        with self.assertNoLogs("django"):
+            self.logger.debug("DEBUG logs are ignored.")
 
     @override_settings(DEBUG=True)
     def test_does_not_hide_other_failures(self):
-        msg = '1 != 2'
+        msg = "1 != 2"
         with self.assertRaisesMessage(AssertionError, msg):
-            with self.assertNoLogs('django'):
+            with self.assertNoLogs("django"):
                 self.assertEqual(1, 2)
 
 
 class AssertFieldOutputTests(SimpleTestCase):
-
     def test_assert_field_output(self):
-        error_invalid = ['Enter a valid email address.']
-        self.assertFieldOutput(EmailField, {'a@a.com': 'a@a.com'}, {'aaa': error_invalid})
+        error_invalid = ["Enter a valid email address."]
+        self.assertFieldOutput(
+            EmailField, {"a@a.com": "a@a.com"}, {"aaa": error_invalid}
+        )
         with self.assertRaises(AssertionError):
-            self.assertFieldOutput(EmailField, {'a@a.com': 'a@a.com'}, {'aaa': error_invalid + ['Another error']})
+            self.assertFieldOutput(
+                EmailField,
+                {"a@a.com": "a@a.com"},
+                {"aaa": error_invalid + ["Another error"]},
+            )
         with self.assertRaises(AssertionError):
-            self.assertFieldOutput(EmailField, {'a@a.com': 'Wrong output'}, {'aaa': error_invalid})
+            self.assertFieldOutput(
+                EmailField, {"a@a.com": "Wrong output"}, {"aaa": error_invalid}
+            )
         with self.assertRaises(AssertionError):
             self.assertFieldOutput(
-                EmailField, {'a@a.com': 'a@a.com'}, {'aaa': ['Come on, gimme some well formatted data, dude.']}
+                EmailField,
+                {"a@a.com": "a@a.com"},
+                {"aaa": ["Come on, gimme some well formatted data, dude."]},
             )
 
     def test_custom_required_message(self):
         class MyCustomField(IntegerField):
             default_error_messages = {
-                'required': 'This is really required.',
+                "required": "This is really required.",
             }
+
         self.assertFieldOutput(MyCustomField, {}, {}, empty_value=None)
 
 
-@override_settings(ROOT_URLCONF='test_utils.urls')
+@override_settings(ROOT_URLCONF="test_utils.urls")
 class AssertURLEqualTests(SimpleTestCase):
     def test_equal(self):
         valid_tests = (
-            ('http://example.com/?', 'http://example.com/'),
-            ('http://example.com/?x=1&', 'http://example.com/?x=1'),
-            ('http://example.com/?x=1&y=2', 'http://example.com/?y=2&x=1'),
-            ('http://example.com/?x=1&y=2', 'http://example.com/?y=2&x=1'),
-            ('http://example.com/?x=1&y=2&a=1&a=2', 'http://example.com/?a=1&a=2&y=2&x=1'),
-            ('/path/to/?x=1&y=2&z=3', '/path/to/?z=3&y=2&x=1'),
-            ('?x=1&y=2&z=3', '?z=3&y=2&x=1'),
-            ('/test_utils/no_template_used/', reverse_lazy('no_template_used')),
+            ("http://example.com/?", "http://example.com/"),
+            ("http://example.com/?x=1&", "http://example.com/?x=1"),
+            ("http://example.com/?x=1&y=2", "http://example.com/?y=2&x=1"),
+            ("http://example.com/?x=1&y=2", "http://example.com/?y=2&x=1"),
+            (
+                "http://example.com/?x=1&y=2&a=1&a=2",
+                "http://example.com/?a=1&a=2&y=2&x=1",
+            ),
+            ("/path/to/?x=1&y=2&z=3", "/path/to/?z=3&y=2&x=1"),
+            ("?x=1&y=2&z=3", "?z=3&y=2&x=1"),
+            ("/test_utils/no_template_used/", reverse_lazy("no_template_used")),
         )
         for url1, url2 in valid_tests:
             with self.subTest(url=url1):
@@ -1234,11 +1284,11 @@ class AssertURLEqualTests(SimpleTestCase):
     def test_not_equal(self):
         invalid_tests = (
             # Protocol must be the same.
-            ('http://example.com/', 'https://example.com/'),
-            ('http://example.com/?x=1&x=2', 'https://example.com/?x=2&x=1'),
-            ('http://example.com/?x=1&y=bar&x=2', 'https://example.com/?y=bar&x=2&x=1'),
+            ("http://example.com/", "https://example.com/"),
+            ("http://example.com/?x=1&x=2", "https://example.com/?x=2&x=1"),
+            ("http://example.com/?x=1&y=bar&x=2", "https://example.com/?y=bar&x=2&x=1"),
             # Parameters of the same name must be in the same order.
-            ('/path/to?a=1&a=2', '/path/to/?a=2&a=1')
+            ("/path/to?a=1&a=2", "/path/to/?a=2&a=1"),
         )
         for url1, url2 in invalid_tests:
             with self.subTest(url=url1), self.assertRaises(AssertionError):
@@ -1250,7 +1300,9 @@ class AssertURLEqualTests(SimpleTestCase):
             "'https://example.com/?x=2&x=1'"
         )
         with self.assertRaisesMessage(AssertionError, msg):
-            self.assertURLEqual('http://example.com/?x=1&x=2', 'https://example.com/?x=2&x=1')
+            self.assertURLEqual(
+                "http://example.com/?x=1&x=2", "https://example.com/?x=2&x=1"
+            )
 
     def test_msg_prefix(self):
         msg = (
@@ -1259,8 +1311,9 @@ class AssertURLEqualTests(SimpleTestCase):
         )
         with self.assertRaisesMessage(AssertionError, msg):
             self.assertURLEqual(
-                'http://example.com/?x=1&x=2', 'https://example.com/?x=2&x=1',
-                msg_prefix='Prefix: ',
+                "http://example.com/?x=1&x=2",
+                "https://example.com/?x=2&x=1",
+                msg_prefix="Prefix: ",
             )
 
 
@@ -1268,77 +1321,79 @@ class TestForm(Form):
     field = CharField()
 
     def clean_field(self):
-        value = self.cleaned_data.get('field', '')
-        if value == 'invalid':
-            raise ValidationError('invalid value')
+        value = self.cleaned_data.get("field", "")
+        if value == "invalid":
+            raise ValidationError("invalid value")
         return value
 
     def clean(self):
-        if self.cleaned_data.get('field') == 'invalid_non_field':
-            raise ValidationError('non-field error')
+        if self.cleaned_data.get("field") == "invalid_non_field":
+            raise ValidationError("non-field error")
         return self.cleaned_data
 
     @classmethod
     def _get_cleaned_form(cls, field_value):
-        form = cls({'field': field_value})
+        form = cls({"field": field_value})
         form.full_clean()
         return form
 
     @classmethod
     def valid(cls):
-        return cls._get_cleaned_form('valid')
+        return cls._get_cleaned_form("valid")
 
     @classmethod
     def invalid(cls, nonfield=False):
-        return cls._get_cleaned_form('invalid_non_field' if nonfield else 'invalid')
+        return cls._get_cleaned_form("invalid_non_field" if nonfield else "invalid")
 
 
 class TestFormset(formset_factory(TestForm)):
     @classmethod
     def _get_cleaned_formset(cls, field_value):
-        formset = cls({
-            'form-TOTAL_FORMS': '1',
-            'form-INITIAL_FORMS': '0',
-            'form-0-field': field_value,
-        })
+        formset = cls(
+            {
+                "form-TOTAL_FORMS": "1",
+                "form-INITIAL_FORMS": "0",
+                "form-0-field": field_value,
+            }
+        )
         formset.full_clean()
         return formset
 
     @classmethod
     def valid(cls):
-        return cls._get_cleaned_formset('valid')
+        return cls._get_cleaned_formset("valid")
 
     @classmethod
     def invalid(cls, nonfield=False, nonform=False):
         if nonform:
-            formset = cls({}, error_messages={'missing_management_form': 'error'})
+            formset = cls({}, error_messages={"missing_management_form": "error"})
             formset.full_clean()
             return formset
-        return cls._get_cleaned_formset('invalid_non_field' if nonfield else 'invalid')
+        return cls._get_cleaned_formset("invalid_non_field" if nonfield else "invalid")
 
 
 class AssertFormErrorTests(SimpleTestCase):
     def test_non_client_response(self):
         msg = (
-            'assertFormError() is only usable on responses fetched using the '
-            'Django test Client.'
+            "assertFormError() is only usable on responses fetched using the "
+            "Django test Client."
         )
         response = HttpResponse()
         with self.assertRaisesMessage(ValueError, msg):
-            self.assertFormError(response, 'formset', 0, 'field', 'invalid value')
+            self.assertFormError(response, "formset", 0, "field", "invalid value")
 
     def test_response_with_no_context(self):
-        msg = 'Response did not use any contexts to render the response'
+        msg = "Response did not use any contexts to render the response"
         response = mock.Mock(context=[])
         with self.assertRaisesMessage(AssertionError, msg):
-            self.assertFormError(response, 'form', 'field', 'invalid value')
-        msg_prefix = 'Custom prefix'
-        with self.assertRaisesMessage(AssertionError, f'{msg_prefix}: {msg}'):
+            self.assertFormError(response, "form", "field", "invalid value")
+        msg_prefix = "Custom prefix"
+        with self.assertRaisesMessage(AssertionError, f"{msg_prefix}: {msg}"):
             self.assertFormError(
                 response,
-                'form',
-                'field',
-                'invalid value',
+                "form",
+                "field",
+                "invalid value",
                 msg_prefix=msg_prefix,
             )
 
@@ -1346,131 +1401,131 @@ class AssertFormErrorTests(SimpleTestCase):
         msg = "The form 'form' was not used to render the response"
         response = mock.Mock(context=[{}])
         with self.assertRaisesMessage(AssertionError, msg):
-            self.assertFormError(response, 'form', 'field', 'invalid value')
+            self.assertFormError(response, "form", "field", "invalid value")
 
     def test_field_not_in_form(self):
         msg = "The form 'form' in context 0 does not contain the field 'other_field'"
-        response = mock.Mock(context=[{'form': TestForm.invalid()}])
+        response = mock.Mock(context=[{"form": TestForm.invalid()}])
         with self.assertRaisesMessage(AssertionError, msg):
-            self.assertFormError(response, 'form', 'other_field', 'invalid value')
+            self.assertFormError(response, "form", "other_field", "invalid value")
 
     def test_field_not_in_form_multicontext(self):
         msg = "The form 'form' in context 1 does not contain the field 'other_field'"
-        response = mock.Mock(context=[{}, {'form': TestForm.invalid()}])
+        response = mock.Mock(context=[{}, {"form": TestForm.invalid()}])
         with self.assertRaisesMessage(AssertionError, msg):
-            self.assertFormError(response, 'form', 'other_field', 'invalid value')
+            self.assertFormError(response, "form", "other_field", "invalid value")
 
     def test_field_with_no_errors(self):
         msg = "The field 'field' on form 'form' in context 0 contains no errors"
-        response = mock.Mock(context=[{'form': TestForm.valid()}])
+        response = mock.Mock(context=[{"form": TestForm.valid()}])
         with self.assertRaisesMessage(AssertionError, msg):
-            self.assertFormError(response, 'form', 'field', 'invalid value')
+            self.assertFormError(response, "form", "field", "invalid value")
 
     def test_field_with_no_errors_multicontext(self):
         msg = "The field 'field' on form 'form' in context 1 contains no errors"
-        response = mock.Mock(context=[{}, {'form': TestForm.valid()}])
+        response = mock.Mock(context=[{}, {"form": TestForm.valid()}])
         with self.assertRaisesMessage(AssertionError, msg):
-            self.assertFormError(response, 'form', 'field', 'invalid value')
+            self.assertFormError(response, "form", "field", "invalid value")
 
     def test_field_with_different_error(self):
         msg = (
             "The field 'field' on form 'form' in context 0 does not contain "
             "the error 'other error' (actual errors: ['invalid value'])"
         )
-        response = mock.Mock(context=[{'form': TestForm.invalid()}])
+        response = mock.Mock(context=[{"form": TestForm.invalid()}])
         with self.assertRaisesMessage(AssertionError, msg):
-            self.assertFormError(response, 'form', 'field', 'other error')
+            self.assertFormError(response, "form", "field", "other error")
 
     def test_field_with_different_error_multicontext(self):
         msg = (
             "The field 'field' on form 'form' in context 1 does not contain "
             "the error 'other error' (actual errors: ['invalid value'])"
         )
-        response = mock.Mock(context=[{}, {'form': TestForm.invalid()}])
+        response = mock.Mock(context=[{}, {"form": TestForm.invalid()}])
         with self.assertRaisesMessage(AssertionError, msg):
-            self.assertFormError(response, 'form', 'field', 'other error')
+            self.assertFormError(response, "form", "field", "other error")
 
     def test_basic_positive_assertion(self):
-        response = mock.Mock(context=[{'form': TestForm.invalid()}])
-        self.assertFormError(response, 'form', 'field', 'invalid value')
+        response = mock.Mock(context=[{"form": TestForm.invalid()}])
+        self.assertFormError(response, "form", "field", "invalid value")
 
     def test_basic_positive_assertion_multicontext(self):
-        response = mock.Mock(context=[{}, {'form': TestForm.invalid()}])
-        self.assertFormError(response, 'form', 'field', 'invalid value')
+        response = mock.Mock(context=[{}, {"form": TestForm.invalid()}])
+        self.assertFormError(response, "form", "field", "invalid value")
 
     def test_empty_errors_unbound_form(self):
-        response = mock.Mock(context=[{'form': TestForm()}])
-        self.assertFormError(response, 'form', 'field', [])
+        response = mock.Mock(context=[{"form": TestForm()}])
+        self.assertFormError(response, "form", "field", [])
 
     def test_empty_errors_valid_form(self):
-        response = mock.Mock(context=[{'form': TestForm.valid()}])
-        self.assertFormError(response, 'form', 'field', [])
+        response = mock.Mock(context=[{"form": TestForm.valid()}])
+        self.assertFormError(response, "form", "field", [])
 
     def test_empty_errors_invalid_form(self):
-        response = mock.Mock(context=[{'form': TestForm.invalid()}])
-        self.assertFormError(response, 'form', 'field', [])
+        response = mock.Mock(context=[{"form": TestForm.invalid()}])
+        self.assertFormError(response, "form", "field", [])
 
     def test_non_field_errors(self):
-        response = mock.Mock(context=[{'form': TestForm.invalid(nonfield=True)}])
-        self.assertFormError(response, 'form', None, 'non-field error')
+        response = mock.Mock(context=[{"form": TestForm.invalid(nonfield=True)}])
+        self.assertFormError(response, "form", None, "non-field error")
 
     @ignore_warnings(category=RemovedInDjango50Warning)
     def test_errors_none(self):
-        response = mock.Mock(context=[{'form': TestForm.invalid()}])
-        self.assertFormError(response, 'form', 'field', None)
+        response = mock.Mock(context=[{"form": TestForm.invalid()}])
+        self.assertFormError(response, "form", "field", None)
 
     def test_errors_none_warning(self):
-        response = mock.Mock(context=[{'form': TestForm.invalid()}])
+        response = mock.Mock(context=[{"form": TestForm.invalid()}])
         msg = (
-            'Passing errors=None to assertFormError() is deprecated, use '
-            'errors=[] instead.'
+            "Passing errors=None to assertFormError() is deprecated, use "
+            "errors=[] instead."
         )
         with self.assertWarnsMessage(RemovedInDjango50Warning, msg):
-            self.assertFormError(response, 'form', 'value', None)
+            self.assertFormError(response, "form", "value", None)
 
 
 class AssertFormsetErrorTests(SimpleTestCase):
     def _get_formset_data(self, field_value):
         return {
-            'form-TOTAL_FORMS': '1',
-            'form-INITIAL_FORMS': '0',
-            'form-0-field': field_value,
+            "form-TOTAL_FORMS": "1",
+            "form-INITIAL_FORMS": "0",
+            "form-0-field": field_value,
         }
 
     def test_non_client_response(self):
         msg = (
-            'assertFormsetError() is only usable on responses fetched using '
-            'the Django test Client.'
+            "assertFormsetError() is only usable on responses fetched using "
+            "the Django test Client."
         )
         response = HttpResponse()
         with self.assertRaisesMessage(ValueError, msg):
-            self.assertFormsetError(response, 'formset', 0, 'field', 'invalid value')
+            self.assertFormsetError(response, "formset", 0, "field", "invalid value")
 
     def test_response_with_no_context(self):
-        msg = 'Response did not use any contexts to render the response'
+        msg = "Response did not use any contexts to render the response"
         response = mock.Mock(context=[])
         with self.assertRaisesMessage(AssertionError, msg):
-            self.assertFormsetError(response, 'formset', 0, 'field', 'invalid value')
+            self.assertFormsetError(response, "formset", 0, "field", "invalid value")
 
     def test_formset_not_in_context(self):
         msg = "The formset 'formset' was not used to render the response"
         response = mock.Mock(context=[{}])
         with self.assertRaisesMessage(AssertionError, msg):
-            self.assertFormsetError(response, 'formset', 0, 'field', 'invalid value')
+            self.assertFormsetError(response, "formset", 0, "field", "invalid value")
 
     def test_field_not_in_form(self):
         msg = (
             "The formset 'formset', form 0 in context 0 does not contain the "
             "field 'other_field'"
         )
-        response = mock.Mock(context=[{'formset': TestFormset.invalid()}])
+        response = mock.Mock(context=[{"formset": TestFormset.invalid()}])
         with self.assertRaisesMessage(AssertionError, msg):
             self.assertFormsetError(
                 response,
-                'formset',
+                "formset",
                 0,
-                'other_field',
-                'invalid value',
+                "other_field",
+                "invalid value",
             )
 
     def test_field_not_in_form_multicontext(self):
@@ -1478,14 +1533,14 @@ class AssertFormsetErrorTests(SimpleTestCase):
             "The formset 'formset', form 0 in context 1 does not contain the "
             "field 'other_field'"
         )
-        response = mock.Mock(context=[{}, {'formset': TestFormset.invalid()}])
+        response = mock.Mock(context=[{}, {"formset": TestFormset.invalid()}])
         with self.assertRaisesMessage(AssertionError, msg):
             self.assertFormsetError(
                 response,
-                'formset',
+                "formset",
                 0,
-                'other_field',
-                'invalid value',
+                "other_field",
+                "invalid value",
             )
 
     def test_field_with_no_errors(self):
@@ -1493,18 +1548,18 @@ class AssertFormsetErrorTests(SimpleTestCase):
             "The field 'field' on formset 'formset', form 0 in context 0 "
             "contains no errors"
         )
-        response = mock.Mock(context=[{'formset': TestFormset.valid()}])
+        response = mock.Mock(context=[{"formset": TestFormset.valid()}])
         with self.assertRaisesMessage(AssertionError, msg):
-            self.assertFormsetError(response, 'formset', 0, 'field', 'invalid value')
+            self.assertFormsetError(response, "formset", 0, "field", "invalid value")
 
     def test_field_with_no_errors_multicontext(self):
         msg = (
             "The field 'field' on formset 'formset', form 0 in context 1 "
             "contains no errors"
         )
-        response = mock.Mock(context=[{}, {'formset': TestFormset.valid()}])
+        response = mock.Mock(context=[{}, {"formset": TestFormset.valid()}])
         with self.assertRaisesMessage(AssertionError, msg):
-            self.assertFormsetError(response, 'formset', 0, 'field', 'invalid value')
+            self.assertFormsetError(response, "formset", 0, "field", "invalid value")
 
     def test_field_with_different_error(self):
         msg = (
@@ -1512,9 +1567,9 @@ class AssertFormsetErrorTests(SimpleTestCase):
             " not contain the error 'other error' (actual errors: ['invalid "
             "value'])"
         )
-        response = mock.Mock(context=[{'formset': TestFormset.invalid()}])
+        response = mock.Mock(context=[{"formset": TestFormset.invalid()}])
         with self.assertRaisesMessage(AssertionError, msg):
-            self.assertFormsetError(response, 'formset', 0, 'field', 'other error')
+            self.assertFormsetError(response, "formset", 0, "field", "other error")
 
     def test_field_with_different_error_multicontext(self):
         msg = (
@@ -1522,92 +1577,99 @@ class AssertFormsetErrorTests(SimpleTestCase):
             " not contain the error 'other error' (actual errors: ['invalid "
             "value'])"
         )
-        response = mock.Mock(context=[{}, {'formset': TestFormset.invalid()}])
+        response = mock.Mock(context=[{}, {"formset": TestFormset.invalid()}])
         with self.assertRaisesMessage(AssertionError, msg):
-            self.assertFormsetError(response, 'formset', 0, 'field', 'other error')
+            self.assertFormsetError(response, "formset", 0, "field", "other error")
 
     def test_basic_positive_assertion(self):
-        response = mock.Mock(context=[{'formset': TestFormset.invalid()}])
-        self.assertFormsetError(response, 'formset', 0, 'field', 'invalid value')
+        response = mock.Mock(context=[{"formset": TestFormset.invalid()}])
+        self.assertFormsetError(response, "formset", 0, "field", "invalid value")
 
     def test_basic_positive_assertion_multicontext(self):
-        response = mock.Mock(context=[{}, {'formset': TestFormset.invalid()}])
-        self.assertFormsetError(response, 'formset', 0, 'field', 'invalid value')
+        response = mock.Mock(context=[{}, {"formset": TestFormset.invalid()}])
+        self.assertFormsetError(response, "formset", 0, "field", "invalid value")
 
     def test_empty_errors_unbound_formset(self):
-        response = mock.Mock(context=[{'formset': TestFormset()}])
-        self.assertFormsetError(response, 'formset', 0, 'field', [])
+        response = mock.Mock(context=[{"formset": TestFormset()}])
+        self.assertFormsetError(response, "formset", 0, "field", [])
 
     def test_empty_errors_valid_formset(self):
-        response = mock.Mock(context=[{}, {'formset': TestFormset.valid()}])
-        self.assertFormsetError(response, 'formset', 0, 'field', [])
+        response = mock.Mock(context=[{}, {"formset": TestFormset.valid()}])
+        self.assertFormsetError(response, "formset", 0, "field", [])
 
     def test_empty_errors_invalid_formset(self):
-        response = mock.Mock(context=[{}, {'formset': TestFormset.invalid()}])
-        self.assertFormsetError(response, 'formset', 0, 'field', [])
+        response = mock.Mock(context=[{}, {"formset": TestFormset.invalid()}])
+        self.assertFormsetError(response, "formset", 0, "field", [])
 
     def test_non_field_errors(self):
-        response = mock.Mock(context=[
-            {},
-            {'formset': TestFormset.invalid(nonfield=True)},
-        ])
-        self.assertFormsetError(response, 'formset', 0, None, 'non-field error')
+        response = mock.Mock(
+            context=[
+                {},
+                {"formset": TestFormset.invalid(nonfield=True)},
+            ]
+        )
+        self.assertFormsetError(response, "formset", 0, None, "non-field error")
 
     def test_non_form_errors(self):
-        response = mock.Mock(context=[
-            {},
-            {'formset': TestFormset.invalid(nonform=True)},
-        ])
-        self.assertFormsetError(response, 'formset', None, None, 'error')
+        response = mock.Mock(
+            context=[
+                {},
+                {"formset": TestFormset.invalid(nonform=True)},
+            ]
+        )
+        self.assertFormsetError(response, "formset", None, None, "error")
 
     def test_formset_named_form(self):
         formset = TestFormset.invalid()
         # The mocked context emulates the template-based rendering of the
         # formset.
-        response = mock.Mock(context=[
-            {'form': formset},
-            {'form': formset.management_form},
-        ])
-        self.assertFormsetError(response, 'form', 0, 'field', 'invalid value')
+        response = mock.Mock(
+            context=[
+                {"form": formset},
+                {"form": formset.management_form},
+            ]
+        )
+        self.assertFormsetError(response, "form", 0, "field", "invalid value")
 
     @ignore_warnings(category=RemovedInDjango50Warning)
     def test_errors_none(self):
-        response = mock.Mock(context=[{'formset': TestFormset.invalid()}])
-        self.assertFormsetError(response, 'formset', 0, 'field', None)
+        response = mock.Mock(context=[{"formset": TestFormset.invalid()}])
+        self.assertFormsetError(response, "formset", 0, "field", None)
 
     def test_errors_none_warning(self):
-        response = mock.Mock(context=[{'formset': TestFormset.invalid()}])
+        response = mock.Mock(context=[{"formset": TestFormset.invalid()}])
         msg = (
-            'Passing errors=None to assertFormsetError() is deprecated, use '
-            'errors=[] instead.'
+            "Passing errors=None to assertFormsetError() is deprecated, use "
+            "errors=[] instead."
         )
         with self.assertWarnsMessage(RemovedInDjango50Warning, msg):
-            self.assertFormsetError(response, 'formset', 0, 'field', None)
+            self.assertFormsetError(response, "formset", 0, "field", None)
 
 
 class FirstUrls:
-    urlpatterns = [path('first/', empty_response, name='first')]
+    urlpatterns = [path("first/", empty_response, name="first")]
 
 
 class SecondUrls:
-    urlpatterns = [path('second/', empty_response, name='second')]
+    urlpatterns = [path("second/", empty_response, name="second")]
 
 
 class SetupTestEnvironmentTests(SimpleTestCase):
-
     def test_setup_test_environment_calling_more_than_once(self):
-        with self.assertRaisesMessage(RuntimeError, "setup_test_environment() was already called"):
+        with self.assertRaisesMessage(
+            RuntimeError, "setup_test_environment() was already called"
+        ):
             setup_test_environment()
 
     def test_allowed_hosts(self):
         for type_ in (list, tuple):
             with self.subTest(type_=type_):
-                allowed_hosts = type_('*')
-                with mock.patch('django.test.utils._TestState') as x:
+                allowed_hosts = type_("*")
+                with mock.patch("django.test.utils._TestState") as x:
                     del x.saved_data
                     with self.settings(ALLOWED_HOSTS=allowed_hosts):
                         setup_test_environment()
-                        self.assertEqual(settings.ALLOWED_HOSTS, ['*', 'testserver'])
+                        self.assertEqual(settings.ALLOWED_HOSTS, ["*", "testserver"])
 
 
 class OverrideSettingsTests(SimpleTestCase):
@@ -1618,54 +1680,54 @@ class OverrideSettingsTests(SimpleTestCase):
 
     @override_settings(ROOT_URLCONF=FirstUrls)
     def test_urlconf_first(self):
-        reverse('first')
+        reverse("first")
 
     @override_settings(ROOT_URLCONF=SecondUrls)
     def test_urlconf_second(self):
-        reverse('second')
+        reverse("second")
 
     def test_urlconf_cache(self):
         with self.assertRaises(NoReverseMatch):
-            reverse('first')
+            reverse("first")
         with self.assertRaises(NoReverseMatch):
-            reverse('second')
+            reverse("second")
 
         with override_settings(ROOT_URLCONF=FirstUrls):
-            self.client.get(reverse('first'))
+            self.client.get(reverse("first"))
             with self.assertRaises(NoReverseMatch):
-                reverse('second')
+                reverse("second")
 
             with override_settings(ROOT_URLCONF=SecondUrls):
                 with self.assertRaises(NoReverseMatch):
-                    reverse('first')
-                self.client.get(reverse('second'))
+                    reverse("first")
+                self.client.get(reverse("second"))
 
-            self.client.get(reverse('first'))
+            self.client.get(reverse("first"))
             with self.assertRaises(NoReverseMatch):
-                reverse('second')
+                reverse("second")
 
         with self.assertRaises(NoReverseMatch):
-            reverse('first')
+            reverse("first")
         with self.assertRaises(NoReverseMatch):
-            reverse('second')
+            reverse("second")
 
     def test_override_media_root(self):
         """
         Overriding the MEDIA_ROOT setting should be reflected in the
         base_location attribute of django.core.files.storage.default_storage.
         """
-        self.assertEqual(default_storage.base_location, '')
-        with self.settings(MEDIA_ROOT='test_value'):
-            self.assertEqual(default_storage.base_location, 'test_value')
+        self.assertEqual(default_storage.base_location, "")
+        with self.settings(MEDIA_ROOT="test_value"):
+            self.assertEqual(default_storage.base_location, "test_value")
 
     def test_override_media_url(self):
         """
         Overriding the MEDIA_URL setting should be reflected in the
         base_url attribute of django.core.files.storage.default_storage.
         """
-        self.assertEqual(default_storage.base_location, '')
-        with self.settings(MEDIA_URL='/test_value/'):
-            self.assertEqual(default_storage.base_url, '/test_value/')
+        self.assertEqual(default_storage.base_location, "")
+        with self.settings(MEDIA_URL="/test_value/"):
+            self.assertEqual(default_storage.base_url, "/test_value/")
 
     def test_override_file_upload_permissions(self):
         """
@@ -1701,8 +1763,8 @@ class OverrideSettingsTests(SimpleTestCase):
         base_url attribute of
         django.contrib.staticfiles.storage.staticfiles_storage.
         """
-        with self.settings(STATIC_URL='/test/'):
-            self.assertEqual(staticfiles_storage.base_url, '/test/')
+        with self.settings(STATIC_URL="/test/"):
+            self.assertEqual(staticfiles_storage.base_url, "/test/")
 
     def test_override_static_root(self):
         """
@@ -1710,16 +1772,16 @@ class OverrideSettingsTests(SimpleTestCase):
         location attribute of
         django.contrib.staticfiles.storage.staticfiles_storage.
         """
-        with self.settings(STATIC_ROOT='/tmp/test'):
-            self.assertEqual(staticfiles_storage.location, os.path.abspath('/tmp/test'))
+        with self.settings(STATIC_ROOT="/tmp/test"):
+            self.assertEqual(staticfiles_storage.location, os.path.abspath("/tmp/test"))
 
     def test_override_staticfiles_storage(self):
         """
         Overriding the STATICFILES_STORAGE setting should be reflected in
         the value of django.contrib.staticfiles.storage.staticfiles_storage.
         """
-        new_class = 'ManifestStaticFilesStorage'
-        new_storage = 'django.contrib.staticfiles.storage.' + new_class
+        new_class = "ManifestStaticFilesStorage"
+        new_storage = "django.contrib.staticfiles.storage." + new_class
         with self.settings(STATICFILES_STORAGE=new_storage):
             self.assertEqual(staticfiles_storage.__class__.__name__, new_class)
 
@@ -1730,7 +1792,7 @@ class OverrideSettingsTests(SimpleTestCase):
         """
         current = get_finders()
         self.assertGreater(len(list(current)), 1)
-        finders = ['django.contrib.staticfiles.finders.FileSystemFinder']
+        finders = ["django.contrib.staticfiles.finders.FileSystemFinder"]
         with self.settings(STATICFILES_FINDERS=finders):
             self.assertEqual(len(list(get_finders())), len(finders))
 
@@ -1740,12 +1802,12 @@ class OverrideSettingsTests(SimpleTestCase):
         the locations attribute of the
         django.contrib.staticfiles.finders.FileSystemFinder instance.
         """
-        finder = get_finder('django.contrib.staticfiles.finders.FileSystemFinder')
-        test_path = '/tmp/test'
-        expected_location = ('', test_path)
+        finder = get_finder("django.contrib.staticfiles.finders.FileSystemFinder")
+        test_path = "/tmp/test"
+        expected_location = ("", test_path)
         self.assertNotIn(expected_location, finder.locations)
         with self.settings(STATICFILES_DIRS=[test_path]):
-            finder = get_finder('django.contrib.staticfiles.finders.FileSystemFinder')
+            finder = get_finder("django.contrib.staticfiles.finders.FileSystemFinder")
             self.assertIn(expected_location, finder.locations)
 
 
@@ -1754,6 +1816,7 @@ class TestBadSetUpTestData(TestCase):
     An exception in setUpTestData() shouldn't leak a transaction which would
     cascade across the rest of the test suite.
     """
+
     class MyException(Exception):
         pass
 
@@ -1783,10 +1846,10 @@ class TestBadSetUpTestData(TestCase):
 
 
 class CaptureOnCommitCallbacksTests(TestCase):
-    databases = {'default', 'other'}
+    databases = {"default", "other"}
     callback_called = False
 
-    def enqueue_callback(self, using='default'):
+    def enqueue_callback(self, using="default"):
         def hook():
             self.callback_called = True
 
@@ -1802,8 +1865,8 @@ class CaptureOnCommitCallbacksTests(TestCase):
         self.assertIs(self.callback_called, True)
 
     def test_using(self):
-        with self.captureOnCommitCallbacks(using='other') as callbacks:
-            self.enqueue_callback(using='other')
+        with self.captureOnCommitCallbacks(using="other") as callbacks:
+            self.enqueue_callback(using="other")
 
         self.assertEqual(len(callbacks), 1)
         self.assertIs(self.callback_called, False)
@@ -1811,8 +1874,8 @@ class CaptureOnCommitCallbacksTests(TestCase):
         self.assertIs(self.callback_called, True)
 
     def test_different_using(self):
-        with self.captureOnCommitCallbacks(using='default') as callbacks:
-            self.enqueue_callback(using='other')
+        with self.captureOnCommitCallbacks(using="default") as callbacks:
+            self.enqueue_callback(using="other")
 
         self.assertEqual(callbacks, [])
 
@@ -1827,7 +1890,7 @@ class CaptureOnCommitCallbacksTests(TestCase):
         def pre_hook():
             pass
 
-        transaction.on_commit(pre_hook, using='default')
+        transaction.on_commit(pre_hook, using="default")
         with self.captureOnCommitCallbacks() as callbacks:
             self.enqueue_callback()
 
@@ -1944,7 +2007,7 @@ class DisallowedDatabaseQueriesTests(SimpleTestCase):
 
 
 class AllowedDatabaseQueriesTests(SimpleTestCase):
-    databases = {'default'}
+    databases = {"default"}
 
     def test_allowed_database_queries(self):
         Car.objects.first()
@@ -1955,10 +2018,10 @@ class AllowedDatabaseQueriesTests(SimpleTestCase):
 
 class DatabaseAliasTests(SimpleTestCase):
     def setUp(self):
-        self.addCleanup(setattr, self.__class__, 'databases', self.databases)
+        self.addCleanup(setattr, self.__class__, "databases", self.databases)
 
     def test_no_close_match(self):
-        self.__class__.databases = {'void'}
+        self.__class__.databases = {"void"}
         message = (
             "test_utils.tests.DatabaseAliasTests.databases refers to 'void' which is not defined "
             "in settings.DATABASES."
@@ -1967,7 +2030,7 @@ class DatabaseAliasTests(SimpleTestCase):
             self._validate_databases()
 
     def test_close_match(self):
-        self.__class__.databases = {'defualt'}
+        self.__class__.databases = {"defualt"}
         message = (
             "test_utils.tests.DatabaseAliasTests.databases refers to 'defualt' which is not defined "
             "in settings.DATABASES. Did you mean 'default'?"
@@ -1976,46 +2039,58 @@ class DatabaseAliasTests(SimpleTestCase):
             self._validate_databases()
 
     def test_match(self):
-        self.__class__.databases = {'default', 'other'}
-        self.assertEqual(self._validate_databases(), frozenset({'default', 'other'}))
+        self.__class__.databases = {"default", "other"}
+        self.assertEqual(self._validate_databases(), frozenset({"default", "other"}))
 
     def test_all(self):
-        self.__class__.databases = '__all__'
+        self.__class__.databases = "__all__"
         self.assertEqual(self._validate_databases(), frozenset(connections))
 
 
-@isolate_apps('test_utils', attr_name='class_apps')
+@isolate_apps("test_utils", attr_name="class_apps")
 class IsolatedAppsTests(SimpleTestCase):
     def test_installed_apps(self):
-        self.assertEqual([app_config.label for app_config in self.class_apps.get_app_configs()], ['test_utils'])
+        self.assertEqual(
+            [app_config.label for app_config in self.class_apps.get_app_configs()],
+            ["test_utils"],
+        )
 
     def test_class_decoration(self):
         class ClassDecoration(models.Model):
             pass
+
         self.assertEqual(ClassDecoration._meta.apps, self.class_apps)
 
-    @isolate_apps('test_utils', kwarg_name='method_apps')
+    @isolate_apps("test_utils", kwarg_name="method_apps")
     def test_method_decoration(self, method_apps):
         class MethodDecoration(models.Model):
             pass
+
         self.assertEqual(MethodDecoration._meta.apps, method_apps)
 
     def test_context_manager(self):
-        with isolate_apps('test_utils') as context_apps:
+        with isolate_apps("test_utils") as context_apps:
+
             class ContextManager(models.Model):
                 pass
+
         self.assertEqual(ContextManager._meta.apps, context_apps)
 
-    @isolate_apps('test_utils', kwarg_name='method_apps')
+    @isolate_apps("test_utils", kwarg_name="method_apps")
     def test_nested(self, method_apps):
         class MethodDecoration(models.Model):
             pass
-        with isolate_apps('test_utils') as context_apps:
+
+        with isolate_apps("test_utils") as context_apps:
+
             class ContextManager(models.Model):
                 pass
-            with isolate_apps('test_utils') as nested_context_apps:
+
+            with isolate_apps("test_utils") as nested_context_apps:
+
                 class NestedContextManager(models.Model):
                     pass
+
         self.assertEqual(MethodDecoration._meta.apps, method_apps)
         self.assertEqual(ContextManager._meta.apps, context_apps)
         self.assertEqual(NestedContextManager._meta.apps, nested_context_apps)
@@ -2030,18 +2105,18 @@ class DoNothingDecorator(TestContextDecorator):
 
 
 class TestContextDecoratorTests(SimpleTestCase):
-
-    @mock.patch.object(DoNothingDecorator, 'disable')
+    @mock.patch.object(DoNothingDecorator, "disable")
     def test_exception_in_setup(self, mock_disable):
         """An exception is setUp() is reraised after disable() is called."""
+
         class ExceptionInSetUp(unittest.TestCase):
             def setUp(self):
-                raise NotImplementedError('reraised')
+                raise NotImplementedError("reraised")
 
         decorator = DoNothingDecorator()
         decorated_test_class = decorator.__call__(ExceptionInSetUp)()
         self.assertFalse(mock_disable.called)
-        with self.assertRaisesMessage(NotImplementedError, 'reraised'):
+        with self.assertRaisesMessage(NotImplementedError, "reraised"):
             decorated_test_class.setUp()
         decorated_test_class.doCleanups()
         self.assertTrue(mock_disable.called)
@@ -2051,19 +2126,19 @@ class TestContextDecoratorTests(SimpleTestCase):
 
         class SaveCallsDecorator(TestContextDecorator):
             def enable(self):
-                calls.append('enable')
+                calls.append("enable")
 
             def disable(self):
-                calls.append('disable')
+                calls.append("disable")
 
         class AddCleanupInSetUp(unittest.TestCase):
             def setUp(self):
-                calls.append('setUp')
-                self.addCleanup(lambda: calls.append('cleanup'))
+                calls.append("setUp")
+                self.addCleanup(lambda: calls.append("cleanup"))
 
         decorator = SaveCallsDecorator()
         decorated_test_class = decorator.__call__(AddCleanupInSetUp)()
         decorated_test_class.setUp()
         decorated_test_class.tearDown()
         decorated_test_class.doCleanups()
-        self.assertEqual(calls, ['enable', 'setUp', 'cleanup', 'disable'])
+        self.assertEqual(calls, ["enable", "setUp", "cleanup", "disable"])
diff --git a/tests/test_utils/urls.py b/tests/test_utils/urls.py
index 6b060dff95..37d0c76a11 100644
--- a/tests/test_utils/urls.py
+++ b/tests/test_utils/urls.py
@@ -3,6 +3,8 @@ from django.urls import path
 from . import views
 
 urlpatterns = [
-    path('test_utils/get_person/<int:pk>/', views.get_person),
-    path('test_utils/no_template_used/', views.no_template_used, name='no_template_used'),
+    path("test_utils/get_person/<int:pk>/", views.get_person),
+    path(
+        "test_utils/no_template_used/", views.no_template_used, name="no_template_used"
+    ),
 ]