Refs #33476 -- Reformatted code with Black.

4 files changed, 250 insertions, 203 deletions

diff --git a/tests/template_backends/test_django.py b/tests/template_backends/test_django.py
index 047af67df5..abd4e3cdb5 100644
--- a/tests/template_backends/test_django.py
+++ b/tests/template_backends/test_django.py
@@ -13,89 +13,95 @@ from .test_dummy import TemplateStringsTests
 class DjangoTemplatesTests(TemplateStringsTests):
 
     engine_class = DjangoTemplates
-    backend_name = 'django'
+    backend_name = "django"
     request_factory = RequestFactory()
 
     def test_context_has_priority_over_template_context_processors(self):
         # See ticket #23789.
-        engine = DjangoTemplates({
-            'DIRS': [],
-            'APP_DIRS': False,
-            'NAME': 'django',
-            'OPTIONS': {
-                'context_processors': [test_processor_name],
-            },
-        })
-
-        template = engine.from_string('{{ processors }}')
-        request = self.request_factory.get('/')
+        engine = DjangoTemplates(
+            {
+                "DIRS": [],
+                "APP_DIRS": False,
+                "NAME": "django",
+                "OPTIONS": {
+                    "context_processors": [test_processor_name],
+                },
+            }
+        )
+
+        template = engine.from_string("{{ processors }}")
+        request = self.request_factory.get("/")
 
         # Context processors run
         content = template.render({}, request)
-        self.assertEqual(content, 'yes')
+        self.assertEqual(content, "yes")
 
         # Context overrides context processors
-        content = template.render({'processors': 'no'}, request)
-        self.assertEqual(content, 'no')
+        content = template.render({"processors": "no"}, request)
+        self.assertEqual(content, "no")
 
     def test_render_requires_dict(self):
         """django.Template.render() requires a dict."""
-        engine = DjangoTemplates({
-            'DIRS': [],
-            'APP_DIRS': False,
-            'NAME': 'django',
-            'OPTIONS': {},
-        })
-        template = engine.from_string('')
+        engine = DjangoTemplates(
+            {
+                "DIRS": [],
+                "APP_DIRS": False,
+                "NAME": "django",
+                "OPTIONS": {},
+            }
+        )
+        template = engine.from_string("")
         context = Context()
-        request_context = RequestContext(self.request_factory.get('/'), {})
-        msg = 'context must be a dict rather than Context.'
+        request_context = RequestContext(self.request_factory.get("/"), {})
+        msg = "context must be a dict rather than Context."
         with self.assertRaisesMessage(TypeError, msg):
             template.render(context)
-        msg = 'context must be a dict rather than RequestContext.'
+        msg = "context must be a dict rather than RequestContext."
         with self.assertRaisesMessage(TypeError, msg):
             template.render(request_context)
 
-    @override_settings(INSTALLED_APPS=['template_backends.apps.good'])
+    @override_settings(INSTALLED_APPS=["template_backends.apps.good"])
     def test_templatetag_discovery(self):
-        engine = DjangoTemplates({
-            'DIRS': [],
-            'APP_DIRS': False,
-            'NAME': 'django',
-            'OPTIONS': {
-                'libraries': {
-                    'alternate': 'template_backends.apps.good.templatetags.good_tags',
-                    'override': 'template_backends.apps.good.templatetags.good_tags',
+        engine = DjangoTemplates(
+            {
+                "DIRS": [],
+                "APP_DIRS": False,
+                "NAME": "django",
+                "OPTIONS": {
+                    "libraries": {
+                        "alternate": "template_backends.apps.good.templatetags.good_tags",
+                        "override": "template_backends.apps.good.templatetags.good_tags",
+                    },
                 },
-            },
-        })
+            }
+        )
 
         # libraries are discovered from installed applications
         self.assertEqual(
-            engine.engine.libraries['good_tags'],
-            'template_backends.apps.good.templatetags.good_tags',
+            engine.engine.libraries["good_tags"],
+            "template_backends.apps.good.templatetags.good_tags",
         )
         self.assertEqual(
-            engine.engine.libraries['subpackage.tags'],
-            'template_backends.apps.good.templatetags.subpackage.tags',
+            engine.engine.libraries["subpackage.tags"],
+            "template_backends.apps.good.templatetags.subpackage.tags",
         )
         # libraries are discovered from django.templatetags
         self.assertEqual(
-            engine.engine.libraries['static'],
-            'django.templatetags.static',
+            engine.engine.libraries["static"],
+            "django.templatetags.static",
         )
         # libraries passed in OPTIONS are registered
         self.assertEqual(
-            engine.engine.libraries['alternate'],
-            'template_backends.apps.good.templatetags.good_tags',
+            engine.engine.libraries["alternate"],
+            "template_backends.apps.good.templatetags.good_tags",
         )
         # libraries passed in OPTIONS take precedence over discovered ones
         self.assertEqual(
-            engine.engine.libraries['override'],
-            'template_backends.apps.good.templatetags.good_tags',
+            engine.engine.libraries["override"],
+            "template_backends.apps.good.templatetags.good_tags",
         )
 
-    @override_settings(INSTALLED_APPS=['template_backends.apps.importerror'])
+    @override_settings(INSTALLED_APPS=["template_backends.apps.importerror"])
     def test_templatetag_discovery_import_error(self):
         """
         Import errors in tag modules should be reraised with a helpful message.
@@ -103,77 +109,99 @@ class DjangoTemplatesTests(TemplateStringsTests):
         with self.assertRaisesMessage(
             InvalidTemplateLibrary,
             "ImportError raised when trying to load "
-            "'template_backends.apps.importerror.templatetags.broken_tags'"
+            "'template_backends.apps.importerror.templatetags.broken_tags'",
         ) as cm:
-            DjangoTemplates({
-                'DIRS': [],
-                'APP_DIRS': False,
-                'NAME': 'django',
-                'OPTIONS': {},
-            })
+            DjangoTemplates(
+                {
+                    "DIRS": [],
+                    "APP_DIRS": False,
+                    "NAME": "django",
+                    "OPTIONS": {},
+                }
+            )
         self.assertIsInstance(cm.exception.__cause__, ImportError)
 
     def test_builtins_discovery(self):
-        engine = DjangoTemplates({
-            'DIRS': [],
-            'APP_DIRS': False,
-            'NAME': 'django',
-            'OPTIONS': {
-                'builtins': ['template_backends.apps.good.templatetags.good_tags'],
-            },
-        })
+        engine = DjangoTemplates(
+            {
+                "DIRS": [],
+                "APP_DIRS": False,
+                "NAME": "django",
+                "OPTIONS": {
+                    "builtins": ["template_backends.apps.good.templatetags.good_tags"],
+                },
+            }
+        )
 
         self.assertEqual(
-            engine.engine.builtins, [
-                'django.template.defaulttags',
-                'django.template.defaultfilters',
-                'django.template.loader_tags',
-                'template_backends.apps.good.templatetags.good_tags',
-            ]
+            engine.engine.builtins,
+            [
+                "django.template.defaulttags",
+                "django.template.defaultfilters",
+                "django.template.loader_tags",
+                "template_backends.apps.good.templatetags.good_tags",
+            ],
         )
 
     def test_autoescape_off(self):
-        templates = [{
-            'BACKEND': 'django.template.backends.django.DjangoTemplates',
-            'OPTIONS': {'autoescape': False},
-        }]
+        templates = [
+            {
+                "BACKEND": "django.template.backends.django.DjangoTemplates",
+                "OPTIONS": {"autoescape": False},
+            }
+        ]
         engines = EngineHandler(templates=templates)
         self.assertEqual(
-            engines['django'].from_string('Hello, {{ name }}').render({'name': 'Bob & Jim'}),
-            'Hello, Bob & Jim'
+            engines["django"]
+            .from_string("Hello, {{ name }}")
+            .render({"name": "Bob & Jim"}),
+            "Hello, Bob & Jim",
         )
 
     def test_autoescape_default(self):
-        templates = [{
-            'BACKEND': 'django.template.backends.django.DjangoTemplates',
-        }]
+        templates = [
+            {
+                "BACKEND": "django.template.backends.django.DjangoTemplates",
+            }
+        ]
         engines = EngineHandler(templates=templates)
         self.assertEqual(
-            engines['django'].from_string('Hello, {{ name }}').render({'name': 'Bob & Jim'}),
-            'Hello, Bob & Jim'
+            engines["django"]
+            .from_string("Hello, {{ name }}")
+            .render({"name": "Bob & Jim"}),
+            "Hello, Bob & Jim",
         )
 
     default_loaders = [
-        'django.template.loaders.filesystem.Loader',
-        'django.template.loaders.app_directories.Loader',
+        "django.template.loaders.filesystem.Loader",
+        "django.template.loaders.app_directories.Loader",
     ]
 
     @override_settings(DEBUG=False)
     def test_non_debug_default_template_loaders(self):
-        engine = DjangoTemplates({'DIRS': [], 'APP_DIRS': True, 'NAME': 'django', 'OPTIONS': {}})
-        self.assertEqual(engine.engine.loaders, [('django.template.loaders.cached.Loader', self.default_loaders)])
+        engine = DjangoTemplates(
+            {"DIRS": [], "APP_DIRS": True, "NAME": "django", "OPTIONS": {}}
+        )
+        self.assertEqual(
+            engine.engine.loaders,
+            [("django.template.loaders.cached.Loader", self.default_loaders)],
+        )
 
     @override_settings(DEBUG=True)
     def test_debug_default_template_loaders(self):
-        engine = DjangoTemplates({'DIRS': [], 'APP_DIRS': True, 'NAME': 'django', 'OPTIONS': {}})
+        engine = DjangoTemplates(
+            {"DIRS": [], "APP_DIRS": True, "NAME": "django", "OPTIONS": {}}
+        )
         self.assertEqual(engine.engine.loaders, self.default_loaders)
 
     def test_dirs_pathlib(self):
-        engine = DjangoTemplates({
-            'DIRS': [Path(__file__).parent / 'templates' / 'template_backends'],
-            'APP_DIRS': False,
-            'NAME': 'django',
-            'OPTIONS': {},
-        })
-        template = engine.get_template('hello.html')
-        self.assertEqual(template.render({'name': 'Joe'}), 'Hello Joe!\n')
+        engine = DjangoTemplates(
+            {
+                "DIRS": [Path(__file__).parent / "templates" / "template_backends"],
+                "APP_DIRS": False,
+                "NAME": "django",
+                "OPTIONS": {},
+            }
+        )
+        template = engine.get_template("hello.html")
+        self.assertEqual(template.render({"name": "Joe"}), "Hello Joe!\n")
diff --git a/tests/template_backends/test_dummy.py b/tests/template_backends/test_dummy.py
index 8c8cef68ce..adddbc6000 100644
--- a/tests/template_backends/test_dummy.py
+++ b/tests/template_backends/test_dummy.py
@@ -3,7 +3,10 @@ import re
 from django.forms import CharField, Form, Media
 from django.http import HttpRequest, HttpResponse
 from django.middleware.csrf import (
-    CSRF_TOKEN_LENGTH, CsrfViewMiddleware, _unmask_cipher_token, get_token,
+    CSRF_TOKEN_LENGTH,
+    CsrfViewMiddleware,
+    _unmask_cipher_token,
+    get_token,
 )
 from django.template import TemplateDoesNotExist, TemplateSyntaxError
 from django.template.backends.dummy import TemplateStrings
@@ -13,17 +16,17 @@ from django.test import SimpleTestCase
 class TemplateStringsTests(SimpleTestCase):
 
     engine_class = TemplateStrings
-    backend_name = 'dummy'
+    backend_name = "dummy"
     options = {}
 
     @classmethod
     def setUpClass(cls):
         super().setUpClass()
         params = {
-            'DIRS': [],
-            'APP_DIRS': True,
-            'NAME': cls.backend_name,
-            'OPTIONS': cls.options,
+            "DIRS": [],
+            "APP_DIRS": True,
+            "NAME": cls.backend_name,
+            "OPTIONS": cls.options,
         }
         cls.engine = cls.engine_class(params)
 
@@ -33,44 +36,44 @@ class TemplateStringsTests(SimpleTestCase):
         self.assertEqual(content, "Hello!\n")
 
     def test_get_template(self):
-        template = self.engine.get_template('template_backends/hello.html')
-        content = template.render({'name': 'world'})
+        template = self.engine.get_template("template_backends/hello.html")
+        content = template.render({"name": "world"})
         self.assertEqual(content, "Hello world!\n")
 
     def test_get_template_nonexistent(self):
         with self.assertRaises(TemplateDoesNotExist) as e:
-            self.engine.get_template('template_backends/nonexistent.html')
+            self.engine.get_template("template_backends/nonexistent.html")
         self.assertEqual(e.exception.backend, self.engine)
 
     def test_get_template_syntax_error(self):
         # There's no way to trigger a syntax error with the dummy backend.
         # The test still lives here to factor it between other backends.
-        if self.backend_name == 'dummy':
+        if self.backend_name == "dummy":
             self.skipTest("test doesn't apply to dummy backend")
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('template_backends/syntax_error.html')
+            self.engine.get_template("template_backends/syntax_error.html")
 
     def test_html_escaping(self):
-        template = self.engine.get_template('template_backends/hello.html')
-        context = {'name': '<script>alert("XSS!");</script>'}
+        template = self.engine.get_template("template_backends/hello.html")
+        context = {"name": '<script>alert("XSS!");</script>'}
         content = template.render(context)
 
-        self.assertIn('&lt;script&gt;', content)
-        self.assertNotIn('<script>', content)
+        self.assertIn("&lt;script&gt;", content)
+        self.assertNotIn("<script>", content)
 
     def test_django_html_escaping(self):
-        if self.backend_name == 'dummy':
+        if self.backend_name == "dummy":
             self.skipTest("test doesn't apply to dummy backend")
 
         class TestForm(Form):
             test_field = CharField()
 
-        media = Media(js=['my-script.js'])
+        media = Media(js=["my-script.js"])
         form = TestForm()
-        template = self.engine.get_template('template_backends/django_escaping.html')
-        content = template.render({'media': media, 'test_form': form})
+        template = self.engine.get_template("template_backends/django_escaping.html")
+        content = template.render({"media": media, "test_form": form})
 
-        expected = '{}\n\n{}\n\n{}'.format(media, form, form['test_field'])
+        expected = "{}\n\n{}\n\n{}".format(media, form, form["test_field"])
 
         self.assertHTMLEqual(content, expected)
 
@@ -82,21 +85,25 @@ class TemplateStringsTests(SimpleTestCase):
 
     def test_csrf_token(self):
         request = HttpRequest()
-        CsrfViewMiddleware(lambda req: HttpResponse()).process_view(request, lambda r: None, (), {})
+        CsrfViewMiddleware(lambda req: HttpResponse()).process_view(
+            request, lambda r: None, (), {}
+        )
 
-        template = self.engine.get_template('template_backends/csrf.html')
+        template = self.engine.get_template("template_backends/csrf.html")
         content = template.render(request=request)
 
         expected = '<input type="hidden" name="csrfmiddlewaretoken" value="([^"]+)">'
-        match = re.match(expected, content) or re.match(expected.replace('"', "'"), content)
+        match = re.match(expected, content) or re.match(
+            expected.replace('"', "'"), content
+        )
         self.assertTrue(match, "hidden csrftoken field not found in output")
         self.check_tokens_equivalent(match[1], get_token(request))
 
     def test_no_directory_traversal(self):
         with self.assertRaises(TemplateDoesNotExist):
-            self.engine.get_template('../forbidden/template_backends/hello.html')
+            self.engine.get_template("../forbidden/template_backends/hello.html")
 
     def test_non_ascii_characters(self):
-        template = self.engine.get_template('template_backends/hello.html')
-        content = template.render({'name': 'Jérôme'})
+        template = self.engine.get_template("template_backends/hello.html")
+        content = template.render({"name": "Jérôme"})
         self.assertEqual(content, "Hello Jérôme!\n")
diff --git a/tests/template_backends/test_jinja2.py b/tests/template_backends/test_jinja2.py
index b908431914..8b282d43af 100644
--- a/tests/template_backends/test_jinja2.py
+++ b/tests/template_backends/test_jinja2.py
@@ -19,22 +19,22 @@ else:
 class Jinja2Tests(TemplateStringsTests):
 
     engine_class = Jinja2
-    backend_name = 'jinja2'
+    backend_name = "jinja2"
     options = {
-        'keep_trailing_newline': True,
-        'context_processors': [
-            'django.template.context_processors.static',
+        "keep_trailing_newline": True,
+        "context_processors": [
+            "django.template.context_processors.static",
         ],
     }
 
     def test_origin(self):
-        template = self.engine.get_template('template_backends/hello.html')
-        self.assertTrue(template.origin.name.endswith('hello.html'))
-        self.assertEqual(template.origin.template_name, 'template_backends/hello.html')
+        template = self.engine.get_template("template_backends/hello.html")
+        self.assertTrue(template.origin.name.endswith("hello.html"))
+        self.assertEqual(template.origin.template_name, "template_backends/hello.html")
 
     def test_origin_from_string(self):
-        template = self.engine.from_string('Hello!\n')
-        self.assertEqual(template.origin.name, '<template>')
+        template = self.engine.from_string("Hello!\n")
+        self.assertEqual(template.origin.name, "<template>")
         self.assertIsNone(template.origin.template_name)
 
     def test_self_context(self):
@@ -44,91 +44,95 @@ class Jinja2Tests(TemplateStringsTests):
         # self will be overridden to be a TemplateReference, so the self
         # variable will not come through. Attempting to use one though should
         # not throw an error.
-        template = self.engine.from_string('hello {{ foo }}!')
-        content = template.render(context={'self': 'self', 'foo': 'world'})
-        self.assertEqual(content, 'hello world!')
+        template = self.engine.from_string("hello {{ foo }}!")
+        content = template.render(context={"self": "self", "foo": "world"})
+        self.assertEqual(content, "hello world!")
 
     def test_exception_debug_info_min_context(self):
         with self.assertRaises(TemplateSyntaxError) as e:
-            self.engine.get_template('template_backends/syntax_error.html')
+            self.engine.get_template("template_backends/syntax_error.html")
         debug = e.exception.template_debug
-        self.assertEqual(debug['after'], '')
-        self.assertEqual(debug['before'], '')
-        self.assertEqual(debug['during'], '{% block %}')
-        self.assertEqual(debug['bottom'], 1)
-        self.assertEqual(debug['top'], 0)
-        self.assertEqual(debug['line'], 1)
-        self.assertEqual(debug['total'], 1)
-        self.assertEqual(len(debug['source_lines']), 1)
-        self.assertTrue(debug['name'].endswith('syntax_error.html'))
-        self.assertIn('message', debug)
+        self.assertEqual(debug["after"], "")
+        self.assertEqual(debug["before"], "")
+        self.assertEqual(debug["during"], "{% block %}")
+        self.assertEqual(debug["bottom"], 1)
+        self.assertEqual(debug["top"], 0)
+        self.assertEqual(debug["line"], 1)
+        self.assertEqual(debug["total"], 1)
+        self.assertEqual(len(debug["source_lines"]), 1)
+        self.assertTrue(debug["name"].endswith("syntax_error.html"))
+        self.assertIn("message", debug)
 
     def test_exception_debug_info_max_context(self):
         with self.assertRaises(TemplateSyntaxError) as e:
-            self.engine.get_template('template_backends/syntax_error2.html')
+            self.engine.get_template("template_backends/syntax_error2.html")
         debug = e.exception.template_debug
-        self.assertEqual(debug['after'], '')
-        self.assertEqual(debug['before'], '')
-        self.assertEqual(debug['during'], '{% block %}')
-        self.assertEqual(debug['bottom'], 26)
-        self.assertEqual(debug['top'], 5)
-        self.assertEqual(debug['line'], 16)
-        self.assertEqual(debug['total'], 31)
-        self.assertEqual(len(debug['source_lines']), 21)
-        self.assertTrue(debug['name'].endswith('syntax_error2.html'))
-        self.assertIn('message', debug)
+        self.assertEqual(debug["after"], "")
+        self.assertEqual(debug["before"], "")
+        self.assertEqual(debug["during"], "{% block %}")
+        self.assertEqual(debug["bottom"], 26)
+        self.assertEqual(debug["top"], 5)
+        self.assertEqual(debug["line"], 16)
+        self.assertEqual(debug["total"], 31)
+        self.assertEqual(len(debug["source_lines"]), 21)
+        self.assertTrue(debug["name"].endswith("syntax_error2.html"))
+        self.assertIn("message", debug)
 
     def test_context_processors(self):
-        request = RequestFactory().get('/')
-        template = self.engine.from_string('Static URL: {{ STATIC_URL }}')
+        request = RequestFactory().get("/")
+        template = self.engine.from_string("Static URL: {{ STATIC_URL }}")
         content = template.render(request=request)
-        self.assertEqual(content, 'Static URL: /static/')
-        with self.settings(STATIC_URL='/s/'):
+        self.assertEqual(content, "Static URL: /static/")
+        with self.settings(STATIC_URL="/s/"):
             content = template.render(request=request)
-        self.assertEqual(content, 'Static URL: /s/')
+        self.assertEqual(content, "Static URL: /s/")
 
     def test_dirs_pathlib(self):
-        engine = Jinja2({
-            'DIRS': [Path(__file__).parent / 'templates' / 'template_backends'],
-            'APP_DIRS': False,
-            'NAME': 'jinja2',
-            'OPTIONS': {},
-        })
-        template = engine.get_template('hello.html')
-        self.assertEqual(template.render({'name': 'Joe'}), 'Hello Joe!')
+        engine = Jinja2(
+            {
+                "DIRS": [Path(__file__).parent / "templates" / "template_backends"],
+                "APP_DIRS": False,
+                "NAME": "jinja2",
+                "OPTIONS": {},
+            }
+        )
+        template = engine.get_template("hello.html")
+        self.assertEqual(template.render({"name": "Joe"}), "Hello Joe!")
 
     def test_template_render_nested_error(self):
-        template = self.engine.get_template('template_backends/syntax_error_include.html')
+        template = self.engine.get_template(
+            "template_backends/syntax_error_include.html"
+        )
         with self.assertRaises(TemplateSyntaxError) as e:
             template.render(context={})
         debug = e.exception.template_debug
-        self.assertEqual(debug['after'], '')
-        self.assertEqual(debug['before'], '')
-        self.assertEqual(debug['during'], '{% block %}')
-        self.assertEqual(debug['bottom'], 1)
-        self.assertEqual(debug['top'], 0)
-        self.assertEqual(debug['line'], 1)
-        self.assertEqual(debug['total'], 1)
-        self.assertEqual(len(debug['source_lines']), 1)
-        self.assertTrue(debug['name'].endswith('syntax_error.html'))
-        self.assertIn('message', debug)
+        self.assertEqual(debug["after"], "")
+        self.assertEqual(debug["before"], "")
+        self.assertEqual(debug["during"], "{% block %}")
+        self.assertEqual(debug["bottom"], 1)
+        self.assertEqual(debug["top"], 0)
+        self.assertEqual(debug["line"], 1)
+        self.assertEqual(debug["total"], 1)
+        self.assertEqual(len(debug["source_lines"]), 1)
+        self.assertTrue(debug["name"].endswith("syntax_error.html"))
+        self.assertIn("message", debug)
 
     def test_template_render_error_nonexistent_source(self):
-        template = self.engine.get_template('template_backends/hello.html')
+        template = self.engine.get_template("template_backends/hello.html")
         with mock.patch(
-            'jinja2.environment.Template.render',
-            side_effect=jinja2.TemplateSyntaxError('', 1, filename='nonexistent.html'),
+            "jinja2.environment.Template.render",
+            side_effect=jinja2.TemplateSyntaxError("", 1, filename="nonexistent.html"),
         ):
             with self.assertRaises(TemplateSyntaxError) as e:
                 template.render(context={})
         debug = e.exception.template_debug
-        self.assertEqual(debug['after'], '')
-        self.assertEqual(debug['before'], '')
-        self.assertEqual(debug['during'], '')
-        self.assertEqual(debug['bottom'], 0)
-        self.assertEqual(debug['top'], 0)
-        self.assertEqual(debug['line'], 1)
-        self.assertEqual(debug['total'], 0)
-        self.assertEqual(len(debug['source_lines']), 0)
-        self.assertTrue(debug['name'].endswith('nonexistent.html'))
-        self.assertIn('message', debug)
+        self.assertEqual(debug["after"], "")
+        self.assertEqual(debug["before"], "")
+        self.assertEqual(debug["during"], "")
+        self.assertEqual(debug["bottom"], 0)
+        self.assertEqual(debug["top"], 0)
+        self.assertEqual(debug["line"], 1)
+        self.assertEqual(debug["total"], 0)
+        self.assertEqual(len(debug["source_lines"]), 0)
+        self.assertTrue(debug["name"].endswith("nonexistent.html"))
+        self.assertIn("message", debug)
diff --git a/tests/template_backends/test_utils.py b/tests/template_backends/test_utils.py
index d0bd01cdc2..15dbaae818 100644
--- a/tests/template_backends/test_utils.py
+++ b/tests/template_backends/test_utils.py
@@ -4,8 +4,7 @@ from django.test import SimpleTestCase, override_settings
 
 
 class TemplateUtilsTests(SimpleTestCase):
-
-    @override_settings(TEMPLATES=[{'BACKEND': 'raise.import.error'}])
+    @override_settings(TEMPLATES=[{"BACKEND": "raise.import.error"}])
     def test_backend_import_error(self):
         """
         Failing to import a backend keeps raising the original import error
@@ -16,28 +15,37 @@ class TemplateUtilsTests(SimpleTestCase):
         with self.assertRaisesMessage(ImportError, "No module named 'raise"):
             engines.all()
 
-    @override_settings(TEMPLATES=[{
-        'BACKEND': 'django.template.backends.django.DjangoTemplates',
-        # Incorrect: APP_DIRS and loaders are mutually incompatible.
-        'APP_DIRS': True,
-        'OPTIONS': {'loaders': []},
-    }])
+    @override_settings(
+        TEMPLATES=[
+            {
+                "BACKEND": "django.template.backends.django.DjangoTemplates",
+                # Incorrect: APP_DIRS and loaders are mutually incompatible.
+                "APP_DIRS": True,
+                "OPTIONS": {"loaders": []},
+            }
+        ]
+    )
     def test_backend_improperly_configured(self):
         """
         Failing to initialize a backend keeps raising the original exception
         (#24265).
         """
-        msg = 'app_dirs must not be set when loaders is defined.'
+        msg = "app_dirs must not be set when loaders is defined."
         with self.assertRaisesMessage(ImproperlyConfigured, msg):
             engines.all()
         with self.assertRaisesMessage(ImproperlyConfigured, msg):
             engines.all()
 
-    @override_settings(TEMPLATES=[{
-        'BACKEND': 'django.template.backends.django.DjangoTemplates',
-    }, {
-        'BACKEND': 'django.template.backends.django.DjangoTemplates',
-    }])
+    @override_settings(
+        TEMPLATES=[
+            {
+                "BACKEND": "django.template.backends.django.DjangoTemplates",
+            },
+            {
+                "BACKEND": "django.template.backends.django.DjangoTemplates",
+            },
+        ]
+    )
     def test_backend_names_must_be_unique(self):
         msg = (
             "Template engine aliases aren't unique, duplicates: django. Set "