Refs #33476 -- Reformatted code with Black.

46 files changed, 3691 insertions, 2644 deletions

diff --git a/tests/template_tests/syntax_tests/i18n/base.py b/tests/template_tests/syntax_tests/i18n/base.py
index 61d2bbdb1c..6197179ee4 100644
--- a/tests/template_tests/syntax_tests/i18n/base.py
+++ b/tests/template_tests/syntax_tests/i18n/base.py
@@ -7,7 +7,7 @@ from django.utils.translation import activate, get_language
 here = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 pdir = os.path.split(os.path.split(os.path.abspath(here))[0])[0]
 extended_locale_paths = settings.LOCALE_PATHS + [
-    os.path.join(pdir, 'i18n', 'other', 'locale'),
+    os.path.join(pdir, "i18n", "other", "locale"),
 ]
 
 
diff --git a/tests/template_tests/syntax_tests/i18n/test_blocktranslate.py b/tests/template_tests/syntax_tests/i18n/test_blocktranslate.py
index 114d4392c6..8ad004a899 100644
--- a/tests/template_tests/syntax_tests/i18n/test_blocktranslate.py
+++ b/tests/template_tests/syntax_tests/i18n/test_blocktranslate.py
@@ -18,18 +18,18 @@ from .base import MultipleLocaleActivationTestCase, extended_locale_paths, here
 
 def setup(templates, *args, **kwargs):
     blocktranslate_setup = base_setup(templates, *args, **kwargs)
-    blocktrans_setup = base_setup({
-        name: template.replace(
-            '{% blocktranslate ', '{% blocktrans '
-        ).replace(
-            '{% endblocktranslate %}', '{% endblocktrans %}'
-        )
-        for name, template in templates.items()
-    })
+    blocktrans_setup = base_setup(
+        {
+            name: template.replace("{% blocktranslate ", "{% blocktrans ").replace(
+                "{% endblocktranslate %}", "{% endblocktrans %}"
+            )
+            for name, template in templates.items()
+        }
+    )
 
     tags = {
-        'blocktrans': blocktrans_setup,
-        'blocktranslate': blocktranslate_setup,
+        "blocktrans": blocktrans_setup,
+        "blocktranslate": blocktranslate_setup,
     }
 
     def decorator(func):
@@ -37,300 +37,459 @@ def setup(templates, *args, **kwargs):
         def inner(self, *args):
             signature = inspect.signature(func)
             for tag_name, setup_func in tags.items():
-                if 'tag_name' in signature.parameters:
+                if "tag_name" in signature.parameters:
                     setup_func(partial(func, tag_name=tag_name))(self)
                 else:
                     setup_func(func)(self)
+
         return inner
+
     return decorator
 
 
 class I18nBlockTransTagTests(SimpleTestCase):
-    libraries = {'i18n': 'django.templatetags.i18n'}
+    libraries = {"i18n": "django.templatetags.i18n"}
 
-    @setup({'i18n03': '{% load i18n %}{% blocktranslate %}{{ anton }}{% endblocktranslate %}'})
+    @setup(
+        {
+            "i18n03": "{% load i18n %}{% blocktranslate %}{{ anton }}{% endblocktranslate %}"
+        }
+    )
     def test_i18n03(self):
         """simple translation of a variable"""
-        output = self.engine.render_to_string('i18n03', {'anton': 'Å'})
-        self.assertEqual(output, 'Å')
+        output = self.engine.render_to_string("i18n03", {"anton": "Å"})
+        self.assertEqual(output, "Å")
 
-    @setup({'i18n04': '{% load i18n %}{% blocktranslate with berta=anton|lower %}{{ berta }}{% endblocktranslate %}'})
+    @setup(
+        {
+            "i18n04": "{% load i18n %}{% blocktranslate with berta=anton|lower %}{{ berta }}{% endblocktranslate %}"
+        }
+    )
     def test_i18n04(self):
         """simple translation of a variable and filter"""
-        output = self.engine.render_to_string('i18n04', {'anton': 'Å'})
-        self.assertEqual(output, 'å')
+        output = self.engine.render_to_string("i18n04", {"anton": "Å"})
+        self.assertEqual(output, "å")
 
-    @setup({'legacyi18n04': '{% load i18n %}'
-                            '{% blocktranslate with anton|lower as berta %}{{ berta }}{% endblocktranslate %}'})
+    @setup(
+        {
+            "legacyi18n04": "{% load i18n %}"
+            "{% blocktranslate with anton|lower as berta %}{{ berta }}{% endblocktranslate %}"
+        }
+    )
     def test_legacyi18n04(self):
         """simple translation of a variable and filter"""
-        output = self.engine.render_to_string('legacyi18n04', {'anton': 'Å'})
-        self.assertEqual(output, 'å')
+        output = self.engine.render_to_string("legacyi18n04", {"anton": "Å"})
+        self.assertEqual(output, "å")
 
-    @setup({'i18n05': '{% load i18n %}{% blocktranslate %}xxx{{ anton }}xxx{% endblocktranslate %}'})
+    @setup(
+        {
+            "i18n05": "{% load i18n %}{% blocktranslate %}xxx{{ anton }}xxx{% endblocktranslate %}"
+        }
+    )
     def test_i18n05(self):
         """simple translation of a string with interpolation"""
-        output = self.engine.render_to_string('i18n05', {'anton': 'yyy'})
-        self.assertEqual(output, 'xxxyyyxxx')
+        output = self.engine.render_to_string("i18n05", {"anton": "yyy"})
+        self.assertEqual(output, "xxxyyyxxx")
 
-    @setup({'i18n07': '{% load i18n %}'
-                      '{% blocktranslate count counter=number %}singular{% plural %}'
-                      '{{ counter }} plural{% endblocktranslate %}'})
+    @setup(
+        {
+            "i18n07": "{% load i18n %}"
+            "{% blocktranslate count counter=number %}singular{% plural %}"
+            "{{ counter }} plural{% endblocktranslate %}"
+        }
+    )
     def test_i18n07(self):
         """translation of singular form"""
-        output = self.engine.render_to_string('i18n07', {'number': 1})
-        self.assertEqual(output, 'singular')
+        output = self.engine.render_to_string("i18n07", {"number": 1})
+        self.assertEqual(output, "singular")
 
-    @setup({'legacyi18n07': '{% load i18n %}'
-                            '{% blocktranslate count number as counter %}singular{% plural %}'
-                            '{{ counter }} plural{% endblocktranslate %}'})
+    @setup(
+        {
+            "legacyi18n07": "{% load i18n %}"
+            "{% blocktranslate count number as counter %}singular{% plural %}"
+            "{{ counter }} plural{% endblocktranslate %}"
+        }
+    )
     def test_legacyi18n07(self):
         """translation of singular form"""
-        output = self.engine.render_to_string('legacyi18n07', {'number': 1})
-        self.assertEqual(output, 'singular')
+        output = self.engine.render_to_string("legacyi18n07", {"number": 1})
+        self.assertEqual(output, "singular")
 
-    @setup({'i18n08': '{% load i18n %}'
-                      '{% blocktranslate count number as counter %}singular{% plural %}'
-                      '{{ counter }} plural{% endblocktranslate %}'})
+    @setup(
+        {
+            "i18n08": "{% load i18n %}"
+            "{% blocktranslate count number as counter %}singular{% plural %}"
+            "{{ counter }} plural{% endblocktranslate %}"
+        }
+    )
     def test_i18n08(self):
         """translation of plural form"""
-        output = self.engine.render_to_string('i18n08', {'number': 2})
-        self.assertEqual(output, '2 plural')
+        output = self.engine.render_to_string("i18n08", {"number": 2})
+        self.assertEqual(output, "2 plural")
 
-    @setup({'legacyi18n08': '{% load i18n %}'
-                            '{% blocktranslate count counter=number %}singular{% plural %}'
-                            '{{ counter }} plural{% endblocktranslate %}'})
+    @setup(
+        {
+            "legacyi18n08": "{% load i18n %}"
+            "{% blocktranslate count counter=number %}singular{% plural %}"
+            "{{ counter }} plural{% endblocktranslate %}"
+        }
+    )
     def test_legacyi18n08(self):
         """translation of plural form"""
-        output = self.engine.render_to_string('legacyi18n08', {'number': 2})
-        self.assertEqual(output, '2 plural')
+        output = self.engine.render_to_string("legacyi18n08", {"number": 2})
+        self.assertEqual(output, "2 plural")
 
-    @setup({'i18n17': '{% load i18n %}'
-                      '{% blocktranslate with berta=anton|escape %}{{ berta }}{% endblocktranslate %}'})
+    @setup(
+        {
+            "i18n17": "{% load i18n %}"
+            "{% blocktranslate with berta=anton|escape %}{{ berta }}{% endblocktranslate %}"
+        }
+    )
     def test_i18n17(self):
         """
         Escaping inside blocktranslate and translate works as if it was
         directly in the template.
         """
-        output = self.engine.render_to_string('i18n17', {'anton': 'α & β'})
-        self.assertEqual(output, 'α & β')
+        output = self.engine.render_to_string("i18n17", {"anton": "α & β"})
+        self.assertEqual(output, "α & β")
 
-    @setup({'i18n18': '{% load i18n %}'
-                      '{% blocktranslate with berta=anton|force_escape %}{{ berta }}{% endblocktranslate %}'})
+    @setup(
+        {
+            "i18n18": "{% load i18n %}"
+            "{% blocktranslate with berta=anton|force_escape %}{{ berta }}{% endblocktranslate %}"
+        }
+    )
     def test_i18n18(self):
-        output = self.engine.render_to_string('i18n18', {'anton': 'α & β'})
-        self.assertEqual(output, 'α & β')
+        output = self.engine.render_to_string("i18n18", {"anton": "α & β"})
+        self.assertEqual(output, "α & β")
 
-    @setup({'i18n19': '{% load i18n %}{% blocktranslate %}{{ andrew }}{% endblocktranslate %}'})
+    @setup(
+        {
+            "i18n19": "{% load i18n %}{% blocktranslate %}{{ andrew }}{% endblocktranslate %}"
+        }
+    )
     def test_i18n19(self):
-        output = self.engine.render_to_string('i18n19', {'andrew': 'a & b'})
-        self.assertEqual(output, 'a & b')
+        output = self.engine.render_to_string("i18n19", {"andrew": "a & b"})
+        self.assertEqual(output, "a & b")
 
-    @setup({'i18n21': '{% load i18n %}{% blocktranslate %}{{ andrew }}{% endblocktranslate %}'})
+    @setup(
+        {
+            "i18n21": "{% load i18n %}{% blocktranslate %}{{ andrew }}{% endblocktranslate %}"
+        }
+    )
     def test_i18n21(self):
-        output = self.engine.render_to_string('i18n21', {'andrew': mark_safe('a & b')})
-        self.assertEqual(output, 'a & b')
+        output = self.engine.render_to_string("i18n21", {"andrew": mark_safe("a & b")})
+        self.assertEqual(output, "a & b")
 
-    @setup({'legacyi18n17': '{% load i18n %}'
-                            '{% blocktranslate with anton|escape as berta %}{{ berta }}{% endblocktranslate %}'})
+    @setup(
+        {
+            "legacyi18n17": "{% load i18n %}"
+            "{% blocktranslate with anton|escape as berta %}{{ berta }}{% endblocktranslate %}"
+        }
+    )
     def test_legacyi18n17(self):
-        output = self.engine.render_to_string('legacyi18n17', {'anton': 'α & β'})
-        self.assertEqual(output, 'α & β')
+        output = self.engine.render_to_string("legacyi18n17", {"anton": "α & β"})
+        self.assertEqual(output, "α & β")
 
-    @setup({'legacyi18n18': '{% load i18n %}'
-                            '{% blocktranslate with anton|force_escape as berta %}'
-                            '{{ berta }}{% endblocktranslate %}'})
+    @setup(
+        {
+            "legacyi18n18": "{% load i18n %}"
+            "{% blocktranslate with anton|force_escape as berta %}"
+            "{{ berta }}{% endblocktranslate %}"
+        }
+    )
     def test_legacyi18n18(self):
-        output = self.engine.render_to_string('legacyi18n18', {'anton': 'α & β'})
-        self.assertEqual(output, 'α & β')
+        output = self.engine.render_to_string("legacyi18n18", {"anton": "α & β"})
+        self.assertEqual(output, "α & β")
 
-    @setup({'i18n26': '{% load i18n %}'
-                      '{% blocktranslate with extra_field=myextra_field count counter=number %}'
-                      'singular {{ extra_field }}{% plural %}plural{% endblocktranslate %}'})
+    @setup(
+        {
+            "i18n26": "{% load i18n %}"
+            "{% blocktranslate with extra_field=myextra_field count counter=number %}"
+            "singular {{ extra_field }}{% plural %}plural{% endblocktranslate %}"
+        }
+    )
     def test_i18n26(self):
         """
         translation of plural form with extra field in singular form (#13568)
         """
-        output = self.engine.render_to_string('i18n26', {'myextra_field': 'test', 'number': 1})
-        self.assertEqual(output, 'singular test')
+        output = self.engine.render_to_string(
+            "i18n26", {"myextra_field": "test", "number": 1}
+        )
+        self.assertEqual(output, "singular test")
 
-    @setup({'legacyi18n26': '{% load i18n %}'
-                            '{% blocktranslate with myextra_field as extra_field count number as counter %}'
-                            'singular {{ extra_field }}{% plural %}plural{% endblocktranslate %}'})
+    @setup(
+        {
+            "legacyi18n26": "{% load i18n %}"
+            "{% blocktranslate with myextra_field as extra_field count number as counter %}"
+            "singular {{ extra_field }}{% plural %}plural{% endblocktranslate %}"
+        }
+    )
     def test_legacyi18n26(self):
-        output = self.engine.render_to_string('legacyi18n26', {'myextra_field': 'test', 'number': 1})
-        self.assertEqual(output, 'singular test')
+        output = self.engine.render_to_string(
+            "legacyi18n26", {"myextra_field": "test", "number": 1}
+        )
+        self.assertEqual(output, "singular test")
 
-    @setup({'i18n27': '{% load i18n %}{% blocktranslate count counter=number %}'
-                      '{{ counter }} result{% plural %}{{ counter }} results'
-                      '{% endblocktranslate %}'})
+    @setup(
+        {
+            "i18n27": "{% load i18n %}{% blocktranslate count counter=number %}"
+            "{{ counter }} result{% plural %}{{ counter }} results"
+            "{% endblocktranslate %}"
+        }
+    )
     def test_i18n27(self):
         """translation of singular form in Russian (#14126)"""
-        with translation.override('ru'):
-            output = self.engine.render_to_string('i18n27', {'number': 1})
-        self.assertEqual(output, '1 \u0440\u0435\u0437\u0443\u043b\u044c\u0442\u0430\u0442')
+        with translation.override("ru"):
+            output = self.engine.render_to_string("i18n27", {"number": 1})
+        self.assertEqual(
+            output, "1 \u0440\u0435\u0437\u0443\u043b\u044c\u0442\u0430\u0442"
+        )
 
-    @setup({'legacyi18n27': '{% load i18n %}'
-                            '{% blocktranslate count number as counter %}{{ counter }} result'
-                            '{% plural %}{{ counter }} results{% endblocktranslate %}'})
+    @setup(
+        {
+            "legacyi18n27": "{% load i18n %}"
+            "{% blocktranslate count number as counter %}{{ counter }} result"
+            "{% plural %}{{ counter }} results{% endblocktranslate %}"
+        }
+    )
     def test_legacyi18n27(self):
-        with translation.override('ru'):
-            output = self.engine.render_to_string('legacyi18n27', {'number': 1})
-        self.assertEqual(output, '1 \u0440\u0435\u0437\u0443\u043b\u044c\u0442\u0430\u0442')
+        with translation.override("ru"):
+            output = self.engine.render_to_string("legacyi18n27", {"number": 1})
+        self.assertEqual(
+            output, "1 \u0440\u0435\u0437\u0443\u043b\u044c\u0442\u0430\u0442"
+        )
 
-    @setup({'i18n28': '{% load i18n %}'
-                      '{% blocktranslate with a=anton b=berta %}{{ a }} + {{ b }}{% endblocktranslate %}'})
+    @setup(
+        {
+            "i18n28": "{% load i18n %}"
+            "{% blocktranslate with a=anton b=berta %}{{ a }} + {{ b }}{% endblocktranslate %}"
+        }
+    )
     def test_i18n28(self):
         """simple translation of multiple variables"""
-        output = self.engine.render_to_string('i18n28', {'anton': 'α', 'berta': 'β'})
-        self.assertEqual(output, 'α + β')
+        output = self.engine.render_to_string("i18n28", {"anton": "α", "berta": "β"})
+        self.assertEqual(output, "α + β")
 
-    @setup({'legacyi18n28': '{% load i18n %}'
-                            '{% blocktranslate with anton as a and berta as b %}'
-                            '{{ a }} + {{ b }}{% endblocktranslate %}'})
+    @setup(
+        {
+            "legacyi18n28": "{% load i18n %}"
+            "{% blocktranslate with anton as a and berta as b %}"
+            "{{ a }} + {{ b }}{% endblocktranslate %}"
+        }
+    )
     def test_legacyi18n28(self):
-        output = self.engine.render_to_string('legacyi18n28', {'anton': 'α', 'berta': 'β'})
-        self.assertEqual(output, 'α + β')
+        output = self.engine.render_to_string(
+            "legacyi18n28", {"anton": "α", "berta": "β"}
+        )
+        self.assertEqual(output, "α + β")
 
     # blocktranslate handling of variables which are not in the context.
     # this should work as if blocktranslate was not there (#19915)
-    @setup({'i18n34': '{% load i18n %}{% blocktranslate %}{{ missing }}{% endblocktranslate %}'})
+    @setup(
+        {
+            "i18n34": "{% load i18n %}{% blocktranslate %}{{ missing }}{% endblocktranslate %}"
+        }
+    )
     def test_i18n34(self):
-        output = self.engine.render_to_string('i18n34')
+        output = self.engine.render_to_string("i18n34")
         if self.engine.string_if_invalid:
-            self.assertEqual(output, 'INVALID')
+            self.assertEqual(output, "INVALID")
         else:
-            self.assertEqual(output, '')
+            self.assertEqual(output, "")
 
-    @setup({'i18n34_2': '{% load i18n %}{% blocktranslate with a=\'α\' %}{{ missing }}{% endblocktranslate %}'})
+    @setup(
+        {
+            "i18n34_2": "{% load i18n %}{% blocktranslate with a='α' %}{{ missing }}{% endblocktranslate %}"
+        }
+    )
     def test_i18n34_2(self):
-        output = self.engine.render_to_string('i18n34_2')
+        output = self.engine.render_to_string("i18n34_2")
         if self.engine.string_if_invalid:
-            self.assertEqual(output, 'INVALID')
+            self.assertEqual(output, "INVALID")
         else:
-            self.assertEqual(output, '')
+            self.assertEqual(output, "")
 
-    @setup({'i18n34_3': '{% load i18n %}{% blocktranslate with a=anton %}{{ missing }}{% endblocktranslate %}'})
+    @setup(
+        {
+            "i18n34_3": "{% load i18n %}{% blocktranslate with a=anton %}{{ missing }}{% endblocktranslate %}"
+        }
+    )
     def test_i18n34_3(self):
-        output = self.engine.render_to_string(
-            'i18n34_3', {'anton': '\xce\xb1'})
+        output = self.engine.render_to_string("i18n34_3", {"anton": "\xce\xb1"})
         if self.engine.string_if_invalid:
-            self.assertEqual(output, 'INVALID')
+            self.assertEqual(output, "INVALID")
         else:
-            self.assertEqual(output, '')
+            self.assertEqual(output, "")
 
-    @setup({'i18n37': '{% load i18n %}'
-                      '{% translate "Page not found" as page_not_found %}'
-                      '{% blocktranslate %}Error: {{ page_not_found }}{% endblocktranslate %}'})
+    @setup(
+        {
+            "i18n37": "{% load i18n %}"
+            '{% translate "Page not found" as page_not_found %}'
+            "{% blocktranslate %}Error: {{ page_not_found }}{% endblocktranslate %}"
+        }
+    )
     def test_i18n37(self):
-        with translation.override('de'):
-            output = self.engine.render_to_string('i18n37')
-        self.assertEqual(output, 'Error: Seite nicht gefunden')
+        with translation.override("de"):
+            output = self.engine.render_to_string("i18n37")
+        self.assertEqual(output, "Error: Seite nicht gefunden")
 
     # blocktranslate tag with asvar
-    @setup({'i18n39': '{% load i18n %}'
-                      '{% blocktranslate asvar page_not_found %}Page not found{% endblocktranslate %}'
-                      '>{{ page_not_found }}<'})
+    @setup(
+        {
+            "i18n39": "{% load i18n %}"
+            "{% blocktranslate asvar page_not_found %}Page not found{% endblocktranslate %}"
+            ">{{ page_not_found }}<"
+        }
+    )
     def test_i18n39(self):
-        with translation.override('de'):
-            output = self.engine.render_to_string('i18n39')
-        self.assertEqual(output, '>Seite nicht gefunden<')
+        with translation.override("de"):
+            output = self.engine.render_to_string("i18n39")
+        self.assertEqual(output, ">Seite nicht gefunden<")
 
-    @setup({'i18n40': '{% load i18n %}'
-                      '{% translate "Page not found" as pg_404 %}'
-                      '{% blocktranslate with page_not_found=pg_404 asvar output %}'
-                      'Error: {{ page_not_found }}'
-                      '{% endblocktranslate %}'})
+    @setup(
+        {
+            "i18n40": "{% load i18n %}"
+            '{% translate "Page not found" as pg_404 %}'
+            "{% blocktranslate with page_not_found=pg_404 asvar output %}"
+            "Error: {{ page_not_found }}"
+            "{% endblocktranslate %}"
+        }
+    )
     def test_i18n40(self):
-        output = self.engine.render_to_string('i18n40')
-        self.assertEqual(output, '')
+        output = self.engine.render_to_string("i18n40")
+        self.assertEqual(output, "")
 
-    @setup({'i18n41': '{% load i18n %}'
-                      '{% translate "Page not found" as pg_404 %}'
-                      '{% blocktranslate with page_not_found=pg_404 asvar output %}'
-                      'Error: {{ page_not_found }}'
-                      '{% endblocktranslate %}'
-                      '>{{ output }}<'})
+    @setup(
+        {
+            "i18n41": "{% load i18n %}"
+            '{% translate "Page not found" as pg_404 %}'
+            "{% blocktranslate with page_not_found=pg_404 asvar output %}"
+            "Error: {{ page_not_found }}"
+            "{% endblocktranslate %}"
+            ">{{ output }}<"
+        }
+    )
     def test_i18n41(self):
-        with translation.override('de'):
-            output = self.engine.render_to_string('i18n41')
-        self.assertEqual(output, '>Error: Seite nicht gefunden<')
+        with translation.override("de"):
+            output = self.engine.render_to_string("i18n41")
+        self.assertEqual(output, ">Error: Seite nicht gefunden<")
 
-    @setup({'template': '{% load i18n %}{% blocktranslate asvar %}Yes{% endblocktranslate %}'})
+    @setup(
+        {
+            "template": "{% load i18n %}{% blocktranslate asvar %}Yes{% endblocktranslate %}"
+        }
+    )
     def test_blocktrans_syntax_error_missing_assignment(self, tag_name):
-        msg = "No argument provided to the '{}' tag for the asvar option.".format(tag_name)
+        msg = "No argument provided to the '{}' tag for the asvar option.".format(
+            tag_name
+        )
         with self.assertRaisesMessage(TemplateSyntaxError, msg):
-            self.engine.render_to_string('template')
+            self.engine.render_to_string("template")
 
-    @setup({'template': '{% load i18n %}{% blocktranslate %}%s{% endblocktranslate %}'})
+    @setup({"template": "{% load i18n %}{% blocktranslate %}%s{% endblocktranslate %}"})
     def test_blocktrans_tag_using_a_string_that_looks_like_str_fmt(self):
-        output = self.engine.render_to_string('template')
-        self.assertEqual(output, '%s')
+        output = self.engine.render_to_string("template")
+        self.assertEqual(output, "%s")
 
-    @setup({'template': '{% load i18n %}{% blocktranslate %}{% block b %} {% endblock %}{% endblocktranslate %}'})
+    @setup(
+        {
+            "template": "{% load i18n %}{% blocktranslate %}{% block b %} {% endblock %}{% endblocktranslate %}"
+        }
+    )
     def test_with_block(self, tag_name):
-        msg = "'{}' doesn't allow other block tags (seen 'block b') inside it".format(tag_name)
+        msg = "'{}' doesn't allow other block tags (seen 'block b') inside it".format(
+            tag_name
+        )
         with self.assertRaisesMessage(TemplateSyntaxError, msg):
-            self.engine.render_to_string('template')
+            self.engine.render_to_string("template")
 
-    @setup({'template': (
-        '{% load i18n %}'
-        '{% blocktranslate %}{% for b in [1, 2, 3] %} {% endfor %}'
-        '{% endblocktranslate %}'
-    )})
+    @setup(
+        {
+            "template": (
+                "{% load i18n %}"
+                "{% blocktranslate %}{% for b in [1, 2, 3] %} {% endfor %}"
+                "{% endblocktranslate %}"
+            )
+        }
+    )
     def test_with_for(self, tag_name):
-        msg = "'{}' doesn't allow other block tags (seen 'for b in [1, 2, 3]') inside it".format(tag_name)
+        msg = "'{}' doesn't allow other block tags (seen 'for b in [1, 2, 3]') inside it".format(
+            tag_name
+        )
         with self.assertRaisesMessage(TemplateSyntaxError, msg):
-            self.engine.render_to_string('template')
+            self.engine.render_to_string("template")
 
-    @setup({'template': '{% load i18n %}{% blocktranslate with foo=bar with %}{{ foo }}{% endblocktranslate %}'})
+    @setup(
+        {
+            "template": "{% load i18n %}{% blocktranslate with foo=bar with %}{{ foo }}{% endblocktranslate %}"
+        }
+    )
     def test_variable_twice(self):
-        with self.assertRaisesMessage(TemplateSyntaxError, "The 'with' option was specified more than once"):
-            self.engine.render_to_string('template', {'foo': 'bar'})
+        with self.assertRaisesMessage(
+            TemplateSyntaxError, "The 'with' option was specified more than once"
+        ):
+            self.engine.render_to_string("template", {"foo": "bar"})
 
-    @setup({'template': '{% load i18n %}{% blocktranslate with %}{% endblocktranslate %}'})
+    @setup(
+        {"template": "{% load i18n %}{% blocktranslate with %}{% endblocktranslate %}"}
+    )
     def test_no_args_with(self, tag_name):
-        msg = '"with" in \'{}\' tag needs at least one keyword argument.'.format(tag_name)
+        msg = "\"with\" in '{}' tag needs at least one keyword argument.".format(
+            tag_name
+        )
         with self.assertRaisesMessage(TemplateSyntaxError, msg):
-            self.engine.render_to_string('template')
+            self.engine.render_to_string("template")
 
-    @setup({'template': '{% load i18n %}{% blocktranslate count a %}{% endblocktranslate %}'})
+    @setup(
+        {
+            "template": "{% load i18n %}{% blocktranslate count a %}{% endblocktranslate %}"
+        }
+    )
     def test_count(self, tag_name):
-        msg = '"count" in \'{}\' tag expected exactly one keyword argument.'.format(tag_name)
+        msg = "\"count\" in '{}' tag expected exactly one keyword argument.".format(
+            tag_name
+        )
         with self.assertRaisesMessage(TemplateSyntaxError, msg):
-            self.engine.render_to_string('template', {'a': [1, 2, 3]})
+            self.engine.render_to_string("template", {"a": [1, 2, 3]})
 
-    @setup({'template': (
-        '{% load i18n %}{% blocktranslate count counter=num %}{{ counter }}'
-        '{% plural %}{{ counter }}{% endblocktranslate %}'
-    )})
+    @setup(
+        {
+            "template": (
+                "{% load i18n %}{% blocktranslate count counter=num %}{{ counter }}"
+                "{% plural %}{{ counter }}{% endblocktranslate %}"
+            )
+        }
+    )
     def test_count_not_number(self, tag_name):
         msg = "'counter' argument to '{}' tag must be a number.".format(tag_name)
         with self.assertRaisesMessage(TemplateSyntaxError, msg):
-            self.engine.render_to_string('template', {'num': '1'})
+            self.engine.render_to_string("template", {"num": "1"})
 
-    @setup({'template': (
-        '{% load i18n %}{% blocktranslate count count=var|length %}'
-        'There is {{ count }} object. {% block a %} {% endblock %}'
-        '{% endblocktranslate %}'
-    )})
+    @setup(
+        {
+            "template": (
+                "{% load i18n %}{% blocktranslate count count=var|length %}"
+                "There is {{ count }} object. {% block a %} {% endblock %}"
+                "{% endblocktranslate %}"
+            )
+        }
+    )
     def test_plural_bad_syntax(self, tag_name):
         msg = "'{}' doesn't allow other block tags inside it".format(tag_name)
         with self.assertRaisesMessage(TemplateSyntaxError, msg):
-            self.engine.render_to_string('template', {'var': [1, 2, 3]})
+            self.engine.render_to_string("template", {"var": [1, 2, 3]})
 
 
 class TranslationBlockTranslateTagTests(SimpleTestCase):
-    tag_name = 'blocktranslate'
+    tag_name = "blocktranslate"
 
     def get_template(self, template_string):
         return Template(
             template_string.replace(
-                '{{% blocktranslate ',
-                '{{% {}'.format(self.tag_name)
+                "{{% blocktranslate ", "{{% {}".format(self.tag_name)
             ).replace(
-                '{{% endblocktranslate %}}',
-                '{{% end{} %}}'.format(self.tag_name)
+                "{{% endblocktranslate %}}", "{{% end{} %}}".format(self.tag_name)
             )
         )
 
@@ -339,108 +498,112 @@ class TranslationBlockTranslateTagTests(SimpleTestCase):
         """{% blocktranslate %} takes message contexts into account (#14806)."""
         trans_real._active = Local()
         trans_real._translations = {}
-        with translation.override('de'):
+        with translation.override("de"):
             # Nonexistent context
             t = self.get_template(
                 '{% load i18n %}{% blocktranslate context "nonexistent" %}May'
-                '{% endblocktranslate %}'
+                "{% endblocktranslate %}"
             )
             rendered = t.render(Context())
-            self.assertEqual(rendered, 'May')
+            self.assertEqual(rendered, "May")
 
             # Existing context...  using a literal
-            t = self.get_template('{% load i18n %}{% blocktranslate context "month name" %}May{% endblocktranslate %}')
+            t = self.get_template(
+                '{% load i18n %}{% blocktranslate context "month name" %}May{% endblocktranslate %}'
+            )
             rendered = t.render(Context())
-            self.assertEqual(rendered, 'Mai')
-            t = self.get_template('{% load i18n %}{% blocktranslate context "verb" %}May{% endblocktranslate %}')
+            self.assertEqual(rendered, "Mai")
+            t = self.get_template(
+                '{% load i18n %}{% blocktranslate context "verb" %}May{% endblocktranslate %}'
+            )
             rendered = t.render(Context())
-            self.assertEqual(rendered, 'Kann')
+            self.assertEqual(rendered, "Kann")
 
             # Using a variable
             t = self.get_template(
-                '{% load i18n %}{% blocktranslate context message_context %}'
-                'May{% endblocktranslate %}'
+                "{% load i18n %}{% blocktranslate context message_context %}"
+                "May{% endblocktranslate %}"
             )
-            rendered = t.render(Context({'message_context': 'month name'}))
-            self.assertEqual(rendered, 'Mai')
+            rendered = t.render(Context({"message_context": "month name"}))
+            self.assertEqual(rendered, "Mai")
             t = self.get_template(
-                '{% load i18n %}{% blocktranslate context message_context %}'
-                'May{% endblocktranslate %}'
+                "{% load i18n %}{% blocktranslate context message_context %}"
+                "May{% endblocktranslate %}"
             )
-            rendered = t.render(Context({'message_context': 'verb'}))
-            self.assertEqual(rendered, 'Kann')
+            rendered = t.render(Context({"message_context": "verb"}))
+            self.assertEqual(rendered, "Kann")
 
             # Using a filter
             t = self.get_template(
-                '{% load i18n %}{% blocktranslate context message_context|lower %}May{% endblocktranslate %}'
+                "{% load i18n %}{% blocktranslate context message_context|lower %}May{% endblocktranslate %}"
             )
-            rendered = t.render(Context({'message_context': 'MONTH NAME'}))
-            self.assertEqual(rendered, 'Mai')
+            rendered = t.render(Context({"message_context": "MONTH NAME"}))
+            self.assertEqual(rendered, "Mai")
             t = self.get_template(
-                '{% load i18n %}{% blocktranslate context message_context|lower %}May{% endblocktranslate %}'
+                "{% load i18n %}{% blocktranslate context message_context|lower %}May{% endblocktranslate %}"
             )
-            rendered = t.render(Context({'message_context': 'VERB'}))
-            self.assertEqual(rendered, 'Kann')
+            rendered = t.render(Context({"message_context": "VERB"}))
+            self.assertEqual(rendered, "Kann")
 
             # Using 'count'
             t = self.get_template(
                 '{% load i18n %}{% blocktranslate count number=1 context "super search" %}'
-                '{{ number }} super result{% plural %}{{ number }} super results{% endblocktranslate %}'
+                "{{ number }} super result{% plural %}{{ number }} super results{% endblocktranslate %}"
             )
             rendered = t.render(Context())
-            self.assertEqual(rendered, '1 Super-Ergebnis')
+            self.assertEqual(rendered, "1 Super-Ergebnis")
             t = self.get_template(
                 '{% load i18n %}{% blocktranslate count number=2 context "super search" %}{{ number }}'
-                ' super result{% plural %}{{ number }} super results{% endblocktranslate %}'
+                " super result{% plural %}{{ number }} super results{% endblocktranslate %}"
             )
             rendered = t.render(Context())
-            self.assertEqual(rendered, '2 Super-Ergebnisse')
+            self.assertEqual(rendered, "2 Super-Ergebnisse")
             t = self.get_template(
                 '{% load i18n %}{% blocktranslate context "other super search" count number=1 %}'
-                '{{ number }} super result{% plural %}{{ number }} super results{% endblocktranslate %}'
+                "{{ number }} super result{% plural %}{{ number }} super results{% endblocktranslate %}"
             )
             rendered = t.render(Context())
-            self.assertEqual(rendered, '1 anderen Super-Ergebnis')
+            self.assertEqual(rendered, "1 anderen Super-Ergebnis")
             t = self.get_template(
                 '{% load i18n %}{% blocktranslate context "other super search" count number=2 %}'
-                '{{ number }} super result{% plural %}{{ number }} super results{% endblocktranslate %}'
+                "{{ number }} super result{% plural %}{{ number }} super results{% endblocktranslate %}"
             )
             rendered = t.render(Context())
-            self.assertEqual(rendered, '2 andere Super-Ergebnisse')
+            self.assertEqual(rendered, "2 andere Super-Ergebnisse")
 
             # Using 'with'
             t = self.get_template(
                 '{% load i18n %}{% blocktranslate with num_comments=5 context "comment count" %}'
-                'There are {{ num_comments }} comments{% endblocktranslate %}'
+                "There are {{ num_comments }} comments{% endblocktranslate %}"
             )
             rendered = t.render(Context())
-            self.assertEqual(rendered, 'Es gibt 5 Kommentare')
+            self.assertEqual(rendered, "Es gibt 5 Kommentare")
             t = self.get_template(
                 '{% load i18n %}{% blocktranslate with num_comments=5 context "other comment count" %}'
-                'There are {{ num_comments }} comments{% endblocktranslate %}'
+                "There are {{ num_comments }} comments{% endblocktranslate %}"
             )
             rendered = t.render(Context())
-            self.assertEqual(rendered, 'Andere: Es gibt 5 Kommentare')
+            self.assertEqual(rendered, "Andere: Es gibt 5 Kommentare")
 
             # Using trimmed
             t = self.get_template(
-                '{% load i18n %}{% blocktranslate trimmed %}\n\nThere\n\t are 5  '
-                '\n\n   comments\n{% endblocktranslate %}'
+                "{% load i18n %}{% blocktranslate trimmed %}\n\nThere\n\t are 5  "
+                "\n\n   comments\n{% endblocktranslate %}"
             )
             rendered = t.render(Context())
-            self.assertEqual(rendered, 'There are 5 comments')
+            self.assertEqual(rendered, "There are 5 comments")
             t = self.get_template(
                 '{% load i18n %}{% blocktranslate with num_comments=5 context "comment count" trimmed %}\n\n'
-                'There are  \t\n  \t {{ num_comments }} comments\n\n{% endblocktranslate %}'
+                "There are  \t\n  \t {{ num_comments }} comments\n\n{% endblocktranslate %}"
             )
             rendered = t.render(Context())
-            self.assertEqual(rendered, 'Es gibt 5 Kommentare')
+            self.assertEqual(rendered, "Es gibt 5 Kommentare")
             t = self.get_template(
                 '{% load i18n %}{% blocktranslate context "other super search" count number=2 trimmed %}\n'
-                '{{ number }} super \n result{% plural %}{{ number }} super results{% endblocktranslate %}'
+                "{{ number }} super \n result{% plural %}{{ number }} super results{% endblocktranslate %}"
             )
             rendered = t.render(Context())
-            self.assertEqual(rendered, '2 andere Super-Ergebnisse')
+            self.assertEqual(rendered, "2 andere Super-Ergebnisse")
 
             # Misuses
             msg = "Unknown argument for 'blocktranslate' tag: %r."
@@ -448,55 +611,61 @@ class TranslationBlockTranslateTagTests(SimpleTestCase):
                 self.get_template(
                     '{% load i18n %}{% blocktranslate context with month="May" %}{{ month }}{% endblocktranslate %}'
                 )
-            msg = '"context" in %r tag expected exactly one argument.' % 'blocktranslate'
+            msg = (
+                '"context" in %r tag expected exactly one argument.' % "blocktranslate"
+            )
             with self.assertRaisesMessage(TemplateSyntaxError, msg):
-                self.get_template('{% load i18n %}{% blocktranslate context %}{% endblocktranslate %}')
+                self.get_template(
+                    "{% load i18n %}{% blocktranslate context %}{% endblocktranslate %}"
+                )
             with self.assertRaisesMessage(TemplateSyntaxError, msg):
                 self.get_template(
-                    '{% load i18n %}{% blocktranslate count number=2 context %}'
-                    '{{ number }} super result{% plural %}{{ number }}'
-                    ' super results{% endblocktranslate %}'
+                    "{% load i18n %}{% blocktranslate count number=2 context %}"
+                    "{{ number }} super result{% plural %}{{ number }}"
+                    " super results{% endblocktranslate %}"
                 )
 
-    @override_settings(LOCALE_PATHS=[os.path.join(here, 'other', 'locale')])
+    @override_settings(LOCALE_PATHS=[os.path.join(here, "other", "locale")])
     def test_bad_placeholder_1(self):
         """
         Error in translation file should not crash template rendering (#16516).
         (%(person)s is translated as %(personne)s in fr.po).
         """
-        with translation.override('fr'):
-            t = Template('{% load i18n %}{% blocktranslate %}My name is {{ person }}.{% endblocktranslate %}')
-            rendered = t.render(Context({'person': 'James'}))
-            self.assertEqual(rendered, 'My name is James.')
+        with translation.override("fr"):
+            t = Template(
+                "{% load i18n %}{% blocktranslate %}My name is {{ person }}.{% endblocktranslate %}"
+            )
+            rendered = t.render(Context({"person": "James"}))
+            self.assertEqual(rendered, "My name is James.")
 
-    @override_settings(LOCALE_PATHS=[os.path.join(here, 'other', 'locale')])
+    @override_settings(LOCALE_PATHS=[os.path.join(here, "other", "locale")])
     def test_bad_placeholder_2(self):
         """
         Error in translation file should not crash template rendering (#18393).
         (%(person) misses a 's' in fr.po, causing the string formatting to fail)
         .
         """
-        with translation.override('fr'):
-            t = Template('{% load i18n %}{% blocktranslate %}My other name is {{ person }}.{% endblocktranslate %}')
-            rendered = t.render(Context({'person': 'James'}))
-            self.assertEqual(rendered, 'My other name is James.')
+        with translation.override("fr"):
+            t = Template(
+                "{% load i18n %}{% blocktranslate %}My other name is {{ person }}.{% endblocktranslate %}"
+            )
+            rendered = t.render(Context({"person": "James"}))
+            self.assertEqual(rendered, "My other name is James.")
 
 
 class TranslationBlockTransnTagTests(TranslationBlockTranslateTagTests):
-    tag_name = 'blocktrans'
+    tag_name = "blocktrans"
 
 
 class MultipleLocaleActivationBlockTranslateTests(MultipleLocaleActivationTestCase):
-    tag_name = 'blocktranslate'
+    tag_name = "blocktranslate"
 
     def get_template(self, template_string):
         return Template(
             template_string.replace(
-                '{{% blocktranslate ',
-                '{{% {}'.format(self.tag_name)
+                "{{% blocktranslate ", "{{% {}".format(self.tag_name)
             ).replace(
-                '{{% endblocktranslate %}}',
-                '{{% end{} %}}'.format(self.tag_name)
+                "{{% endblocktranslate %}}", "{{% end{} %}}".format(self.tag_name)
             )
         )
 
@@ -505,46 +674,54 @@ class MultipleLocaleActivationBlockTranslateTests(MultipleLocaleActivationTestCa
         Simple baseline behavior with one locale for all the supported i18n
         constructs.
         """
-        with translation.override('fr'):
+        with translation.override("fr"):
             self.assertEqual(
-                self.get_template("{% load i18n %}{% blocktranslate %}Yes{% endblocktranslate %}").render(Context({})),
-                'Oui'
+                self.get_template(
+                    "{% load i18n %}{% blocktranslate %}Yes{% endblocktranslate %}"
+                ).render(Context({})),
+                "Oui",
             )
 
     def test_multiple_locale_btrans(self):
-        with translation.override('de'):
-            t = self.get_template("{% load i18n %}{% blocktranslate %}No{% endblocktranslate %}")
-        with translation.override(self._old_language), translation.override('nl'):
-            self.assertEqual(t.render(Context({})), 'Nee')
+        with translation.override("de"):
+            t = self.get_template(
+                "{% load i18n %}{% blocktranslate %}No{% endblocktranslate %}"
+            )
+        with translation.override(self._old_language), translation.override("nl"):
+            self.assertEqual(t.render(Context({})), "Nee")
 
     def test_multiple_locale_deactivate_btrans(self):
-        with translation.override('de', deactivate=True):
-            t = self.get_template("{% load i18n %}{% blocktranslate %}No{% endblocktranslate %}")
-        with translation.override('nl'):
-            self.assertEqual(t.render(Context({})), 'Nee')
+        with translation.override("de", deactivate=True):
+            t = self.get_template(
+                "{% load i18n %}{% blocktranslate %}No{% endblocktranslate %}"
+            )
+        with translation.override("nl"):
+            self.assertEqual(t.render(Context({})), "Nee")
 
     def test_multiple_locale_direct_switch_btrans(self):
-        with translation.override('de'):
-            t = self.get_template("{% load i18n %}{% blocktranslate %}No{% endblocktranslate %}")
-        with translation.override('nl'):
-            self.assertEqual(t.render(Context({})), 'Nee')
+        with translation.override("de"):
+            t = self.get_template(
+                "{% load i18n %}{% blocktranslate %}No{% endblocktranslate %}"
+            )
+        with translation.override("nl"):
+            self.assertEqual(t.render(Context({})), "Nee")
 
 
-class MultipleLocaleActivationBlockTransTests(MultipleLocaleActivationBlockTranslateTests):
-    tag_name = 'blocktrans'
+class MultipleLocaleActivationBlockTransTests(
+    MultipleLocaleActivationBlockTranslateTests
+):
+    tag_name = "blocktrans"
 
 
 class MiscTests(SimpleTestCase):
-    tag_name = 'blocktranslate'
+    tag_name = "blocktranslate"
 
     def get_template(self, template_string):
         return Template(
             template_string.replace(
-                '{{% blocktranslate ',
-                '{{% {}'.format(self.tag_name)
+                "{{% blocktranslate ", "{{% {}".format(self.tag_name)
             ).replace(
-                '{{% endblocktranslate %}}',
-                '{{% end{} %}}'.format(self.tag_name)
+                "{{% endblocktranslate %}}", "{{% end{} %}}".format(self.tag_name)
             )
         )
 
@@ -558,10 +735,18 @@ class MiscTests(SimpleTestCase):
             "{{ percent }}% represents {{ num }} object{% plural %}"
             "{{ percent }}% represents {{ num }} objects{% endblocktranslate %}"
         )
-        with translation.override('de'):
-            self.assertEqual(t_sing.render(Context({'percent': 42})), 'Das Ergebnis war 42%')
-            self.assertEqual(t_plur.render(Context({'percent': 42, 'num': 1})), '42% stellt 1 Objekt dar')
-            self.assertEqual(t_plur.render(Context({'percent': 42, 'num': 4})), '42% stellt 4 Objekte dar')
+        with translation.override("de"):
+            self.assertEqual(
+                t_sing.render(Context({"percent": 42})), "Das Ergebnis war 42%"
+            )
+            self.assertEqual(
+                t_plur.render(Context({"percent": 42, "num": 1})),
+                "42% stellt 1 Objekt dar",
+            )
+            self.assertEqual(
+                t_plur.render(Context({"percent": 42, "num": 4})),
+                "42% stellt 4 Objekte dar",
+            )
 
     @override_settings(LOCALE_PATHS=extended_locale_paths)
     def test_percent_formatting_in_blocktranslate(self):
@@ -577,26 +762,38 @@ class MiscTests(SimpleTestCase):
             "%(percent)s% represents {{ num }} object{% plural %}"
             "%(percent)s% represents {{ num }} objects{% endblocktranslate %}"
         )
-        with translation.override('de'):
+        with translation.override("de"):
             # Strings won't get translated as they don't match after escaping %
-            self.assertEqual(t_sing.render(Context({'num_comments': 42})), 'There are %(num_comments)s comments')
-            self.assertEqual(t_plur.render(Context({'percent': 42, 'num': 1})), '%(percent)s% represents 1 object')
-            self.assertEqual(t_plur.render(Context({'percent': 42, 'num': 4})), '%(percent)s% represents 4 objects')
+            self.assertEqual(
+                t_sing.render(Context({"num_comments": 42})),
+                "There are %(num_comments)s comments",
+            )
+            self.assertEqual(
+                t_plur.render(Context({"percent": 42, "num": 1})),
+                "%(percent)s% represents 1 object",
+            )
+            self.assertEqual(
+                t_plur.render(Context({"percent": 42, "num": 4})),
+                "%(percent)s% represents 4 objects",
+            )
 
 
 class MiscBlockTranslationTests(MiscTests):
-    tag_name = 'blocktrans'
+    tag_name = "blocktrans"
 
 
 class BlockTranslateNodeTests(SimpleTestCase):
     def test_repr(self):
-        block_translate_node = BlockTranslateNode(extra_context={}, singular=[
-            Token(TokenType.TEXT, 'content'),
-            Token(TokenType.VAR, 'variable'),
-        ])
+        block_translate_node = BlockTranslateNode(
+            extra_context={},
+            singular=[
+                Token(TokenType.TEXT, "content"),
+                Token(TokenType.VAR, "variable"),
+            ],
+        )
         self.assertEqual(
             repr(block_translate_node),
-            '<BlockTranslateNode: extra_context={} '
+            "<BlockTranslateNode: extra_context={} "
             'singular=[<Text token: "content...">, <Var token: "variable...">] '
-            'plural=None>',
+            "plural=None>",
         )
diff --git a/tests/template_tests/syntax_tests/i18n/test_filters.py b/tests/template_tests/syntax_tests/i18n/test_filters.py
index cf8e4573c3..c78b8aca5f 100644
--- a/tests/template_tests/syntax_tests/i18n/test_filters.py
+++ b/tests/template_tests/syntax_tests/i18n/test_filters.py
@@ -6,42 +6,56 @@ from ...utils import setup
 
 class I18nFiltersTests(SimpleTestCase):
     libraries = {
-        'custom': 'template_tests.templatetags.custom',
-        'i18n': 'django.templatetags.i18n',
+        "custom": "template_tests.templatetags.custom",
+        "i18n": "django.templatetags.i18n",
     }
 
-    @setup({'i18n32': '{% load i18n %}{{ "hu"|language_name }} '
-                      '{{ "hu"|language_name_local }} {{ "hu"|language_bidi }} '
-                      '{{ "hu"|language_name_translated }}'})
+    @setup(
+        {
+            "i18n32": '{% load i18n %}{{ "hu"|language_name }} '
+            '{{ "hu"|language_name_local }} {{ "hu"|language_bidi }} '
+            '{{ "hu"|language_name_translated }}'
+        }
+    )
     def test_i18n32(self):
-        output = self.engine.render_to_string('i18n32')
-        self.assertEqual(output, 'Hungarian Magyar False Hungarian')
+        output = self.engine.render_to_string("i18n32")
+        self.assertEqual(output, "Hungarian Magyar False Hungarian")
 
-        with translation.override('cs'):
-            output = self.engine.render_to_string('i18n32')
-            self.assertEqual(output, 'Hungarian Magyar False maďarsky')
+        with translation.override("cs"):
+            output = self.engine.render_to_string("i18n32")
+            self.assertEqual(output, "Hungarian Magyar False maďarsky")
 
-    @setup({'i18n33': '{% load i18n %}'
-                      '{{ langcode|language_name }} {{ langcode|language_name_local }} '
-                      '{{ langcode|language_bidi }} {{ langcode|language_name_translated }}'})
+    @setup(
+        {
+            "i18n33": "{% load i18n %}"
+            "{{ langcode|language_name }} {{ langcode|language_name_local }} "
+            "{{ langcode|language_bidi }} {{ langcode|language_name_translated }}"
+        }
+    )
     def test_i18n33(self):
-        output = self.engine.render_to_string('i18n33', {'langcode': 'nl'})
-        self.assertEqual(output, 'Dutch Nederlands False Dutch')
+        output = self.engine.render_to_string("i18n33", {"langcode": "nl"})
+        self.assertEqual(output, "Dutch Nederlands False Dutch")
 
-        with translation.override('cs'):
-            output = self.engine.render_to_string('i18n33', {'langcode': 'nl'})
-            self.assertEqual(output, 'Dutch Nederlands False nizozemsky')
+        with translation.override("cs"):
+            output = self.engine.render_to_string("i18n33", {"langcode": "nl"})
+            self.assertEqual(output, "Dutch Nederlands False nizozemsky")
 
-    @setup({'i18n38_2': '{% load i18n custom %}'
-                        '{% get_language_info_list for langcodes|noop:"x y" as langs %}'
-                        '{% for l in langs %}{{ l.code }}: {{ l.name }}/'
-                        '{{ l.name_local }}/{{ l.name_translated }} '
-                        'bidi={{ l.bidi }}; {% endfor %}'})
+    @setup(
+        {
+            "i18n38_2": "{% load i18n custom %}"
+            '{% get_language_info_list for langcodes|noop:"x y" as langs %}'
+            "{% for l in langs %}{{ l.code }}: {{ l.name }}/"
+            "{{ l.name_local }}/{{ l.name_translated }} "
+            "bidi={{ l.bidi }}; {% endfor %}"
+        }
+    )
     def test_i18n38_2(self):
-        with translation.override('cs'):
-            output = self.engine.render_to_string('i18n38_2', {'langcodes': ['it', 'fr']})
+        with translation.override("cs"):
+            output = self.engine.render_to_string(
+                "i18n38_2", {"langcodes": ["it", "fr"]}
+            )
         self.assertEqual(
             output,
-            'it: Italian/italiano/italsky bidi=False; '
-            'fr: French/français/francouzsky bidi=False; '
+            "it: Italian/italiano/italsky bidi=False; "
+            "fr: French/français/francouzsky bidi=False; ",
         )
diff --git a/tests/template_tests/syntax_tests/i18n/test_get_available_languages.py b/tests/template_tests/syntax_tests/i18n/test_get_available_languages.py
index 5ac97a4f79..dce5a4de66 100644
--- a/tests/template_tests/syntax_tests/i18n/test_get_available_languages.py
+++ b/tests/template_tests/syntax_tests/i18n/test_get_available_languages.py
@@ -5,17 +5,21 @@ from ...utils import setup
 
 
 class GetAvailableLanguagesTagTests(SimpleTestCase):
-    libraries = {'i18n': 'django.templatetags.i18n'}
+    libraries = {"i18n": "django.templatetags.i18n"}
 
-    @setup({'i18n12': '{% load i18n %}'
-                      '{% get_available_languages as langs %}{% for lang in langs %}'
-                      '{% if lang.0 == "de" %}{{ lang.0 }}{% endif %}{% endfor %}'})
+    @setup(
+        {
+            "i18n12": "{% load i18n %}"
+            "{% get_available_languages as langs %}{% for lang in langs %}"
+            '{% if lang.0 == "de" %}{{ lang.0 }}{% endif %}{% endfor %}'
+        }
+    )
     def test_i18n12(self):
-        output = self.engine.render_to_string('i18n12')
-        self.assertEqual(output, 'de')
+        output = self.engine.render_to_string("i18n12")
+        self.assertEqual(output, "de")
 
-    @setup({'syntax_i18n': '{% load i18n %}{% get_available_languages a langs %}'})
+    @setup({"syntax_i18n": "{% load i18n %}{% get_available_languages a langs %}"})
     def test_no_as_var(self):
         msg = "'get_available_languages' requires 'as variable' (got ['get_available_languages', 'a', 'langs'])"
         with self.assertRaisesMessage(TemplateSyntaxError, msg):
-            self.engine.render_to_string('syntax_i18n')
+            self.engine.render_to_string("syntax_i18n")
diff --git a/tests/template_tests/syntax_tests/i18n/test_get_current_language.py b/tests/template_tests/syntax_tests/i18n/test_get_current_language.py
index f168b74f8e..8ed7f742c2 100644
--- a/tests/template_tests/syntax_tests/i18n/test_get_current_language.py
+++ b/tests/template_tests/syntax_tests/i18n/test_get_current_language.py
@@ -5,10 +5,10 @@ from django.test import SimpleTestCase
 
 
 class I18nGetCurrentLanguageTagTests(SimpleTestCase):
-    libraries = {'i18n': 'django.templatetags.i18n'}
+    libraries = {"i18n": "django.templatetags.i18n"}
 
-    @setup({'template': '{% load i18n %} {% get_current_language %}'})
+    @setup({"template": "{% load i18n %} {% get_current_language %}"})
     def test_no_as_var(self):
         msg = "'get_current_language' requires 'as variable' (got ['get_current_language'])"
         with self.assertRaisesMessage(TemplateSyntaxError, msg):
-            self.engine.render_to_string('template')
+            self.engine.render_to_string("template")
diff --git a/tests/template_tests/syntax_tests/i18n/test_get_current_language_bidi.py b/tests/template_tests/syntax_tests/i18n/test_get_current_language_bidi.py
index 0ac408f78f..3f307471ae 100644
--- a/tests/template_tests/syntax_tests/i18n/test_get_current_language_bidi.py
+++ b/tests/template_tests/syntax_tests/i18n/test_get_current_language_bidi.py
@@ -5,10 +5,10 @@ from django.test import SimpleTestCase
 
 
 class I18nGetCurrentLanguageBidiTagTests(SimpleTestCase):
-    libraries = {'i18n': 'django.templatetags.i18n'}
+    libraries = {"i18n": "django.templatetags.i18n"}
 
-    @setup({'template': '{% load i18n %} {% get_current_language_bidi %}'})
+    @setup({"template": "{% load i18n %} {% get_current_language_bidi %}"})
     def test_no_as_var(self):
         msg = "'get_current_language_bidi' requires 'as variable' (got ['get_current_language_bidi'])"
         with self.assertRaisesMessage(TemplateSyntaxError, msg):
-            self.engine.render_to_string('template')
+            self.engine.render_to_string("template")
diff --git a/tests/template_tests/syntax_tests/i18n/test_get_language_info.py b/tests/template_tests/syntax_tests/i18n/test_get_language_info.py
index 4ae8186af5..cf05df13db 100644
--- a/tests/template_tests/syntax_tests/i18n/test_get_language_info.py
+++ b/tests/template_tests/syntax_tests/i18n/test_get_language_info.py
@@ -7,37 +7,49 @@ from ...utils import setup
 
 class I18nGetLanguageInfoTagTests(SimpleTestCase):
     libraries = {
-        'custom': 'template_tests.templatetags.custom',
-        'i18n': 'django.templatetags.i18n',
+        "custom": "template_tests.templatetags.custom",
+        "i18n": "django.templatetags.i18n",
     }
 
     # retrieving language information
-    @setup({'i18n28_2': '{% load i18n %}'
-                        '{% get_language_info for "de" as l %}'
-                        '{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}'})
+    @setup(
+        {
+            "i18n28_2": "{% load i18n %}"
+            '{% get_language_info for "de" as l %}'
+            "{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}"
+        }
+    )
     def test_i18n28_2(self):
-        output = self.engine.render_to_string('i18n28_2')
-        self.assertEqual(output, 'de: German/Deutsch bidi=False')
+        output = self.engine.render_to_string("i18n28_2")
+        self.assertEqual(output, "de: German/Deutsch bidi=False")
 
-    @setup({'i18n29': '{% load i18n %}'
-                      '{% get_language_info for LANGUAGE_CODE as l %}'
-                      '{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}'})
+    @setup(
+        {
+            "i18n29": "{% load i18n %}"
+            "{% get_language_info for LANGUAGE_CODE as l %}"
+            "{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}"
+        }
+    )
     def test_i18n29(self):
-        output = self.engine.render_to_string('i18n29', {'LANGUAGE_CODE': 'fi'})
-        self.assertEqual(output, 'fi: Finnish/suomi bidi=False')
+        output = self.engine.render_to_string("i18n29", {"LANGUAGE_CODE": "fi"})
+        self.assertEqual(output, "fi: Finnish/suomi bidi=False")
 
     # Test whitespace in filter arguments
-    @setup({'i18n38': '{% load i18n custom %}'
-                      '{% get_language_info for "de"|noop:"x y" as l %}'
-                      '{{ l.code }}: {{ l.name }}/{{ l.name_local }}/'
-                      '{{ l.name_translated }} bidi={{ l.bidi }}'})
+    @setup(
+        {
+            "i18n38": "{% load i18n custom %}"
+            '{% get_language_info for "de"|noop:"x y" as l %}'
+            "{{ l.code }}: {{ l.name }}/{{ l.name_local }}/"
+            "{{ l.name_translated }} bidi={{ l.bidi }}"
+        }
+    )
     def test_i18n38(self):
-        with translation.override('cs'):
-            output = self.engine.render_to_string('i18n38')
-        self.assertEqual(output, 'de: German/Deutsch/německy bidi=False')
+        with translation.override("cs"):
+            output = self.engine.render_to_string("i18n38")
+        self.assertEqual(output, "de: German/Deutsch/německy bidi=False")
 
-    @setup({'template': '{% load i18n %}{% get_language_info %}'})
+    @setup({"template": "{% load i18n %}{% get_language_info %}"})
     def test_no_for_as(self):
         msg = "'get_language_info' requires 'for string as variable' (got [])"
         with self.assertRaisesMessage(TemplateSyntaxError, msg):
-            self.engine.render_to_string('template')
+            self.engine.render_to_string("template")
diff --git a/tests/template_tests/syntax_tests/i18n/test_get_language_info_list.py b/tests/template_tests/syntax_tests/i18n/test_get_language_info_list.py
index c2c7f8b9cb..93038daa2f 100644
--- a/tests/template_tests/syntax_tests/i18n/test_get_language_info_list.py
+++ b/tests/template_tests/syntax_tests/i18n/test_get_language_info_list.py
@@ -7,46 +7,64 @@ from ...utils import setup
 
 class GetLanguageInfoListTests(SimpleTestCase):
     libraries = {
-        'custom': 'template_tests.templatetags.custom',
-        'i18n': 'django.templatetags.i18n',
+        "custom": "template_tests.templatetags.custom",
+        "i18n": "django.templatetags.i18n",
     }
 
-    @setup({'i18n30': '{% load i18n %}'
-                      '{% get_language_info_list for langcodes as langs %}'
-                      '{% for l in langs %}{{ l.code }}: {{ l.name }}/'
-                      '{{ l.name_local }} bidi={{ l.bidi }}; {% endfor %}'})
+    @setup(
+        {
+            "i18n30": "{% load i18n %}"
+            "{% get_language_info_list for langcodes as langs %}"
+            "{% for l in langs %}{{ l.code }}: {{ l.name }}/"
+            "{{ l.name_local }} bidi={{ l.bidi }}; {% endfor %}"
+        }
+    )
     def test_i18n30(self):
-        output = self.engine.render_to_string('i18n30', {'langcodes': ['it', 'no']})
-        self.assertEqual(output, 'it: Italian/italiano bidi=False; no: Norwegian/norsk bidi=False; ')
+        output = self.engine.render_to_string("i18n30", {"langcodes": ["it", "no"]})
+        self.assertEqual(
+            output, "it: Italian/italiano bidi=False; no: Norwegian/norsk bidi=False; "
+        )
 
-    @setup({'i18n31': '{% load i18n %}'
-                      '{% get_language_info_list for langcodes as langs %}'
-                      '{% for l in langs %}{{ l.code }}: {{ l.name }}/'
-                      '{{ l.name_local }} bidi={{ l.bidi }}; {% endfor %}'})
+    @setup(
+        {
+            "i18n31": "{% load i18n %}"
+            "{% get_language_info_list for langcodes as langs %}"
+            "{% for l in langs %}{{ l.code }}: {{ l.name }}/"
+            "{{ l.name_local }} bidi={{ l.bidi }}; {% endfor %}"
+        }
+    )
     def test_i18n31(self):
-        output = self.engine.render_to_string('i18n31', {'langcodes': (('sl', 'Slovenian'), ('fa', 'Persian'))})
+        output = self.engine.render_to_string(
+            "i18n31", {"langcodes": (("sl", "Slovenian"), ("fa", "Persian"))}
+        )
         self.assertEqual(
             output,
-            'sl: Slovenian/Sloven\u0161\u010dina bidi=False; '
-            'fa: Persian/\u0641\u0627\u0631\u0633\u06cc bidi=True; '
+            "sl: Slovenian/Sloven\u0161\u010dina bidi=False; "
+            "fa: Persian/\u0641\u0627\u0631\u0633\u06cc bidi=True; ",
         )
 
-    @setup({'i18n38_2': '{% load i18n custom %}'
-                        '{% get_language_info_list for langcodes|noop:"x y" as langs %}'
-                        '{% for l in langs %}{{ l.code }}: {{ l.name }}/'
-                        '{{ l.name_local }}/{{ l.name_translated }} '
-                        'bidi={{ l.bidi }}; {% endfor %}'})
+    @setup(
+        {
+            "i18n38_2": "{% load i18n custom %}"
+            '{% get_language_info_list for langcodes|noop:"x y" as langs %}'
+            "{% for l in langs %}{{ l.code }}: {{ l.name }}/"
+            "{{ l.name_local }}/{{ l.name_translated }} "
+            "bidi={{ l.bidi }}; {% endfor %}"
+        }
+    )
     def test_i18n38_2(self):
-        with translation.override('cs'):
-            output = self.engine.render_to_string('i18n38_2', {'langcodes': ['it', 'fr']})
+        with translation.override("cs"):
+            output = self.engine.render_to_string(
+                "i18n38_2", {"langcodes": ["it", "fr"]}
+            )
         self.assertEqual(
             output,
-            'it: Italian/italiano/italsky bidi=False; '
-            'fr: French/français/francouzsky bidi=False; '
+            "it: Italian/italiano/italsky bidi=False; "
+            "fr: French/français/francouzsky bidi=False; ",
         )
 
-    @setup({'i18n_syntax': '{% load i18n %} {% get_language_info_list error %}'})
+    @setup({"i18n_syntax": "{% load i18n %} {% get_language_info_list error %}"})
     def test_no_for_as(self):
         msg = "'get_language_info_list' requires 'for sequence as variable' (got ['error'])"
         with self.assertRaisesMessage(TemplateSyntaxError, msg):
-            self.engine.render_to_string('i18n_syntax')
+            self.engine.render_to_string("i18n_syntax")
diff --git a/tests/template_tests/syntax_tests/i18n/test_language.py b/tests/template_tests/syntax_tests/i18n/test_language.py
index 47797befae..57a3a53866 100644
--- a/tests/template_tests/syntax_tests/i18n/test_language.py
+++ b/tests/template_tests/syntax_tests/i18n/test_language.py
@@ -5,9 +5,11 @@ from django.test import SimpleTestCase
 
 
 class I18nLanguageTagTests(SimpleTestCase):
-    libraries = {'i18n': 'django.templatetags.i18n'}
+    libraries = {"i18n": "django.templatetags.i18n"}
 
-    @setup({'i18n_language': '{% load i18n %} {% language %} {% endlanguage %}'})
+    @setup({"i18n_language": "{% load i18n %} {% language %} {% endlanguage %}"})
     def test_no_arg(self):
-        with self.assertRaisesMessage(TemplateSyntaxError, "'language' takes one argument (language)"):
-            self.engine.render_to_string('i18n_language')
+        with self.assertRaisesMessage(
+            TemplateSyntaxError, "'language' takes one argument (language)"
+        ):
+            self.engine.render_to_string("i18n_language")
diff --git a/tests/template_tests/syntax_tests/i18n/test_translate.py b/tests/template_tests/syntax_tests/i18n/test_translate.py
index 55fdb92f7a..932b47a373 100644
--- a/tests/template_tests/syntax_tests/i18n/test_translate.py
+++ b/tests/template_tests/syntax_tests/i18n/test_translate.py
@@ -16,14 +16,16 @@ from .base import MultipleLocaleActivationTestCase, extended_locale_paths
 
 def setup(templates, *args, **kwargs):
     translate_setup = base_setup(templates, *args, **kwargs)
-    trans_setup = base_setup({
-        name: template.replace('{% translate ', '{% trans ')
-        for name, template in templates.items()
-    })
+    trans_setup = base_setup(
+        {
+            name: template.replace("{% translate ", "{% trans ")
+            for name, template in templates.items()
+        }
+    )
 
     tags = {
-        'trans': trans_setup,
-        'translate': translate_setup,
+        "trans": trans_setup,
+        "translate": translate_setup,
     }
 
     def decorator(func):
@@ -31,143 +33,162 @@ def setup(templates, *args, **kwargs):
         def inner(self, *args):
             signature = inspect.signature(func)
             for tag_name, setup_func in tags.items():
-                if 'tag_name' in signature.parameters:
+                if "tag_name" in signature.parameters:
                     setup_func(partial(func, tag_name=tag_name))(self)
                 else:
                     setup_func(func)(self)
+
         return inner
+
     return decorator
 
 
 class I18nTransTagTests(SimpleTestCase):
-    libraries = {'i18n': 'django.templatetags.i18n'}
+    libraries = {"i18n": "django.templatetags.i18n"}
 
-    @setup({'i18n01': '{% load i18n %}{% translate \'xxxyyyxxx\' %}'})
+    @setup({"i18n01": "{% load i18n %}{% translate 'xxxyyyxxx' %}"})
     def test_i18n01(self):
         """simple translation of a string delimited by '."""
-        output = self.engine.render_to_string('i18n01')
-        self.assertEqual(output, 'xxxyyyxxx')
+        output = self.engine.render_to_string("i18n01")
+        self.assertEqual(output, "xxxyyyxxx")
 
-    @setup({'i18n02': '{% load i18n %}{% translate "xxxyyyxxx" %}'})
+    @setup({"i18n02": '{% load i18n %}{% translate "xxxyyyxxx" %}'})
     def test_i18n02(self):
         """simple translation of a string delimited by "."""
-        output = self.engine.render_to_string('i18n02')
-        self.assertEqual(output, 'xxxyyyxxx')
+        output = self.engine.render_to_string("i18n02")
+        self.assertEqual(output, "xxxyyyxxx")
 
-    @setup({'i18n06': '{% load i18n %}{% translate "Page not found" %}'})
+    @setup({"i18n06": '{% load i18n %}{% translate "Page not found" %}'})
     def test_i18n06(self):
         """simple translation of a string to German"""
-        with translation.override('de'):
-            output = self.engine.render_to_string('i18n06')
-        self.assertEqual(output, 'Seite nicht gefunden')
+        with translation.override("de"):
+            output = self.engine.render_to_string("i18n06")
+        self.assertEqual(output, "Seite nicht gefunden")
 
-    @setup({'i18n09': '{% load i18n %}{% translate "Page not found" noop %}'})
+    @setup({"i18n09": '{% load i18n %}{% translate "Page not found" noop %}'})
     def test_i18n09(self):
         """simple non-translation (only marking) of a string to German"""
-        with translation.override('de'):
-            output = self.engine.render_to_string('i18n09')
-        self.assertEqual(output, 'Page not found')
+        with translation.override("de"):
+            output = self.engine.render_to_string("i18n09")
+        self.assertEqual(output, "Page not found")
 
-    @setup({'i18n20': '{% load i18n %}{% translate andrew %}'})
+    @setup({"i18n20": "{% load i18n %}{% translate andrew %}"})
     def test_i18n20(self):
-        output = self.engine.render_to_string('i18n20', {'andrew': 'a & b'})
-        self.assertEqual(output, 'a &amp; b')
+        output = self.engine.render_to_string("i18n20", {"andrew": "a & b"})
+        self.assertEqual(output, "a &amp; b")
 
-    @setup({'i18n22': '{% load i18n %}{% translate andrew %}'})
+    @setup({"i18n22": "{% load i18n %}{% translate andrew %}"})
     def test_i18n22(self):
-        output = self.engine.render_to_string('i18n22', {'andrew': mark_safe('a & b')})
-        self.assertEqual(output, 'a & b')
+        output = self.engine.render_to_string("i18n22", {"andrew": mark_safe("a & b")})
+        self.assertEqual(output, "a & b")
 
-    @setup({'i18n23': '{% load i18n %}{% translate "Page not found"|capfirst|slice:"6:" %}'})
+    @setup(
+        {
+            "i18n23": '{% load i18n %}{% translate "Page not found"|capfirst|slice:"6:" %}'
+        }
+    )
     def test_i18n23(self):
         """Using filters with the {% translate %} tag (#5972)."""
-        with translation.override('de'):
-            output = self.engine.render_to_string('i18n23')
-        self.assertEqual(output, 'nicht gefunden')
+        with translation.override("de"):
+            output = self.engine.render_to_string("i18n23")
+        self.assertEqual(output, "nicht gefunden")
 
-    @setup({'i18n24': '{% load i18n %}{% translate \'Page not found\'|upper %}'})
+    @setup({"i18n24": "{% load i18n %}{% translate 'Page not found'|upper %}"})
     def test_i18n24(self):
-        with translation.override('de'):
-            output = self.engine.render_to_string('i18n24')
-        self.assertEqual(output, 'SEITE NICHT GEFUNDEN')
+        with translation.override("de"):
+            output = self.engine.render_to_string("i18n24")
+        self.assertEqual(output, "SEITE NICHT GEFUNDEN")
 
-    @setup({'i18n25': '{% load i18n %}{% translate somevar|upper %}'})
+    @setup({"i18n25": "{% load i18n %}{% translate somevar|upper %}"})
     def test_i18n25(self):
-        with translation.override('de'):
-            output = self.engine.render_to_string('i18n25', {'somevar': 'Page not found'})
-        self.assertEqual(output, 'SEITE NICHT GEFUNDEN')
+        with translation.override("de"):
+            output = self.engine.render_to_string(
+                "i18n25", {"somevar": "Page not found"}
+            )
+        self.assertEqual(output, "SEITE NICHT GEFUNDEN")
 
     # trans tag with as var
-    @setup({'i18n35': '{% load i18n %}{% translate "Page not found" as page_not_found %}{{ page_not_found }}'})
+    @setup(
+        {
+            "i18n35": '{% load i18n %}{% translate "Page not found" as page_not_found %}{{ page_not_found }}'
+        }
+    )
     def test_i18n35(self):
-        with translation.override('de'):
-            output = self.engine.render_to_string('i18n35')
-        self.assertEqual(output, 'Seite nicht gefunden')
+        with translation.override("de"):
+            output = self.engine.render_to_string("i18n35")
+        self.assertEqual(output, "Seite nicht gefunden")
 
-    @setup({'i18n36': '{% load i18n %}'
-                      '{% translate "Page not found" noop as page_not_found %}{{ page_not_found }}'})
+    @setup(
+        {
+            "i18n36": "{% load i18n %}"
+            '{% translate "Page not found" noop as page_not_found %}{{ page_not_found }}'
+        }
+    )
     def test_i18n36(self):
-        with translation.override('de'):
-            output = self.engine.render_to_string('i18n36')
-        self.assertEqual(output, 'Page not found')
+        with translation.override("de"):
+            output = self.engine.render_to_string("i18n36")
+        self.assertEqual(output, "Page not found")
 
-    @setup({'template': '{% load i18n %}{% translate %}A}'})
+    @setup({"template": "{% load i18n %}{% translate %}A}"})
     def test_syntax_error_no_arguments(self, tag_name):
         msg = "'{}' takes at least one argument".format(tag_name)
         with self.assertRaisesMessage(TemplateSyntaxError, msg):
-            self.engine.render_to_string('template')
+            self.engine.render_to_string("template")
 
-    @setup({'template': '{% load i18n %}{% translate "Yes" badoption %}'})
+    @setup({"template": '{% load i18n %}{% translate "Yes" badoption %}'})
     def test_syntax_error_bad_option(self, tag_name):
         msg = "Unknown argument for '{}' tag: 'badoption'".format(tag_name)
         with self.assertRaisesMessage(TemplateSyntaxError, msg):
-            self.engine.render_to_string('template')
+            self.engine.render_to_string("template")
 
-    @setup({'template': '{% load i18n %}{% translate "Yes" as %}'})
+    @setup({"template": '{% load i18n %}{% translate "Yes" as %}'})
     def test_syntax_error_missing_assignment(self, tag_name):
         msg = "No argument provided to the '{}' tag for the as option.".format(tag_name)
         with self.assertRaisesMessage(TemplateSyntaxError, msg):
-            self.engine.render_to_string('template')
+            self.engine.render_to_string("template")
 
-    @setup({'template': '{% load i18n %}{% translate "Yes" as var context %}'})
+    @setup({"template": '{% load i18n %}{% translate "Yes" as var context %}'})
     def test_syntax_error_missing_context(self, tag_name):
-        msg = "No argument provided to the '{}' tag for the context option.".format(tag_name)
+        msg = "No argument provided to the '{}' tag for the context option.".format(
+            tag_name
+        )
         with self.assertRaisesMessage(TemplateSyntaxError, msg):
-            self.engine.render_to_string('template')
+            self.engine.render_to_string("template")
 
-    @setup({'template': '{% load i18n %}{% translate "Yes" context as var %}'})
+    @setup({"template": '{% load i18n %}{% translate "Yes" context as var %}'})
     def test_syntax_error_context_as(self, tag_name):
-        msg = "Invalid argument 'as' provided to the '{}' tag for the context option".format(tag_name)
+        msg = "Invalid argument 'as' provided to the '{}' tag for the context option".format(
+            tag_name
+        )
         with self.assertRaisesMessage(TemplateSyntaxError, msg):
-            self.engine.render_to_string('template')
+            self.engine.render_to_string("template")
 
-    @setup({'template': '{% load i18n %}{% translate "Yes" context noop %}'})
+    @setup({"template": '{% load i18n %}{% translate "Yes" context noop %}'})
     def test_syntax_error_context_noop(self, tag_name):
-        msg = "Invalid argument 'noop' provided to the '{}' tag for the context option".format(tag_name)
+        msg = "Invalid argument 'noop' provided to the '{}' tag for the context option".format(
+            tag_name
+        )
         with self.assertRaisesMessage(TemplateSyntaxError, msg):
-            self.engine.render_to_string('template')
+            self.engine.render_to_string("template")
 
-    @setup({'template': '{% load i18n %}{% translate "Yes" noop noop %}'})
+    @setup({"template": '{% load i18n %}{% translate "Yes" noop noop %}'})
     def test_syntax_error_duplicate_option(self):
         msg = "The 'noop' option was specified more than once."
         with self.assertRaisesMessage(TemplateSyntaxError, msg):
-            self.engine.render_to_string('template')
+            self.engine.render_to_string("template")
 
-    @setup({'template': '{% load i18n %}{% translate "%s" %}'})
+    @setup({"template": '{% load i18n %}{% translate "%s" %}'})
     def test_trans_tag_using_a_string_that_looks_like_str_fmt(self):
-        output = self.engine.render_to_string('template')
-        self.assertEqual(output, '%s')
+        output = self.engine.render_to_string("template")
+        self.assertEqual(output, "%s")
 
 
 class TranslationTransTagTests(SimpleTestCase):
-    tag_name = 'trans'
+    tag_name = "trans"
 
     def get_template(self, template_string):
         return Template(
-            template_string.replace(
-                '{{% translate ',
-                '{{% {}'.format(self.tag_name)
-            )
+            template_string.replace("{{% translate ", "{{% {}".format(self.tag_name))
         )
 
     @override_settings(LOCALE_PATHS=extended_locale_paths)
@@ -175,58 +196,71 @@ class TranslationTransTagTests(SimpleTestCase):
         """{% translate %} takes message contexts into account (#14806)."""
         trans_real._active = Local()
         trans_real._translations = {}
-        with translation.override('de'):
+        with translation.override("de"):
             # Nonexistent context...
-            t = self.get_template('{% load i18n %}{% translate "May" context "nonexistent" %}')
+            t = self.get_template(
+                '{% load i18n %}{% translate "May" context "nonexistent" %}'
+            )
             rendered = t.render(Context())
-            self.assertEqual(rendered, 'May')
+            self.assertEqual(rendered, "May")
 
             # Existing context... using a literal
-            t = self.get_template('{% load i18n %}{% translate "May" context "month name" %}')
+            t = self.get_template(
+                '{% load i18n %}{% translate "May" context "month name" %}'
+            )
             rendered = t.render(Context())
-            self.assertEqual(rendered, 'Mai')
+            self.assertEqual(rendered, "Mai")
             t = self.get_template('{% load i18n %}{% translate "May" context "verb" %}')
             rendered = t.render(Context())
-            self.assertEqual(rendered, 'Kann')
+            self.assertEqual(rendered, "Kann")
 
             # Using a variable
-            t = self.get_template('{% load i18n %}{% translate "May" context message_context %}')
-            rendered = t.render(Context({'message_context': 'month name'}))
-            self.assertEqual(rendered, 'Mai')
-            t = self.get_template('{% load i18n %}{% translate "May" context message_context %}')
-            rendered = t.render(Context({'message_context': 'verb'}))
-            self.assertEqual(rendered, 'Kann')
+            t = self.get_template(
+                '{% load i18n %}{% translate "May" context message_context %}'
+            )
+            rendered = t.render(Context({"message_context": "month name"}))
+            self.assertEqual(rendered, "Mai")
+            t = self.get_template(
+                '{% load i18n %}{% translate "May" context message_context %}'
+            )
+            rendered = t.render(Context({"message_context": "verb"}))
+            self.assertEqual(rendered, "Kann")
 
             # Using a filter
-            t = self.get_template('{% load i18n %}{% translate "May" context message_context|lower %}')
-            rendered = t.render(Context({'message_context': 'MONTH NAME'}))
-            self.assertEqual(rendered, 'Mai')
-            t = self.get_template('{% load i18n %}{% translate "May" context message_context|lower %}')
-            rendered = t.render(Context({'message_context': 'VERB'}))
-            self.assertEqual(rendered, 'Kann')
+            t = self.get_template(
+                '{% load i18n %}{% translate "May" context message_context|lower %}'
+            )
+            rendered = t.render(Context({"message_context": "MONTH NAME"}))
+            self.assertEqual(rendered, "Mai")
+            t = self.get_template(
+                '{% load i18n %}{% translate "May" context message_context|lower %}'
+            )
+            rendered = t.render(Context({"message_context": "VERB"}))
+            self.assertEqual(rendered, "Kann")
 
             # Using 'as'
-            t = self.get_template('{% load i18n %}{% translate "May" context "month name" as var %}Value: {{ var }}')
+            t = self.get_template(
+                '{% load i18n %}{% translate "May" context "month name" as var %}Value: {{ var }}'
+            )
             rendered = t.render(Context())
-            self.assertEqual(rendered, 'Value: Mai')
-            t = self.get_template('{% load i18n %}{% translate "May" as var context "verb" %}Value: {{ var }}')
+            self.assertEqual(rendered, "Value: Mai")
+            t = self.get_template(
+                '{% load i18n %}{% translate "May" as var context "verb" %}Value: {{ var }}'
+            )
             rendered = t.render(Context())
-            self.assertEqual(rendered, 'Value: Kann')
+            self.assertEqual(rendered, "Value: Kann")
 
 
 class TranslationTranslateTagTests(TranslationTransTagTests):
-    tag_name = 'translate'
+    tag_name = "translate"
 
 
 class MultipleLocaleActivationTransTagTests(MultipleLocaleActivationTestCase):
-    tag_name = 'trans'
+    tag_name = "trans"
 
     def get_template(self, template_string):
         return Template(
-            template_string.replace(
-                '{{% translate ',
-                '{{% {}'.format(self.tag_name)
-            )
+            template_string.replace("{{% translate ", "{{% {}".format(self.tag_name))
         )
 
     def test_single_locale_activation(self):
@@ -234,36 +268,38 @@ class MultipleLocaleActivationTransTagTests(MultipleLocaleActivationTestCase):
         Simple baseline behavior with one locale for all the supported i18n
         constructs.
         """
-        with translation.override('fr'):
+        with translation.override("fr"):
             self.assertEqual(
-                self.get_template("{% load i18n %}{% translate 'Yes' %}").render(Context({})),
-                'Oui'
+                self.get_template("{% load i18n %}{% translate 'Yes' %}").render(
+                    Context({})
+                ),
+                "Oui",
             )
 
     def test_multiple_locale_trans(self):
-        with translation.override('de'):
+        with translation.override("de"):
             t = self.get_template("{% load i18n %}{% translate 'No' %}")
-        with translation.override(self._old_language), translation.override('nl'):
-            self.assertEqual(t.render(Context({})), 'Nee')
+        with translation.override(self._old_language), translation.override("nl"):
+            self.assertEqual(t.render(Context({})), "Nee")
 
     def test_multiple_locale_deactivate_trans(self):
-        with translation.override('de', deactivate=True):
+        with translation.override("de", deactivate=True):
             t = self.get_template("{% load i18n %}{% translate 'No' %}")
-        with translation.override('nl'):
-            self.assertEqual(t.render(Context({})), 'Nee')
+        with translation.override("nl"):
+            self.assertEqual(t.render(Context({})), "Nee")
 
     def test_multiple_locale_direct_switch_trans(self):
-        with translation.override('de'):
+        with translation.override("de"):
             t = self.get_template("{% load i18n %}{% translate 'No' %}")
-        with translation.override('nl'):
-            self.assertEqual(t.render(Context({})), 'Nee')
+        with translation.override("nl"):
+            self.assertEqual(t.render(Context({})), "Nee")
 
 
 class MultipleLocaleActivationTranslateTagTests(MultipleLocaleActivationTransTagTests):
-    tag_name = 'translate'
+    tag_name = "translate"
 
 
 class LocalizeNodeTests(SimpleTestCase):
     def test_repr(self):
         node = LocalizeNode(nodelist=[], use_l10n=True)
-        self.assertEqual(repr(node), '<LocalizeNode>')
+        self.assertEqual(repr(node), "<LocalizeNode>")
diff --git a/tests/template_tests/syntax_tests/i18n/test_underscore_syntax.py b/tests/template_tests/syntax_tests/i18n/test_underscore_syntax.py
index 38d929e214..dfb035999c 100644
--- a/tests/template_tests/syntax_tests/i18n/test_underscore_syntax.py
+++ b/tests/template_tests/syntax_tests/i18n/test_underscore_syntax.py
@@ -7,101 +7,105 @@ from .base import MultipleLocaleActivationTestCase
 
 
 class MultipleLocaleActivationTests(MultipleLocaleActivationTestCase):
-
     def test_single_locale_activation(self):
         """
         Simple baseline behavior with one locale for all the supported i18n
         constructs.
         """
-        with translation.override('fr'):
-            self.assertEqual(Template("{{ _('Yes') }}").render(Context({})), 'Oui')
+        with translation.override("fr"):
+            self.assertEqual(Template("{{ _('Yes') }}").render(Context({})), "Oui")
 
     # Literal marked up with _() in a filter expression
 
     def test_multiple_locale_filter(self):
-        with translation.override('de'):
+        with translation.override("de"):
             t = Template("{% load i18n %}{{ 0|yesno:_('yes,no,maybe') }}")
-        with translation.override(self._old_language), translation.override('nl'):
-            self.assertEqual(t.render(Context({})), 'nee')
+        with translation.override(self._old_language), translation.override("nl"):
+            self.assertEqual(t.render(Context({})), "nee")
 
     def test_multiple_locale_filter_deactivate(self):
-        with translation.override('de', deactivate=True):
+        with translation.override("de", deactivate=True):
             t = Template("{% load i18n %}{{ 0|yesno:_('yes,no,maybe') }}")
-        with translation.override('nl'):
-            self.assertEqual(t.render(Context({})), 'nee')
+        with translation.override("nl"):
+            self.assertEqual(t.render(Context({})), "nee")
 
     def test_multiple_locale_filter_direct_switch(self):
-        with translation.override('de'):
+        with translation.override("de"):
             t = Template("{% load i18n %}{{ 0|yesno:_('yes,no,maybe') }}")
-        with translation.override('nl'):
-            self.assertEqual(t.render(Context({})), 'nee')
+        with translation.override("nl"):
+            self.assertEqual(t.render(Context({})), "nee")
 
     # Literal marked up with _()
 
     def test_multiple_locale(self):
-        with translation.override('de'):
+        with translation.override("de"):
             t = Template("{{ _('No') }}")
-        with translation.override(self._old_language), translation.override('nl'):
-            self.assertEqual(t.render(Context({})), 'Nee')
+        with translation.override(self._old_language), translation.override("nl"):
+            self.assertEqual(t.render(Context({})), "Nee")
 
     def test_multiple_locale_deactivate(self):
-        with translation.override('de', deactivate=True):
+        with translation.override("de", deactivate=True):
             t = Template("{{ _('No') }}")
-        with translation.override('nl'):
-            self.assertEqual(t.render(Context({})), 'Nee')
+        with translation.override("nl"):
+            self.assertEqual(t.render(Context({})), "Nee")
 
     def test_multiple_locale_direct_switch(self):
-        with translation.override('de'):
+        with translation.override("de"):
             t = Template("{{ _('No') }}")
-        with translation.override('nl'):
-            self.assertEqual(t.render(Context({})), 'Nee')
+        with translation.override("nl"):
+            self.assertEqual(t.render(Context({})), "Nee")
 
     # Literal marked up with _(), loading the i18n template tag library
 
     def test_multiple_locale_loadi18n(self):
-        with translation.override('de'):
+        with translation.override("de"):
             t = Template("{% load i18n %}{{ _('No') }}")
-        with translation.override(self._old_language), translation.override('nl'):
-            self.assertEqual(t.render(Context({})), 'Nee')
+        with translation.override(self._old_language), translation.override("nl"):
+            self.assertEqual(t.render(Context({})), "Nee")
 
     def test_multiple_locale_loadi18n_deactivate(self):
-        with translation.override('de', deactivate=True):
+        with translation.override("de", deactivate=True):
             t = Template("{% load i18n %}{{ _('No') }}")
-        with translation.override('nl'):
-            self.assertEqual(t.render(Context({})), 'Nee')
+        with translation.override("nl"):
+            self.assertEqual(t.render(Context({})), "Nee")
 
     def test_multiple_locale_loadi18n_direct_switch(self):
-        with translation.override('de'):
+        with translation.override("de"):
             t = Template("{% load i18n %}{{ _('No') }}")
-        with translation.override('nl'):
-            self.assertEqual(t.render(Context({})), 'Nee')
+        with translation.override("nl"):
+            self.assertEqual(t.render(Context({})), "Nee")
 
 
 class I18nStringLiteralTests(SimpleTestCase):
     """translation of constant strings"""
-    libraries = {'i18n': 'django.templatetags.i18n'}
 
-    @setup({'i18n13': '{{ _("Password") }}'})
+    libraries = {"i18n": "django.templatetags.i18n"}
+
+    @setup({"i18n13": '{{ _("Password") }}'})
     def test_i18n13(self):
 
-        with translation.override('de'):
-            output = self.engine.render_to_string('i18n13')
-        self.assertEqual(output, 'Passwort')
+        with translation.override("de"):
+            output = self.engine.render_to_string("i18n13")
+        self.assertEqual(output, "Passwort")
 
-    @setup({'i18n14': '{% cycle "foo" _("Password") _(\'Password\') as c %} {% cycle c %} {% cycle c %}'})
+    @setup(
+        {
+            "i18n14": '{% cycle "foo" _("Password") _(\'Password\') as c %} {% cycle c %} {% cycle c %}'
+        }
+    )
     def test_i18n14(self):
-        with translation.override('de'):
-            output = self.engine.render_to_string('i18n14')
-        self.assertEqual(output, 'foo Passwort Passwort')
+        with translation.override("de"):
+            output = self.engine.render_to_string("i18n14")
+        self.assertEqual(output, "foo Passwort Passwort")
 
-    @setup({'i18n15': '{{ absent|default:_("Password") }}'})
+    @setup({"i18n15": '{{ absent|default:_("Password") }}'})
     def test_i18n15(self):
-        with translation.override('de'):
-            output = self.engine.render_to_string('i18n15', {'absent': ''})
-        self.assertEqual(output, 'Passwort')
+        with translation.override("de"):
+            output = self.engine.render_to_string("i18n15", {"absent": ""})
+        self.assertEqual(output, "Passwort")
 
-    @setup({'i18n16': '{{ _("<") }}'})
+    @setup({"i18n16": '{{ _("<") }}'})
     def test_i18n16(self):
-        with translation.override('de'):
-            output = self.engine.render_to_string('i18n16')
-        self.assertEqual(output, '<')
+        with translation.override("de"):
+            output = self.engine.render_to_string("i18n16")
+        self.assertEqual(output, "<")
diff --git a/tests/template_tests/syntax_tests/test_autoescape.py b/tests/template_tests/syntax_tests/test_autoescape.py
index 13968537a6..d3c5cb02da 100644
--- a/tests/template_tests/syntax_tests/test_autoescape.py
+++ b/tests/template_tests/syntax_tests/test_autoescape.py
@@ -6,72 +6,89 @@ from ..utils import SafeClass, UnsafeClass, setup
 
 
 class AutoescapeTagTests(SimpleTestCase):
-
-    @setup({'autoescape-tag01': '{% autoescape off %}hello{% endautoescape %}'})
+    @setup({"autoescape-tag01": "{% autoescape off %}hello{% endautoescape %}"})
     def test_autoescape_tag01(self):
-        output = self.engine.render_to_string('autoescape-tag01')
-        self.assertEqual(output, 'hello')
+        output = self.engine.render_to_string("autoescape-tag01")
+        self.assertEqual(output, "hello")
 
-    @setup({'autoescape-tag02': '{% autoescape off %}{{ first }}{% endautoescape %}'})
+    @setup({"autoescape-tag02": "{% autoescape off %}{{ first }}{% endautoescape %}"})
     def test_autoescape_tag02(self):
-        output = self.engine.render_to_string('autoescape-tag02', {'first': '<b>hello</b>'})
-        self.assertEqual(output, '<b>hello</b>')
+        output = self.engine.render_to_string(
+            "autoescape-tag02", {"first": "<b>hello</b>"}
+        )
+        self.assertEqual(output, "<b>hello</b>")
 
-    @setup({'autoescape-tag03': '{% autoescape on %}{{ first }}{% endautoescape %}'})
+    @setup({"autoescape-tag03": "{% autoescape on %}{{ first }}{% endautoescape %}"})
     def test_autoescape_tag03(self):
-        output = self.engine.render_to_string('autoescape-tag03', {'first': '<b>hello</b>'})
-        self.assertEqual(output, '&lt;b&gt;hello&lt;/b&gt;')
+        output = self.engine.render_to_string(
+            "autoescape-tag03", {"first": "<b>hello</b>"}
+        )
+        self.assertEqual(output, "&lt;b&gt;hello&lt;/b&gt;")
 
     # Autoescape disabling and enabling nest in a predictable way.
-    @setup({
-        'autoescape-tag04':
-        '{% autoescape off %}{{ first }} {% autoescape on %}{{ first }}{% endautoescape %}{% endautoescape %}'
-    })
+    @setup(
+        {
+            "autoescape-tag04": "{% autoescape off %}{{ first }} {% autoescape on %}{{ first }}{% endautoescape %}{% endautoescape %}"
+        }
+    )
     def test_autoescape_tag04(self):
-        output = self.engine.render_to_string('autoescape-tag04', {'first': '<a>'})
-        self.assertEqual(output, '<a> &lt;a&gt;')
+        output = self.engine.render_to_string("autoescape-tag04", {"first": "<a>"})
+        self.assertEqual(output, "<a> &lt;a&gt;")
 
-    @setup({'autoescape-tag05': '{% autoescape on %}{{ first }}{% endautoescape %}'})
+    @setup({"autoescape-tag05": "{% autoescape on %}{{ first }}{% endautoescape %}"})
     def test_autoescape_tag05(self):
-        output = self.engine.render_to_string('autoescape-tag05', {'first': '<b>first</b>'})
-        self.assertEqual(output, '&lt;b&gt;first&lt;/b&gt;')
+        output = self.engine.render_to_string(
+            "autoescape-tag05", {"first": "<b>first</b>"}
+        )
+        self.assertEqual(output, "&lt;b&gt;first&lt;/b&gt;")
 
     # Strings (ASCII or Unicode) already marked as "safe" are not
     # auto-escaped
-    @setup({'autoescape-tag06': '{{ first }}'})
+    @setup({"autoescape-tag06": "{{ first }}"})
     def test_autoescape_tag06(self):
-        output = self.engine.render_to_string('autoescape-tag06', {'first': mark_safe('<b>first</b>')})
-        self.assertEqual(output, '<b>first</b>')
+        output = self.engine.render_to_string(
+            "autoescape-tag06", {"first": mark_safe("<b>first</b>")}
+        )
+        self.assertEqual(output, "<b>first</b>")
 
-    @setup({'autoescape-tag07': '{% autoescape on %}{{ first }}{% endautoescape %}'})
+    @setup({"autoescape-tag07": "{% autoescape on %}{{ first }}{% endautoescape %}"})
     def test_autoescape_tag07(self):
-        output = self.engine.render_to_string('autoescape-tag07', {'first': mark_safe('<b>Apple</b>')})
-        self.assertEqual(output, '<b>Apple</b>')
+        output = self.engine.render_to_string(
+            "autoescape-tag07", {"first": mark_safe("<b>Apple</b>")}
+        )
+        self.assertEqual(output, "<b>Apple</b>")
 
-    @setup({
-        'autoescape-tag08':
-        r'{% autoescape on %}{{ var|default_if_none:" endquote\" hah" }}{% endautoescape %}'
-    })
+    @setup(
+        {
+            "autoescape-tag08": r'{% autoescape on %}{{ var|default_if_none:" endquote\" hah" }}{% endautoescape %}'
+        }
+    )
     def test_autoescape_tag08(self):
         """
         Literal string arguments to filters, if used in the result, are safe.
         """
-        output = self.engine.render_to_string('autoescape-tag08', {"var": None})
+        output = self.engine.render_to_string("autoescape-tag08", {"var": None})
         self.assertEqual(output, ' endquote" hah')
 
     # Objects which return safe strings as their __str__ method
     # won't get double-escaped.
-    @setup({'autoescape-tag09': r'{{ unsafe }}'})
+    @setup({"autoescape-tag09": r"{{ unsafe }}"})
     def test_autoescape_tag09(self):
-        output = self.engine.render_to_string('autoescape-tag09', {'unsafe': UnsafeClass()})
-        self.assertEqual(output, 'you &amp; me')
+        output = self.engine.render_to_string(
+            "autoescape-tag09", {"unsafe": UnsafeClass()}
+        )
+        self.assertEqual(output, "you &amp; me")
 
-    @setup({'autoescape-tag10': r'{{ safe }}'})
+    @setup({"autoescape-tag10": r"{{ safe }}"})
     def test_autoescape_tag10(self):
-        output = self.engine.render_to_string('autoescape-tag10', {'safe': SafeClass()})
-        self.assertEqual(output, 'you &gt; me')
+        output = self.engine.render_to_string("autoescape-tag10", {"safe": SafeClass()})
+        self.assertEqual(output, "you &gt; me")
 
-    @setup({'autoescape-filtertag01': '{{ first }}{% filter safe %}{{ first }} x<y{% endfilter %}'})
+    @setup(
+        {
+            "autoescape-filtertag01": "{{ first }}{% filter safe %}{{ first }} x<y{% endfilter %}"
+        }
+    )
     def test_autoescape_filtertag01(self):
         """
         The "safe" and "escape" filters cannot work due to internal
@@ -79,51 +96,69 @@ class AutoescapeTagTests(SimpleTestCase):
         tags can be used in those cases)
         """
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.render_to_string('autoescape-filtertag01', {'first': '<a>'})
+            self.engine.render_to_string("autoescape-filtertag01", {"first": "<a>"})
 
     # Arguments to filters are 'safe' and manipulate their input unescaped.
-    @setup({'autoescape-filters01': '{{ var|cut:"&" }}'})
+    @setup({"autoescape-filters01": '{{ var|cut:"&" }}'})
     def test_autoescape_filters01(self):
-        output = self.engine.render_to_string('autoescape-filters01', {'var': 'this & that'})
-        self.assertEqual(output, 'this  that')
+        output = self.engine.render_to_string(
+            "autoescape-filters01", {"var": "this & that"}
+        )
+        self.assertEqual(output, "this  that")
 
-    @setup({'autoescape-filters02': '{{ var|join:" & " }}'})
+    @setup({"autoescape-filters02": '{{ var|join:" & " }}'})
     def test_autoescape_filters02(self):
-        output = self.engine.render_to_string('autoescape-filters02', {'var': ('Tom', 'Dick', 'Harry')})
-        self.assertEqual(output, 'Tom & Dick & Harry')
+        output = self.engine.render_to_string(
+            "autoescape-filters02", {"var": ("Tom", "Dick", "Harry")}
+        )
+        self.assertEqual(output, "Tom & Dick & Harry")
 
-    @setup({'autoescape-literals01': '{{ "this & that" }}'})
+    @setup({"autoescape-literals01": '{{ "this & that" }}'})
     def test_autoescape_literals01(self):
         """
         Literal strings are safe.
         """
-        output = self.engine.render_to_string('autoescape-literals01')
-        self.assertEqual(output, 'this & that')
+        output = self.engine.render_to_string("autoescape-literals01")
+        self.assertEqual(output, "this & that")
 
-    @setup({'autoescape-stringiterations01': '{% for l in var %}{{ l }},{% endfor %}'})
+    @setup({"autoescape-stringiterations01": "{% for l in var %}{{ l }},{% endfor %}"})
     def test_autoescape_stringiterations01(self):
         """
         Iterating over strings outputs safe characters.
         """
-        output = self.engine.render_to_string('autoescape-stringiterations01', {'var': 'K&R'})
-        self.assertEqual(output, 'K,&amp;,R,')
+        output = self.engine.render_to_string(
+            "autoescape-stringiterations01", {"var": "K&R"}
+        )
+        self.assertEqual(output, "K,&amp;,R,")
 
-    @setup({'autoescape-lookup01': '{{ var.key }}'})
+    @setup({"autoescape-lookup01": "{{ var.key }}"})
     def test_autoescape_lookup01(self):
         """
         Escape requirement survives lookup.
         """
-        output = self.engine.render_to_string('autoescape-lookup01', {'var': {'key': 'this & that'}})
-        self.assertEqual(output, 'this &amp; that')
+        output = self.engine.render_to_string(
+            "autoescape-lookup01", {"var": {"key": "this & that"}}
+        )
+        self.assertEqual(output, "this &amp; that")
 
-    @setup({'autoescape-incorrect-arg': '{% autoescape true %}{{ var.key }}{% endautoescape %}'})
+    @setup(
+        {
+            "autoescape-incorrect-arg": "{% autoescape true %}{{ var.key }}{% endautoescape %}"
+        }
+    )
     def test_invalid_arg(self):
         msg = "'autoescape' argument should be 'on' or 'off'"
         with self.assertRaisesMessage(TemplateSyntaxError, msg):
-            self.engine.render_to_string('autoescape-incorrect-arg', {'var': {'key': 'this & that'}})
+            self.engine.render_to_string(
+                "autoescape-incorrect-arg", {"var": {"key": "this & that"}}
+            )
 
-    @setup({'autoescape-incorrect-arg': '{% autoescape %}{{ var.key }}{% endautoescape %}'})
+    @setup(
+        {"autoescape-incorrect-arg": "{% autoescape %}{{ var.key }}{% endautoescape %}"}
+    )
     def test_no_arg(self):
         msg = "'autoescape' tag requires exactly one argument."
         with self.assertRaisesMessage(TemplateSyntaxError, msg):
-            self.engine.render_to_string('autoescape-incorrect-arg', {'var': {'key': 'this & that'}})
+            self.engine.render_to_string(
+                "autoescape-incorrect-arg", {"var": {"key": "this & that"}}
+            )
diff --git a/tests/template_tests/syntax_tests/test_basic.py b/tests/template_tests/syntax_tests/test_basic.py
index 011ce51229..20bf30d55c 100644
--- a/tests/template_tests/syntax_tests/test_basic.py
+++ b/tests/template_tests/syntax_tests/test_basic.py
@@ -6,20 +6,19 @@ from django.test import SimpleTestCase
 from ..utils import SilentAttrClass, SilentGetItemClass, SomeClass, setup
 
 basic_templates = {
-    'basic-syntax01': 'something cool',
-    'basic-syntax02': '{{ headline }}',
-    'basic-syntax03': '{{ first }} --- {{ second }}',
+    "basic-syntax01": "something cool",
+    "basic-syntax02": "{{ headline }}",
+    "basic-syntax03": "{{ first }} --- {{ second }}",
 }
 
 
 class BasicSyntaxTests(SimpleTestCase):
-
     @setup(basic_templates)
     def test_basic_syntax01(self):
         """
         Plain text should go through the template parser untouched.
         """
-        output = self.engine.render_to_string('basic-syntax01')
+        output = self.engine.render_to_string("basic-syntax01")
         self.assertEqual(output, "something cool")
 
     @setup(basic_templates)
@@ -28,318 +27,330 @@ class BasicSyntaxTests(SimpleTestCase):
         Variables should be replaced with their value in the current
         context
         """
-        output = self.engine.render_to_string('basic-syntax02', {'headline': 'Success'})
-        self.assertEqual(output, 'Success')
+        output = self.engine.render_to_string("basic-syntax02", {"headline": "Success"})
+        self.assertEqual(output, "Success")
 
     @setup(basic_templates)
     def test_basic_syntax03(self):
         """
         More than one replacement variable is allowed in a template
         """
-        output = self.engine.render_to_string('basic-syntax03', {"first": 1, "second": 2})
-        self.assertEqual(output, '1 --- 2')
+        output = self.engine.render_to_string(
+            "basic-syntax03", {"first": 1, "second": 2}
+        )
+        self.assertEqual(output, "1 --- 2")
 
-    @setup({'basic-syntax04': 'as{{ missing }}df'})
+    @setup({"basic-syntax04": "as{{ missing }}df"})
     def test_basic_syntax04(self):
         """
         Fail silently when a variable is not found in the current context
         """
-        output = self.engine.render_to_string('basic-syntax04')
+        output = self.engine.render_to_string("basic-syntax04")
         if self.engine.string_if_invalid:
-            self.assertEqual(output, 'asINVALIDdf')
+            self.assertEqual(output, "asINVALIDdf")
         else:
-            self.assertEqual(output, 'asdf')
+            self.assertEqual(output, "asdf")
 
-    @setup({'basic-syntax06': '{{ multi word variable }}'})
+    @setup({"basic-syntax06": "{{ multi word variable }}"})
     def test_basic_syntax06(self):
         """
         A variable may not contain more than one word
         """
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('basic-syntax06')
+            self.engine.get_template("basic-syntax06")
 
-    @setup({'basic-syntax07': '{{ }}'})
+    @setup({"basic-syntax07": "{{ }}"})
     def test_basic_syntax07(self):
         """
         Raise TemplateSyntaxError for empty variable tags.
         """
-        with self.assertRaisesMessage(TemplateSyntaxError, 'Empty variable tag on line 1'):
-            self.engine.get_template('basic-syntax07')
+        with self.assertRaisesMessage(
+            TemplateSyntaxError, "Empty variable tag on line 1"
+        ):
+            self.engine.get_template("basic-syntax07")
 
-    @setup({'basic-syntax08': '{{        }}'})
+    @setup({"basic-syntax08": "{{        }}"})
     def test_basic_syntax08(self):
         """
         Raise TemplateSyntaxError for empty variable tags.
         """
-        with self.assertRaisesMessage(TemplateSyntaxError, 'Empty variable tag on line 1'):
-            self.engine.get_template('basic-syntax08')
+        with self.assertRaisesMessage(
+            TemplateSyntaxError, "Empty variable tag on line 1"
+        ):
+            self.engine.get_template("basic-syntax08")
 
-    @setup({'basic-syntax09': '{{ var.method }}'})
+    @setup({"basic-syntax09": "{{ var.method }}"})
     def test_basic_syntax09(self):
         """
         Attribute syntax allows a template to call an object's attribute
         """
-        output = self.engine.render_to_string('basic-syntax09', {'var': SomeClass()})
-        self.assertEqual(output, 'SomeClass.method')
+        output = self.engine.render_to_string("basic-syntax09", {"var": SomeClass()})
+        self.assertEqual(output, "SomeClass.method")
 
-    @setup({'basic-syntax10': '{{ var.otherclass.method }}'})
+    @setup({"basic-syntax10": "{{ var.otherclass.method }}"})
     def test_basic_syntax10(self):
         """
         Multiple levels of attribute access are allowed.
         """
-        output = self.engine.render_to_string('basic-syntax10', {'var': SomeClass()})
-        self.assertEqual(output, 'OtherClass.method')
+        output = self.engine.render_to_string("basic-syntax10", {"var": SomeClass()})
+        self.assertEqual(output, "OtherClass.method")
 
-    @setup({'basic-syntax11': '{{ var.blech }}'})
+    @setup({"basic-syntax11": "{{ var.blech }}"})
     def test_basic_syntax11(self):
         """
         Fail silently when a variable's attribute isn't found.
         """
-        output = self.engine.render_to_string('basic-syntax11', {'var': SomeClass()})
+        output = self.engine.render_to_string("basic-syntax11", {"var": SomeClass()})
 
         if self.engine.string_if_invalid:
-            self.assertEqual(output, 'INVALID')
+            self.assertEqual(output, "INVALID")
         else:
-            self.assertEqual(output, '')
+            self.assertEqual(output, "")
 
-    @setup({'basic-syntax12': '{{ var.__dict__ }}'})
+    @setup({"basic-syntax12": "{{ var.__dict__ }}"})
     def test_basic_syntax12(self):
         """
         Raise TemplateSyntaxError when trying to access a variable
         beginning with an underscore.
         """
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('basic-syntax12')
+            self.engine.get_template("basic-syntax12")
 
     # Raise TemplateSyntaxError when trying to access a variable
     # containing an illegal character.
-    @setup({'basic-syntax13': "{{ va>r }}"})
+    @setup({"basic-syntax13": "{{ va>r }}"})
     def test_basic_syntax13(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('basic-syntax13')
+            self.engine.get_template("basic-syntax13")
 
-    @setup({'basic-syntax14': "{{ (var.r) }}"})
+    @setup({"basic-syntax14": "{{ (var.r) }}"})
     def test_basic_syntax14(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('basic-syntax14')
+            self.engine.get_template("basic-syntax14")
 
-    @setup({'basic-syntax15': "{{ sp%am }}"})
+    @setup({"basic-syntax15": "{{ sp%am }}"})
     def test_basic_syntax15(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('basic-syntax15')
+            self.engine.get_template("basic-syntax15")
 
-    @setup({'basic-syntax16': "{{ eggs! }}"})
+    @setup({"basic-syntax16": "{{ eggs! }}"})
     def test_basic_syntax16(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('basic-syntax16')
+            self.engine.get_template("basic-syntax16")
 
-    @setup({'basic-syntax17': "{{ moo? }}"})
+    @setup({"basic-syntax17": "{{ moo? }}"})
     def test_basic_syntax17(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('basic-syntax17')
+            self.engine.get_template("basic-syntax17")
 
-    @setup({'basic-syntax18': "{{ foo.bar }}"})
+    @setup({"basic-syntax18": "{{ foo.bar }}"})
     def test_basic_syntax18(self):
         """
         Attribute syntax allows a template to call a dictionary key's
         value.
         """
-        output = self.engine.render_to_string('basic-syntax18', {"foo": {"bar": "baz"}})
+        output = self.engine.render_to_string("basic-syntax18", {"foo": {"bar": "baz"}})
         self.assertEqual(output, "baz")
 
-    @setup({'basic-syntax19': "{{ foo.spam }}"})
+    @setup({"basic-syntax19": "{{ foo.spam }}"})
     def test_basic_syntax19(self):
         """
         Fail silently when a variable's dictionary key isn't found.
         """
-        output = self.engine.render_to_string('basic-syntax19', {"foo": {"bar": "baz"}})
+        output = self.engine.render_to_string("basic-syntax19", {"foo": {"bar": "baz"}})
 
         if self.engine.string_if_invalid:
-            self.assertEqual(output, 'INVALID')
+            self.assertEqual(output, "INVALID")
         else:
-            self.assertEqual(output, '')
+            self.assertEqual(output, "")
 
-    @setup({'basic-syntax20': "{{ var.method2 }}"})
+    @setup({"basic-syntax20": "{{ var.method2 }}"})
     def test_basic_syntax20(self):
         """
         Fail silently when accessing a non-simple method
         """
-        output = self.engine.render_to_string('basic-syntax20', {'var': SomeClass()})
+        output = self.engine.render_to_string("basic-syntax20", {"var": SomeClass()})
 
         if self.engine.string_if_invalid:
-            self.assertEqual(output, 'INVALID')
+            self.assertEqual(output, "INVALID")
         else:
-            self.assertEqual(output, '')
+            self.assertEqual(output, "")
 
-    @setup({'basic-syntax20b': "{{ var.method5 }}"})
+    @setup({"basic-syntax20b": "{{ var.method5 }}"})
     def test_basic_syntax20b(self):
         """
         Don't silence a TypeError if it was raised inside a callable.
         """
-        template = self.engine.get_template('basic-syntax20b')
+        template = self.engine.get_template("basic-syntax20b")
 
         with self.assertRaises(TypeError):
-            template.render(Context({'var': SomeClass()}))
+            template.render(Context({"var": SomeClass()}))
 
     # Don't get confused when parsing something that is almost, but not
     # quite, a template tag.
-    @setup({'basic-syntax21': "a {{ moo %} b"})
+    @setup({"basic-syntax21": "a {{ moo %} b"})
     def test_basic_syntax21(self):
-        output = self.engine.render_to_string('basic-syntax21')
+        output = self.engine.render_to_string("basic-syntax21")
         self.assertEqual(output, "a {{ moo %} b")
 
-    @setup({'basic-syntax22': "{{ moo #}"})
+    @setup({"basic-syntax22": "{{ moo #}"})
     def test_basic_syntax22(self):
-        output = self.engine.render_to_string('basic-syntax22')
+        output = self.engine.render_to_string("basic-syntax22")
         self.assertEqual(output, "{{ moo #}")
 
-    @setup({'basic-syntax23': "{{ moo #} {{ cow }}"})
+    @setup({"basic-syntax23": "{{ moo #} {{ cow }}"})
     def test_basic_syntax23(self):
         """
         Treat "moo #} {{ cow" as the variable. Not ideal, but costly to work
         around, so this triggers an error.
         """
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('basic-syntax23')
+            self.engine.get_template("basic-syntax23")
 
-    @setup({'basic-syntax24': "{{ moo\n }}"})
+    @setup({"basic-syntax24": "{{ moo\n }}"})
     def test_basic_syntax24(self):
         """
         Embedded newlines make it not-a-tag.
         """
-        output = self.engine.render_to_string('basic-syntax24')
+        output = self.engine.render_to_string("basic-syntax24")
         self.assertEqual(output, "{{ moo\n }}")
 
     # Literal strings are permitted inside variables, mostly for i18n
     # purposes.
-    @setup({'basic-syntax25': '{{ "fred" }}'})
+    @setup({"basic-syntax25": '{{ "fred" }}'})
     def test_basic_syntax25(self):
-        output = self.engine.render_to_string('basic-syntax25')
+        output = self.engine.render_to_string("basic-syntax25")
         self.assertEqual(output, "fred")
 
-    @setup({'basic-syntax26': r'{{ "\"fred\"" }}'})
+    @setup({"basic-syntax26": r'{{ "\"fred\"" }}'})
     def test_basic_syntax26(self):
-        output = self.engine.render_to_string('basic-syntax26')
-        self.assertEqual(output, "\"fred\"")
+        output = self.engine.render_to_string("basic-syntax26")
+        self.assertEqual(output, '"fred"')
 
-    @setup({'basic-syntax27': r'{{ _("\"fred\"") }}'})
+    @setup({"basic-syntax27": r'{{ _("\"fred\"") }}'})
     def test_basic_syntax27(self):
-        output = self.engine.render_to_string('basic-syntax27')
-        self.assertEqual(output, "\"fred\"")
+        output = self.engine.render_to_string("basic-syntax27")
+        self.assertEqual(output, '"fred"')
 
     # #12554 -- Make sure a silent_variable_failure Exception is
     # suppressed on dictionary and attribute lookup.
-    @setup({'basic-syntax28': "{{ a.b }}"})
+    @setup({"basic-syntax28": "{{ a.b }}"})
     def test_basic_syntax28(self):
-        output = self.engine.render_to_string('basic-syntax28', {'a': SilentGetItemClass()})
+        output = self.engine.render_to_string(
+            "basic-syntax28", {"a": SilentGetItemClass()}
+        )
         if self.engine.string_if_invalid:
-            self.assertEqual(output, 'INVALID')
+            self.assertEqual(output, "INVALID")
         else:
-            self.assertEqual(output, '')
+            self.assertEqual(output, "")
 
-    @setup({'basic-syntax29': "{{ a.b }}"})
+    @setup({"basic-syntax29": "{{ a.b }}"})
     def test_basic_syntax29(self):
-        output = self.engine.render_to_string('basic-syntax29', {'a': SilentAttrClass()})
+        output = self.engine.render_to_string(
+            "basic-syntax29", {"a": SilentAttrClass()}
+        )
         if self.engine.string_if_invalid:
-            self.assertEqual(output, 'INVALID')
+            self.assertEqual(output, "INVALID")
         else:
-            self.assertEqual(output, '')
+            self.assertEqual(output, "")
 
     # Something that starts like a number but has an extra lookup works
     # as a lookup.
-    @setup({'basic-syntax30': "{{ 1.2.3 }}"})
+    @setup({"basic-syntax30": "{{ 1.2.3 }}"})
     def test_basic_syntax30(self):
         output = self.engine.render_to_string(
-            'basic-syntax30',
-            {"1": {"2": {"3": "d"}}}
+            "basic-syntax30", {"1": {"2": {"3": "d"}}}
         )
-        self.assertEqual(output, 'd')
+        self.assertEqual(output, "d")
 
-    @setup({'basic-syntax31': "{{ 1.2.3 }}"})
+    @setup({"basic-syntax31": "{{ 1.2.3 }}"})
     def test_basic_syntax31(self):
         output = self.engine.render_to_string(
-            'basic-syntax31',
+            "basic-syntax31",
             {"1": {"2": ("a", "b", "c", "d")}},
         )
-        self.assertEqual(output, 'd')
+        self.assertEqual(output, "d")
 
-    @setup({'basic-syntax32': "{{ 1.2.3 }}"})
+    @setup({"basic-syntax32": "{{ 1.2.3 }}"})
     def test_basic_syntax32(self):
         output = self.engine.render_to_string(
-            'basic-syntax32',
+            "basic-syntax32",
             {"1": (("x", "x", "x", "x"), ("y", "y", "y", "y"), ("a", "b", "c", "d"))},
         )
-        self.assertEqual(output, 'd')
+        self.assertEqual(output, "d")
 
-    @setup({'basic-syntax33': "{{ 1.2.3 }}"})
+    @setup({"basic-syntax33": "{{ 1.2.3 }}"})
     def test_basic_syntax33(self):
         output = self.engine.render_to_string(
-            'basic-syntax33',
+            "basic-syntax33",
             {"1": ("xxxx", "yyyy", "abcd")},
         )
-        self.assertEqual(output, 'd')
+        self.assertEqual(output, "d")
 
-    @setup({'basic-syntax34': "{{ 1.2.3 }}"})
+    @setup({"basic-syntax34": "{{ 1.2.3 }}"})
     def test_basic_syntax34(self):
         output = self.engine.render_to_string(
-            'basic-syntax34',
-            {"1": ({"x": "x"}, {"y": "y"}, {"z": "z", "3": "d"})}
+            "basic-syntax34", {"1": ({"x": "x"}, {"y": "y"}, {"z": "z", "3": "d"})}
         )
-        self.assertEqual(output, 'd')
+        self.assertEqual(output, "d")
 
     # Numbers are numbers even if their digits are in the context.
-    @setup({'basic-syntax35': "{{ 1 }}"})
+    @setup({"basic-syntax35": "{{ 1 }}"})
     def test_basic_syntax35(self):
-        output = self.engine.render_to_string('basic-syntax35', {"1": "abc"})
-        self.assertEqual(output, '1')
+        output = self.engine.render_to_string("basic-syntax35", {"1": "abc"})
+        self.assertEqual(output, "1")
 
-    @setup({'basic-syntax36': "{{ 1.2 }}"})
+    @setup({"basic-syntax36": "{{ 1.2 }}"})
     def test_basic_syntax36(self):
-        output = self.engine.render_to_string('basic-syntax36', {"1": "abc"})
-        self.assertEqual(output, '1.2')
+        output = self.engine.render_to_string("basic-syntax36", {"1": "abc"})
+        self.assertEqual(output, "1.2")
 
-    @setup({'basic-syntax37': '{{ callable }}'})
+    @setup({"basic-syntax37": "{{ callable }}"})
     def test_basic_syntax37(self):
         """
         Call methods in the top level of the context.
         """
-        output = self.engine.render_to_string('basic-syntax37', {"callable": lambda: "foo bar"})
-        self.assertEqual(output, 'foo bar')
+        output = self.engine.render_to_string(
+            "basic-syntax37", {"callable": lambda: "foo bar"}
+        )
+        self.assertEqual(output, "foo bar")
 
-    @setup({'basic-syntax38': '{{ var.callable }}'})
+    @setup({"basic-syntax38": "{{ var.callable }}"})
     def test_basic_syntax38(self):
         """
         Call methods returned from dictionary lookups.
         """
-        output = self.engine.render_to_string('basic-syntax38', {"var": {"callable": lambda: "foo bar"}})
-        self.assertEqual(output, 'foo bar')
+        output = self.engine.render_to_string(
+            "basic-syntax38", {"var": {"callable": lambda: "foo bar"}}
+        )
+        self.assertEqual(output, "foo bar")
 
-    @setup({'template': '{% block content %}'})
+    @setup({"template": "{% block content %}"})
     def test_unclosed_block(self):
         msg = "Unclosed tag on line 1: 'block'. Looking for one of: endblock."
         with self.assertRaisesMessage(TemplateSyntaxError, msg):
-            self.engine.render_to_string('template')
+            self.engine.render_to_string("template")
 
-    @setup({'template': '{% if a %}'})
+    @setup({"template": "{% if a %}"})
     def test_unclosed_block2(self):
         msg = "Unclosed tag on line 1: 'if'. Looking for one of: elif, else, endif."
         with self.assertRaisesMessage(TemplateSyntaxError, msg):
-            self.engine.render_to_string('template')
+            self.engine.render_to_string("template")
 
-    @setup({'tpl-str': '%s', 'tpl-percent': '%%', 'tpl-weird-percent': '% %s'})
+    @setup({"tpl-str": "%s", "tpl-percent": "%%", "tpl-weird-percent": "% %s"})
     def test_ignores_strings_that_look_like_format_interpolation(self):
-        output = self.engine.render_to_string('tpl-str')
-        self.assertEqual(output, '%s')
-        output = self.engine.render_to_string('tpl-percent')
-        self.assertEqual(output, '%%')
-        output = self.engine.render_to_string('tpl-weird-percent')
-        self.assertEqual(output, '% %s')
+        output = self.engine.render_to_string("tpl-str")
+        self.assertEqual(output, "%s")
+        output = self.engine.render_to_string("tpl-percent")
+        self.assertEqual(output, "%%")
+        output = self.engine.render_to_string("tpl-weird-percent")
+        self.assertEqual(output, "% %s")
 
 
 class BlockContextTests(SimpleTestCase):
     def test_repr(self):
         block_context = BlockContext()
-        block_context.add_blocks({'content': BlockNode('content', [])})
+        block_context.add_blocks({"content": BlockNode("content", [])})
         self.assertEqual(
             repr(block_context),
             "<BlockContext: blocks=defaultdict(<class 'list'>, "
diff --git a/tests/template_tests/syntax_tests/test_builtins.py b/tests/template_tests/syntax_tests/test_builtins.py
index 8ade96c65a..6e81410556 100644
--- a/tests/template_tests/syntax_tests/test_builtins.py
+++ b/tests/template_tests/syntax_tests/test_builtins.py
@@ -4,18 +4,17 @@ from ..utils import setup
 
 
 class BuiltinsTests(SimpleTestCase):
-
-    @setup({'builtins01': '{{ True }}'})
+    @setup({"builtins01": "{{ True }}"})
     def test_builtins01(self):
-        output = self.engine.render_to_string('builtins01')
-        self.assertEqual(output, 'True')
+        output = self.engine.render_to_string("builtins01")
+        self.assertEqual(output, "True")
 
-    @setup({'builtins02': '{{ False }}'})
+    @setup({"builtins02": "{{ False }}"})
     def test_builtins02(self):
-        output = self.engine.render_to_string('builtins02')
-        self.assertEqual(output, 'False')
+        output = self.engine.render_to_string("builtins02")
+        self.assertEqual(output, "False")
 
-    @setup({'builtins03': '{{ None }}'})
+    @setup({"builtins03": "{{ None }}"})
     def test_builtins03(self):
-        output = self.engine.render_to_string('builtins03')
-        self.assertEqual(output, 'None')
+        output = self.engine.render_to_string("builtins03")
+        self.assertEqual(output, "None")
diff --git a/tests/template_tests/syntax_tests/test_cache.py b/tests/template_tests/syntax_tests/test_cache.py
index 80af1c2bd6..a722420637 100644
--- a/tests/template_tests/syntax_tests/test_cache.py
+++ b/tests/template_tests/syntax_tests/test_cache.py
@@ -7,176 +7,203 @@ from ..utils import setup
 
 class CacheTagTests(SimpleTestCase):
     libraries = {
-        'cache': 'django.templatetags.cache',
-        'custom': 'template_tests.templatetags.custom',
+        "cache": "django.templatetags.cache",
+        "custom": "template_tests.templatetags.custom",
     }
 
     def tearDown(self):
         cache.clear()
 
-    @setup({'cache03': '{% load cache %}{% cache 2 test %}cache03{% endcache %}'})
+    @setup({"cache03": "{% load cache %}{% cache 2 test %}cache03{% endcache %}"})
     def test_cache03(self):
-        output = self.engine.render_to_string('cache03')
-        self.assertEqual(output, 'cache03')
+        output = self.engine.render_to_string("cache03")
+        self.assertEqual(output, "cache03")
 
-    @setup({
-        'cache03': '{% load cache %}{% cache 2 test %}cache03{% endcache %}',
-        'cache04': '{% load cache %}{% cache 2 test %}cache04{% endcache %}',
-    })
+    @setup(
+        {
+            "cache03": "{% load cache %}{% cache 2 test %}cache03{% endcache %}",
+            "cache04": "{% load cache %}{% cache 2 test %}cache04{% endcache %}",
+        }
+    )
     def test_cache04(self):
-        self.engine.render_to_string('cache03')
-        output = self.engine.render_to_string('cache04')
-        self.assertEqual(output, 'cache03')
+        self.engine.render_to_string("cache03")
+        output = self.engine.render_to_string("cache04")
+        self.assertEqual(output, "cache03")
 
-    @setup({'cache05': '{% load cache %}{% cache 2 test foo %}cache05{% endcache %}'})
+    @setup({"cache05": "{% load cache %}{% cache 2 test foo %}cache05{% endcache %}"})
     def test_cache05(self):
-        output = self.engine.render_to_string('cache05', {'foo': 1})
-        self.assertEqual(output, 'cache05')
+        output = self.engine.render_to_string("cache05", {"foo": 1})
+        self.assertEqual(output, "cache05")
 
-    @setup({'cache06': '{% load cache %}{% cache 2 test foo %}cache06{% endcache %}'})
+    @setup({"cache06": "{% load cache %}{% cache 2 test foo %}cache06{% endcache %}"})
     def test_cache06(self):
-        output = self.engine.render_to_string('cache06', {'foo': 2})
-        self.assertEqual(output, 'cache06')
+        output = self.engine.render_to_string("cache06", {"foo": 2})
+        self.assertEqual(output, "cache06")
 
-    @setup({
-        'cache05': '{% load cache %}{% cache 2 test foo %}cache05{% endcache %}',
-        'cache07': '{% load cache %}{% cache 2 test foo %}cache07{% endcache %}',
-    })
+    @setup(
+        {
+            "cache05": "{% load cache %}{% cache 2 test foo %}cache05{% endcache %}",
+            "cache07": "{% load cache %}{% cache 2 test foo %}cache07{% endcache %}",
+        }
+    )
     def test_cache07(self):
-        context = {'foo': 1}
-        self.engine.render_to_string('cache05', context)
-        output = self.engine.render_to_string('cache07', context)
-        self.assertEqual(output, 'cache05')
+        context = {"foo": 1}
+        self.engine.render_to_string("cache05", context)
+        output = self.engine.render_to_string("cache07", context)
+        self.assertEqual(output, "cache05")
 
-    @setup({
-        'cache06': '{% load cache %}{% cache 2 test foo %}cache06{% endcache %}',
-        'cache08': '{% load cache %}{% cache time test foo %}cache08{% endcache %}',
-    })
+    @setup(
+        {
+            "cache06": "{% load cache %}{% cache 2 test foo %}cache06{% endcache %}",
+            "cache08": "{% load cache %}{% cache time test foo %}cache08{% endcache %}",
+        }
+    )
     def test_cache08(self):
         """
         Allow first argument to be a variable.
         """
-        context = {'foo': 2, 'time': 2}
-        self.engine.render_to_string('cache06', context)
-        output = self.engine.render_to_string('cache08', context)
-        self.assertEqual(output, 'cache06')
+        context = {"foo": 2, "time": 2}
+        self.engine.render_to_string("cache06", context)
+        output = self.engine.render_to_string("cache08", context)
+        self.assertEqual(output, "cache06")
 
     # Raise exception if we don't have at least 2 args, first one integer.
-    @setup({'cache11': '{% load cache %}{% cache %}{% endcache %}'})
+    @setup({"cache11": "{% load cache %}{% cache %}{% endcache %}"})
     def test_cache11(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('cache11')
+            self.engine.get_template("cache11")
 
-    @setup({'cache12': '{% load cache %}{% cache 1 %}{% endcache %}'})
+    @setup({"cache12": "{% load cache %}{% cache 1 %}{% endcache %}"})
     def test_cache12(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('cache12')
+            self.engine.get_template("cache12")
 
-    @setup({'cache13': '{% load cache %}{% cache foo bar %}{% endcache %}'})
+    @setup({"cache13": "{% load cache %}{% cache foo bar %}{% endcache %}"})
     def test_cache13(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.render_to_string('cache13')
+            self.engine.render_to_string("cache13")
 
-    @setup({'cache14': '{% load cache %}{% cache foo bar %}{% endcache %}'})
+    @setup({"cache14": "{% load cache %}{% cache foo bar %}{% endcache %}"})
     def test_cache14(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.render_to_string('cache14', {'foo': 'fail'})
+            self.engine.render_to_string("cache14", {"foo": "fail"})
 
-    @setup({'cache15': '{% load cache %}{% cache foo bar %}{% endcache %}'})
+    @setup({"cache15": "{% load cache %}{% cache foo bar %}{% endcache %}"})
     def test_cache15(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.render_to_string('cache15', {'foo': []})
+            self.engine.render_to_string("cache15", {"foo": []})
 
-    @setup({'cache16': '{% load cache %}{% cache 1 foo bar %}{% endcache %}'})
+    @setup({"cache16": "{% load cache %}{% cache 1 foo bar %}{% endcache %}"})
     def test_cache16(self):
         """
         Regression test for #7460.
         """
-        output = self.engine.render_to_string('cache16', {'foo': 'foo', 'bar': 'with spaces'})
-        self.assertEqual(output, '')
+        output = self.engine.render_to_string(
+            "cache16", {"foo": "foo", "bar": "with spaces"}
+        )
+        self.assertEqual(output, "")
 
-    @setup({'cache17': '{% load cache %}{% cache 10 long_cache_key poem %}Some Content{% endcache %}'})
+    @setup(
+        {
+            "cache17": "{% load cache %}{% cache 10 long_cache_key poem %}Some Content{% endcache %}"
+        }
+    )
     def test_cache17(self):
         """
         Regression test for #11270.
         """
         output = self.engine.render_to_string(
-            'cache17',
+            "cache17",
             {
-                'poem': (
-                    'Oh freddled gruntbuggly/Thy micturations are to me/'
-                    'As plurdled gabbleblotchits/On a lurgid bee/'
-                    'That mordiously hath bitled out/Its earted jurtles/'
-                    'Into a rancid festering/Or else I shall rend thee in the gobberwarts'
-                    'with my blurglecruncheon/See if I don\'t.'
+                "poem": (
+                    "Oh freddled gruntbuggly/Thy micturations are to me/"
+                    "As plurdled gabbleblotchits/On a lurgid bee/"
+                    "That mordiously hath bitled out/Its earted jurtles/"
+                    "Into a rancid festering/Or else I shall rend thee in the gobberwarts"
+                    "with my blurglecruncheon/See if I don't."
                 ),
-            }
+            },
         )
-        self.assertEqual(output, 'Some Content')
+        self.assertEqual(output, "Some Content")
 
-    @setup({'cache18': '{% load cache custom %}{% cache 2|noop:"x y" cache18 %}cache18{% endcache %}'})
+    @setup(
+        {
+            "cache18": '{% load cache custom %}{% cache 2|noop:"x y" cache18 %}cache18{% endcache %}'
+        }
+    )
     def test_cache18(self):
         """
         Test whitespace in filter arguments
         """
-        output = self.engine.render_to_string('cache18')
-        self.assertEqual(output, 'cache18')
+        output = self.engine.render_to_string("cache18")
+        self.assertEqual(output, "cache18")
 
-    @setup({
-        'first': '{% load cache %}{% cache None fragment19 %}content{% endcache %}',
-        'second': '{% load cache %}{% cache None fragment19 %}not rendered{% endcache %}'
-    })
+    @setup(
+        {
+            "first": "{% load cache %}{% cache None fragment19 %}content{% endcache %}",
+            "second": "{% load cache %}{% cache None fragment19 %}not rendered{% endcache %}",
+        }
+    )
     def test_none_timeout(self):
         """A timeout of None means "cache forever"."""
-        output = self.engine.render_to_string('first')
-        self.assertEqual(output, 'content')
-        output = self.engine.render_to_string('second')
-        self.assertEqual(output, 'content')
+        output = self.engine.render_to_string("first")
+        self.assertEqual(output, "content")
+        output = self.engine.render_to_string("second")
+        self.assertEqual(output, "content")
 
 
 class CacheTests(SimpleTestCase):
-
     @classmethod
     def setUpClass(cls):
-        cls.engine = Engine(libraries={'cache': 'django.templatetags.cache'})
+        cls.engine = Engine(libraries={"cache": "django.templatetags.cache"})
         super().setUpClass()
 
     def test_cache_regression_20130(self):
-        t = self.engine.from_string('{% load cache %}{% cache 1 regression_20130 %}foo{% endcache %}')
+        t = self.engine.from_string(
+            "{% load cache %}{% cache 1 regression_20130 %}foo{% endcache %}"
+        )
         cachenode = t.nodelist[1]
-        self.assertEqual(cachenode.fragment_name, 'regression_20130')
+        self.assertEqual(cachenode.fragment_name, "regression_20130")
 
-    @override_settings(CACHES={
-        'default': {
-            'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
-            'LOCATION': 'default',
-        },
-        'template_fragments': {
-            'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
-            'LOCATION': 'fragments',
-        },
-    })
+    @override_settings(
+        CACHES={
+            "default": {
+                "BACKEND": "django.core.cache.backends.locmem.LocMemCache",
+                "LOCATION": "default",
+            },
+            "template_fragments": {
+                "BACKEND": "django.core.cache.backends.locmem.LocMemCache",
+                "LOCATION": "fragments",
+            },
+        }
+    )
     def test_cache_fragment_cache(self):
         """
         When a cache called "template_fragments" is present, the cache tag
         will use it in preference to 'default'
         """
-        t1 = self.engine.from_string('{% load cache %}{% cache 1 fragment %}foo{% endcache %}')
-        t2 = self.engine.from_string('{% load cache %}{% cache 1 fragment using="default" %}bar{% endcache %}')
+        t1 = self.engine.from_string(
+            "{% load cache %}{% cache 1 fragment %}foo{% endcache %}"
+        )
+        t2 = self.engine.from_string(
+            '{% load cache %}{% cache 1 fragment using="default" %}bar{% endcache %}'
+        )
 
         ctx = Context()
         o1 = t1.render(ctx)
         o2 = t2.render(ctx)
 
-        self.assertEqual(o1, 'foo')
-        self.assertEqual(o2, 'bar')
+        self.assertEqual(o1, "foo")
+        self.assertEqual(o2, "bar")
 
     def test_cache_missing_backend(self):
         """
         When a cache that doesn't exist is specified, the cache tag will
         raise a TemplateSyntaxError
         '"""
-        t = self.engine.from_string('{% load cache %}{% cache 1 backend using="unknown" %}bar{% endcache %}')
+        t = self.engine.from_string(
+            '{% load cache %}{% cache 1 backend using="unknown" %}bar{% endcache %}'
+        )
 
         ctx = Context()
         with self.assertRaises(TemplateSyntaxError):
diff --git a/tests/template_tests/syntax_tests/test_comment.py b/tests/template_tests/syntax_tests/test_comment.py
index d1b4dcf147..58dbe88b36 100644
--- a/tests/template_tests/syntax_tests/test_comment.py
+++ b/tests/template_tests/syntax_tests/test_comment.py
@@ -4,89 +4,92 @@ from ..utils import setup
 
 
 class CommentSyntaxTests(SimpleTestCase):
-
-    @setup({'comment-syntax01': '{# this is hidden #}hello'})
+    @setup({"comment-syntax01": "{# this is hidden #}hello"})
     def test_comment_syntax01(self):
-        output = self.engine.render_to_string('comment-syntax01')
-        self.assertEqual(output, 'hello')
+        output = self.engine.render_to_string("comment-syntax01")
+        self.assertEqual(output, "hello")
 
-    @setup({'comment-syntax02': '{# this is hidden #}hello{# foo #}'})
+    @setup({"comment-syntax02": "{# this is hidden #}hello{# foo #}"})
     def test_comment_syntax02(self):
-        output = self.engine.render_to_string('comment-syntax02')
-        self.assertEqual(output, 'hello')
+        output = self.engine.render_to_string("comment-syntax02")
+        self.assertEqual(output, "hello")
 
-    @setup({'comment-syntax03': 'foo{#  {% if %}  #}'})
+    @setup({"comment-syntax03": "foo{#  {% if %}  #}"})
     def test_comment_syntax03(self):
-        output = self.engine.render_to_string('comment-syntax03')
-        self.assertEqual(output, 'foo')
+        output = self.engine.render_to_string("comment-syntax03")
+        self.assertEqual(output, "foo")
 
-    @setup({'comment-syntax04': 'foo{#  {% endblock %}  #}'})
+    @setup({"comment-syntax04": "foo{#  {% endblock %}  #}"})
     def test_comment_syntax04(self):
-        output = self.engine.render_to_string('comment-syntax04')
-        self.assertEqual(output, 'foo')
+        output = self.engine.render_to_string("comment-syntax04")
+        self.assertEqual(output, "foo")
 
-    @setup({'comment-syntax05': 'foo{#  {% somerandomtag %}  #}'})
+    @setup({"comment-syntax05": "foo{#  {% somerandomtag %}  #}"})
     def test_comment_syntax05(self):
-        output = self.engine.render_to_string('comment-syntax05')
-        self.assertEqual(output, 'foo')
+        output = self.engine.render_to_string("comment-syntax05")
+        self.assertEqual(output, "foo")
 
-    @setup({'comment-syntax06': 'foo{# {% #}'})
+    @setup({"comment-syntax06": "foo{# {% #}"})
     def test_comment_syntax06(self):
-        output = self.engine.render_to_string('comment-syntax06')
-        self.assertEqual(output, 'foo')
+        output = self.engine.render_to_string("comment-syntax06")
+        self.assertEqual(output, "foo")
 
-    @setup({'comment-syntax07': 'foo{# %} #}'})
+    @setup({"comment-syntax07": "foo{# %} #}"})
     def test_comment_syntax07(self):
-        output = self.engine.render_to_string('comment-syntax07')
-        self.assertEqual(output, 'foo')
+        output = self.engine.render_to_string("comment-syntax07")
+        self.assertEqual(output, "foo")
 
-    @setup({'comment-syntax08': 'foo{# %} #}bar'})
+    @setup({"comment-syntax08": "foo{# %} #}bar"})
     def test_comment_syntax08(self):
-        output = self.engine.render_to_string('comment-syntax08')
-        self.assertEqual(output, 'foobar')
+        output = self.engine.render_to_string("comment-syntax08")
+        self.assertEqual(output, "foobar")
 
-    @setup({'comment-syntax09': 'foo{# {{ #}'})
+    @setup({"comment-syntax09": "foo{# {{ #}"})
     def test_comment_syntax09(self):
-        output = self.engine.render_to_string('comment-syntax09')
-        self.assertEqual(output, 'foo')
+        output = self.engine.render_to_string("comment-syntax09")
+        self.assertEqual(output, "foo")
 
-    @setup({'comment-syntax10': 'foo{# }} #}'})
+    @setup({"comment-syntax10": "foo{# }} #}"})
     def test_comment_syntax10(self):
-        output = self.engine.render_to_string('comment-syntax10')
-        self.assertEqual(output, 'foo')
+        output = self.engine.render_to_string("comment-syntax10")
+        self.assertEqual(output, "foo")
 
-    @setup({'comment-syntax11': 'foo{# { #}'})
+    @setup({"comment-syntax11": "foo{# { #}"})
     def test_comment_syntax11(self):
-        output = self.engine.render_to_string('comment-syntax11')
-        self.assertEqual(output, 'foo')
+        output = self.engine.render_to_string("comment-syntax11")
+        self.assertEqual(output, "foo")
 
-    @setup({'comment-syntax12': 'foo{# } #}'})
+    @setup({"comment-syntax12": "foo{# } #}"})
     def test_comment_syntax12(self):
-        output = self.engine.render_to_string('comment-syntax12')
-        self.assertEqual(output, 'foo')
+        output = self.engine.render_to_string("comment-syntax12")
+        self.assertEqual(output, "foo")
 
-    @setup({'comment-tag01': '{% comment %}this is hidden{% endcomment %}hello'})
+    @setup({"comment-tag01": "{% comment %}this is hidden{% endcomment %}hello"})
     def test_comment_tag01(self):
-        output = self.engine.render_to_string('comment-tag01')
-        self.assertEqual(output, 'hello')
+        output = self.engine.render_to_string("comment-tag01")
+        self.assertEqual(output, "hello")
 
-    @setup({'comment-tag02': '{% comment %}this is hidden{% endcomment %}'
-                             'hello{% comment %}foo{% endcomment %}'})
+    @setup(
+        {
+            "comment-tag02": "{% comment %}this is hidden{% endcomment %}"
+            "hello{% comment %}foo{% endcomment %}"
+        }
+    )
     def test_comment_tag02(self):
-        output = self.engine.render_to_string('comment-tag02')
-        self.assertEqual(output, 'hello')
+        output = self.engine.render_to_string("comment-tag02")
+        self.assertEqual(output, "hello")
 
-    @setup({'comment-tag03': 'foo{% comment %} {% if %} {% endcomment %}'})
+    @setup({"comment-tag03": "foo{% comment %} {% if %} {% endcomment %}"})
     def test_comment_tag03(self):
-        output = self.engine.render_to_string('comment-tag03')
-        self.assertEqual(output, 'foo')
+        output = self.engine.render_to_string("comment-tag03")
+        self.assertEqual(output, "foo")
 
-    @setup({'comment-tag04': 'foo{% comment %} {% endblock %} {% endcomment %}'})
+    @setup({"comment-tag04": "foo{% comment %} {% endblock %} {% endcomment %}"})
     def test_comment_tag04(self):
-        output = self.engine.render_to_string('comment-tag04')
-        self.assertEqual(output, 'foo')
+        output = self.engine.render_to_string("comment-tag04")
+        self.assertEqual(output, "foo")
 
-    @setup({'comment-tag05': 'foo{% comment %} {% somerandomtag %} {% endcomment %}'})
+    @setup({"comment-tag05": "foo{% comment %} {% somerandomtag %} {% endcomment %}"})
     def test_comment_tag05(self):
-        output = self.engine.render_to_string('comment-tag05')
-        self.assertEqual(output, 'foo')
+        output = self.engine.render_to_string("comment-tag05")
+        self.assertEqual(output, "foo")
diff --git a/tests/template_tests/syntax_tests/test_cycle.py b/tests/template_tests/syntax_tests/test_cycle.py
index 12bf66e117..d4233fac3e 100644
--- a/tests/template_tests/syntax_tests/test_cycle.py
+++ b/tests/template_tests/syntax_tests/test_cycle.py
@@ -5,175 +5,214 @@ from ..utils import setup
 
 
 class CycleTagTests(SimpleTestCase):
-
-    @setup({'cycle01': '{% cycle a %}'})
+    @setup({"cycle01": "{% cycle a %}"})
     def test_cycle01(self):
         msg = "No named cycles in template. 'a' is not defined"
         with self.assertRaisesMessage(TemplateSyntaxError, msg):
-            self.engine.get_template('cycle01')
+            self.engine.get_template("cycle01")
 
-    @setup({'cycle05': '{% cycle %}'})
+    @setup({"cycle05": "{% cycle %}"})
     def test_cycle05(self):
         msg = "'cycle' tag requires at least two arguments"
         with self.assertRaisesMessage(TemplateSyntaxError, msg):
-            self.engine.get_template('cycle05')
+            self.engine.get_template("cycle05")
 
-    @setup({'cycle07': '{% cycle a,b,c as foo %}{% cycle bar %}'})
+    @setup({"cycle07": "{% cycle a,b,c as foo %}{% cycle bar %}"})
     def test_cycle07(self):
         msg = "Could not parse the remainder: ',b,c' from 'a,b,c'"
         with self.assertRaisesMessage(TemplateSyntaxError, msg):
-            self.engine.get_template('cycle07')
+            self.engine.get_template("cycle07")
 
-    @setup({'cycle10': "{% cycle 'a' 'b' 'c' as abc %}{% cycle abc %}"})
+    @setup({"cycle10": "{% cycle 'a' 'b' 'c' as abc %}{% cycle abc %}"})
     def test_cycle10(self):
-        output = self.engine.render_to_string('cycle10')
-        self.assertEqual(output, 'ab')
+        output = self.engine.render_to_string("cycle10")
+        self.assertEqual(output, "ab")
 
-    @setup({'cycle11': "{% cycle 'a' 'b' 'c' as abc %}{% cycle abc %}{% cycle abc %}"})
+    @setup({"cycle11": "{% cycle 'a' 'b' 'c' as abc %}{% cycle abc %}{% cycle abc %}"})
     def test_cycle11(self):
-        output = self.engine.render_to_string('cycle11')
-        self.assertEqual(output, 'abc')
+        output = self.engine.render_to_string("cycle11")
+        self.assertEqual(output, "abc")
 
-    @setup({'cycle12': "{% cycle 'a' 'b' 'c' as abc %}{% cycle abc %}{% cycle abc %}{% cycle abc %}"})
+    @setup(
+        {
+            "cycle12": "{% cycle 'a' 'b' 'c' as abc %}{% cycle abc %}{% cycle abc %}{% cycle abc %}"
+        }
+    )
     def test_cycle12(self):
-        output = self.engine.render_to_string('cycle12')
-        self.assertEqual(output, 'abca')
+        output = self.engine.render_to_string("cycle12")
+        self.assertEqual(output, "abca")
 
-    @setup({'cycle13': "{% for i in test %}{% cycle 'a' 'b' %}{{ i }},{% endfor %}"})
+    @setup({"cycle13": "{% for i in test %}{% cycle 'a' 'b' %}{{ i }},{% endfor %}"})
     def test_cycle13(self):
-        output = self.engine.render_to_string('cycle13', {'test': list(range(5))})
-        self.assertEqual(output, 'a0,b1,a2,b3,a4,')
+        output = self.engine.render_to_string("cycle13", {"test": list(range(5))})
+        self.assertEqual(output, "a0,b1,a2,b3,a4,")
 
-    @setup({'cycle14': '{% cycle one two as foo %}{% cycle foo %}'})
+    @setup({"cycle14": "{% cycle one two as foo %}{% cycle foo %}"})
     def test_cycle14(self):
-        output = self.engine.render_to_string('cycle14', {'one': '1', 'two': '2'})
-        self.assertEqual(output, '12')
+        output = self.engine.render_to_string("cycle14", {"one": "1", "two": "2"})
+        self.assertEqual(output, "12")
 
-    @setup({'cycle15': '{% for i in test %}{% cycle aye bee %}{{ i }},{% endfor %}'})
+    @setup({"cycle15": "{% for i in test %}{% cycle aye bee %}{{ i }},{% endfor %}"})
     def test_cycle15(self):
-        output = self.engine.render_to_string('cycle15', {'test': list(range(5)), 'aye': 'a', 'bee': 'b'})
-        self.assertEqual(output, 'a0,b1,a2,b3,a4,')
+        output = self.engine.render_to_string(
+            "cycle15", {"test": list(range(5)), "aye": "a", "bee": "b"}
+        )
+        self.assertEqual(output, "a0,b1,a2,b3,a4,")
 
-    @setup({'cycle16': '{% cycle one|lower two as foo %}{% cycle foo %}'})
+    @setup({"cycle16": "{% cycle one|lower two as foo %}{% cycle foo %}"})
     def test_cycle16(self):
-        output = self.engine.render_to_string('cycle16', {'one': 'A', 'two': '2'})
-        self.assertEqual(output, 'a2')
+        output = self.engine.render_to_string("cycle16", {"one": "A", "two": "2"})
+        self.assertEqual(output, "a2")
 
-    @setup({'cycle17': "{% cycle 'a' 'b' 'c' as abc silent %}"
-                       "{% cycle abc %}{% cycle abc %}{% cycle abc %}{% cycle abc %}"})
+    @setup(
+        {
+            "cycle17": "{% cycle 'a' 'b' 'c' as abc silent %}"
+            "{% cycle abc %}{% cycle abc %}{% cycle abc %}{% cycle abc %}"
+        }
+    )
     def test_cycle17(self):
-        output = self.engine.render_to_string('cycle17')
-        self.assertEqual(output, '')
+        output = self.engine.render_to_string("cycle17")
+        self.assertEqual(output, "")
 
-    @setup({'cycle18': "{% cycle 'a' 'b' 'c' as foo invalid_flag %}"})
+    @setup({"cycle18": "{% cycle 'a' 'b' 'c' as foo invalid_flag %}"})
     def test_cycle18(self):
         msg = "Only 'silent' flag is allowed after cycle's name, not 'invalid_flag'."
         with self.assertRaisesMessage(TemplateSyntaxError, msg):
-            self.engine.get_template('cycle18')
+            self.engine.get_template("cycle18")
 
-    @setup({'cycle19': "{% cycle 'a' 'b' as silent %}{% cycle silent %}"})
+    @setup({"cycle19": "{% cycle 'a' 'b' as silent %}{% cycle silent %}"})
     def test_cycle19(self):
-        output = self.engine.render_to_string('cycle19')
-        self.assertEqual(output, 'ab')
+        output = self.engine.render_to_string("cycle19")
+        self.assertEqual(output, "ab")
 
-    @setup({'cycle20': '{% cycle one two as foo %} &amp; {% cycle foo %}'})
+    @setup({"cycle20": "{% cycle one two as foo %} &amp; {% cycle foo %}"})
     def test_cycle20(self):
-        output = self.engine.render_to_string('cycle20', {'two': 'C & D', 'one': 'A & B'})
-        self.assertEqual(output, 'A &amp; B &amp; C &amp; D')
+        output = self.engine.render_to_string(
+            "cycle20", {"two": "C & D", "one": "A & B"}
+        )
+        self.assertEqual(output, "A &amp; B &amp; C &amp; D")
 
-    @setup({'cycle21': '{% filter force_escape %}'
-                       '{% cycle one two as foo %} & {% cycle foo %}{% endfilter %}'})
+    @setup(
+        {
+            "cycle21": "{% filter force_escape %}"
+            "{% cycle one two as foo %} & {% cycle foo %}{% endfilter %}"
+        }
+    )
     def test_cycle21(self):
-        output = self.engine.render_to_string('cycle21', {'two': 'C & D', 'one': 'A & B'})
-        self.assertEqual(output, 'A &amp;amp; B &amp; C &amp;amp; D')
+        output = self.engine.render_to_string(
+            "cycle21", {"two": "C & D", "one": "A & B"}
+        )
+        self.assertEqual(output, "A &amp;amp; B &amp; C &amp;amp; D")
 
-    @setup({'cycle22': "{% for x in values %}{% cycle 'a' 'b' 'c' as abc silent %}{{ x }}{% endfor %}"})
+    @setup(
+        {
+            "cycle22": "{% for x in values %}{% cycle 'a' 'b' 'c' as abc silent %}{{ x }}{% endfor %}"
+        }
+    )
     def test_cycle22(self):
-        output = self.engine.render_to_string('cycle22', {'values': [1, 2, 3, 4]})
-        self.assertEqual(output, '1234')
+        output = self.engine.render_to_string("cycle22", {"values": [1, 2, 3, 4]})
+        self.assertEqual(output, "1234")
 
-    @setup({'cycle23': "{% for x in values %}"
-                       "{% cycle 'a' 'b' 'c' as abc silent %}{{ abc }}{{ x }}{% endfor %}"})
+    @setup(
+        {
+            "cycle23": "{% for x in values %}"
+            "{% cycle 'a' 'b' 'c' as abc silent %}{{ abc }}{{ x }}{% endfor %}"
+        }
+    )
     def test_cycle23(self):
-        output = self.engine.render_to_string('cycle23', {'values': [1, 2, 3, 4]})
-        self.assertEqual(output, 'a1b2c3a4')
+        output = self.engine.render_to_string("cycle23", {"values": [1, 2, 3, 4]})
+        self.assertEqual(output, "a1b2c3a4")
 
-    @setup({
-        'cycle24': "{% for x in values %}"
-                   "{% cycle 'a' 'b' 'c' as abc silent %}{% include 'included-cycle' %}{% endfor %}",
-        'included-cycle': '{{ abc }}',
-    })
+    @setup(
+        {
+            "cycle24": "{% for x in values %}"
+            "{% cycle 'a' 'b' 'c' as abc silent %}{% include 'included-cycle' %}{% endfor %}",
+            "included-cycle": "{{ abc }}",
+        }
+    )
     def test_cycle24(self):
-        output = self.engine.render_to_string('cycle24', {'values': [1, 2, 3, 4]})
-        self.assertEqual(output, 'abca')
+        output = self.engine.render_to_string("cycle24", {"values": [1, 2, 3, 4]})
+        self.assertEqual(output, "abca")
 
-    @setup({'cycle25': '{% cycle a as abc %}'})
+    @setup({"cycle25": "{% cycle a as abc %}"})
     def test_cycle25(self):
-        output = self.engine.render_to_string('cycle25', {'a': '<'})
-        self.assertEqual(output, '&lt;')
+        output = self.engine.render_to_string("cycle25", {"a": "<"})
+        self.assertEqual(output, "&lt;")
 
-    @setup({'cycle26': '{% cycle a b as ab %}{% cycle ab %}'})
+    @setup({"cycle26": "{% cycle a b as ab %}{% cycle ab %}"})
     def test_cycle26(self):
-        output = self.engine.render_to_string('cycle26', {'a': '<', 'b': '>'})
-        self.assertEqual(output, '&lt;&gt;')
+        output = self.engine.render_to_string("cycle26", {"a": "<", "b": ">"})
+        self.assertEqual(output, "&lt;&gt;")
 
-    @setup({'cycle27': '{% autoescape off %}{% cycle a b as ab %}{% cycle ab %}{% endautoescape %}'})
+    @setup(
+        {
+            "cycle27": "{% autoescape off %}{% cycle a b as ab %}{% cycle ab %}{% endautoescape %}"
+        }
+    )
     def test_cycle27(self):
-        output = self.engine.render_to_string('cycle27', {'a': '<', 'b': '>'})
-        self.assertEqual(output, '<>')
+        output = self.engine.render_to_string("cycle27", {"a": "<", "b": ">"})
+        self.assertEqual(output, "<>")
 
-    @setup({'cycle28': '{% cycle a|safe b as ab %}{% cycle ab %}'})
+    @setup({"cycle28": "{% cycle a|safe b as ab %}{% cycle ab %}"})
     def test_cycle28(self):
-        output = self.engine.render_to_string('cycle28', {'a': '<', 'b': '>'})
-        self.assertEqual(output, '<&gt;')
+        output = self.engine.render_to_string("cycle28", {"a": "<", "b": ">"})
+        self.assertEqual(output, "<&gt;")
 
-    @setup({
-        'cycle29': "{% cycle 'a' 'b' 'c' as cycler silent %}"
-                   "{% for x in values %}"
-                   "{% ifchanged x %}"
-                   "{% cycle cycler %}{{ cycler }}"
-                   "{% else %}"
-                   "{{ cycler }}"
-                   "{% endifchanged %}"
-                   "{% endfor %}"
-    })
+    @setup(
+        {
+            "cycle29": "{% cycle 'a' 'b' 'c' as cycler silent %}"
+            "{% for x in values %}"
+            "{% ifchanged x %}"
+            "{% cycle cycler %}{{ cycler }}"
+            "{% else %}"
+            "{{ cycler }}"
+            "{% endifchanged %}"
+            "{% endfor %}"
+        }
+    )
     def test_cycle29(self):
         """
         A named {% cycle %} tag works inside an {% ifchanged %} block and a
         {% for %} loop.
         """
-        output = self.engine.render_to_string('cycle29', {'values': [1, 2, 3, 4, 5, 6, 7, 8, 8, 8, 9, 9]})
-        self.assertEqual(output, 'bcabcabcccaa')
+        output = self.engine.render_to_string(
+            "cycle29", {"values": [1, 2, 3, 4, 5, 6, 7, 8, 8, 8, 9, 9]}
+        )
+        self.assertEqual(output, "bcabcabcccaa")
 
-    @setup({
-        'cycle30': "{% cycle 'a' 'b' 'c' as cycler silent %}"
-                   "{% for x in values %}"
-                   "{% with doesnothing=irrelevant %}"
-                   "{% ifchanged x %}"
-                   "{% cycle cycler %}{{ cycler }}"
-                   "{% else %}"
-                   "{{ cycler }}"
-                   "{% endifchanged %}"
-                   "{% endwith %}"
-                   "{% endfor %}"})
+    @setup(
+        {
+            "cycle30": "{% cycle 'a' 'b' 'c' as cycler silent %}"
+            "{% for x in values %}"
+            "{% with doesnothing=irrelevant %}"
+            "{% ifchanged x %}"
+            "{% cycle cycler %}{{ cycler }}"
+            "{% else %}"
+            "{{ cycler }}"
+            "{% endifchanged %}"
+            "{% endwith %}"
+            "{% endfor %}"
+        }
+    )
     def test_cycle30(self):
         """
         A {% with %} tag shouldn't reset the {% cycle %} variable.
         """
         output = self.engine.render_to_string(
-            'cycle30', {
-                'irrelevant': 1,
-                'values': [1, 2, 3, 4, 5, 6, 7, 8, 8, 8, 9, 9]
-            })
-        self.assertEqual(output, 'bcabcabcccaa')
+            "cycle30", {"irrelevant": 1, "values": [1, 2, 3, 4, 5, 6, 7, 8, 8, 8, 9, 9]}
+        )
+        self.assertEqual(output, "bcabcabcccaa")
 
-    @setup({
-        'undefined_cycle':
-            "{% cycle 'a' 'b' 'c' as cycler silent %}"
+    @setup(
+        {
+            "undefined_cycle": "{% cycle 'a' 'b' 'c' as cycler silent %}"
             "{% for x in values %}"
             "{% cycle undefined %}{{ cycler }}"
             "{% endfor %}"
-    })
+        }
+    )
     def test_cycle_undefined(self):
-        with self.assertRaisesMessage(TemplateSyntaxError, "Named cycle 'undefined' does not exist"):
-            self.engine.render_to_string('undefined_cycle')
+        with self.assertRaisesMessage(
+            TemplateSyntaxError, "Named cycle 'undefined' does not exist"
+        ):
+            self.engine.render_to_string("undefined_cycle")
diff --git a/tests/template_tests/syntax_tests/test_debug.py b/tests/template_tests/syntax_tests/test_debug.py
index 2f527b44ae..cbd71fa51a 100644
--- a/tests/template_tests/syntax_tests/test_debug.py
+++ b/tests/template_tests/syntax_tests/test_debug.py
@@ -6,41 +6,40 @@ from ..utils import setup
 
 @override_settings(DEBUG=True)
 class DebugTests(SimpleTestCase):
-
     @override_settings(DEBUG=False)
-    @setup({'non_debug': '{% debug %}'})
+    @setup({"non_debug": "{% debug %}"})
     def test_non_debug(self):
-        output = self.engine.render_to_string('non_debug', {})
-        self.assertEqual(output, '')
+        output = self.engine.render_to_string("non_debug", {})
+        self.assertEqual(output, "")
 
-    @setup({'modules': '{% debug %}'})
+    @setup({"modules": "{% debug %}"})
     def test_modules(self):
-        output = self.engine.render_to_string('modules', {})
+        output = self.engine.render_to_string("modules", {})
         self.assertIn(
-            '&#x27;django&#x27;: &lt;module &#x27;django&#x27; ',
+            "&#x27;django&#x27;: &lt;module &#x27;django&#x27; ",
             output,
         )
 
-    @setup({'plain': '{% debug %}'})
+    @setup({"plain": "{% debug %}"})
     def test_plain(self):
-        output = self.engine.render_to_string('plain', {'a': 1})
-        self.assertTrue(output.startswith(
-            '{&#x27;a&#x27;: 1}'
-            '{&#x27;False&#x27;: False, &#x27;None&#x27;: None, '
-            '&#x27;True&#x27;: True}\n\n{'
-        ))
+        output = self.engine.render_to_string("plain", {"a": 1})
+        self.assertTrue(
+            output.startswith(
+                "{&#x27;a&#x27;: 1}"
+                "{&#x27;False&#x27;: False, &#x27;None&#x27;: None, "
+                "&#x27;True&#x27;: True}\n\n{"
+            )
+        )
 
-    @setup({'non_ascii': '{% debug %}'})
+    @setup({"non_ascii": "{% debug %}"})
     def test_non_ascii(self):
         group = Group(name="清風")
-        output = self.engine.render_to_string('non_ascii', {'group': group})
-        self.assertTrue(output.startswith(
-            '{&#x27;group&#x27;: &lt;Group: 清風&gt;}'
-        ))
+        output = self.engine.render_to_string("non_ascii", {"group": group})
+        self.assertTrue(output.startswith("{&#x27;group&#x27;: &lt;Group: 清風&gt;}"))
 
-    @setup({'script': '{% debug %}'})
+    @setup({"script": "{% debug %}"})
     def test_script(self):
-        output = self.engine.render_to_string('script', {'frag': '<script>'})
-        self.assertTrue(output.startswith(
-            '{&#x27;frag&#x27;: &#x27;&lt;script&gt;&#x27;}'
-        ))
+        output = self.engine.render_to_string("script", {"frag": "<script>"})
+        self.assertTrue(
+            output.startswith("{&#x27;frag&#x27;: &#x27;&lt;script&gt;&#x27;}")
+        )
diff --git a/tests/template_tests/syntax_tests/test_exceptions.py b/tests/template_tests/syntax_tests/test_exceptions.py
index db1e0f9f5f..7000b45afd 100644
--- a/tests/template_tests/syntax_tests/test_exceptions.py
+++ b/tests/template_tests/syntax_tests/test_exceptions.py
@@ -6,30 +6,31 @@ from .test_extends import inheritance_templates
 
 
 class ExceptionsTests(SimpleTestCase):
-
-    @setup({'exception01': "{% extends 'nonexistent' %}"})
+    @setup({"exception01": "{% extends 'nonexistent' %}"})
     def test_exception01(self):
         """
         Raise exception for invalid template name
         """
         with self.assertRaises(TemplateDoesNotExist):
-            self.engine.render_to_string('exception01')
+            self.engine.render_to_string("exception01")
 
-    @setup({'exception02': '{% extends nonexistent %}'})
+    @setup({"exception02": "{% extends nonexistent %}"})
     def test_exception02(self):
         """
         Raise exception for invalid variable template name
         """
         if self.engine.string_if_invalid:
             with self.assertRaises(TemplateDoesNotExist):
-                self.engine.render_to_string('exception02')
+                self.engine.render_to_string("exception02")
         else:
             with self.assertRaises(TemplateSyntaxError):
-                self.engine.render_to_string('exception02')
+                self.engine.render_to_string("exception02")
 
     @setup(
-        {'exception03': "{% extends 'inheritance01' %}"
-                        "{% block first %}2{% endblock %}{% extends 'inheritance16' %}"},
+        {
+            "exception03": "{% extends 'inheritance01' %}"
+            "{% block first %}2{% endblock %}{% extends 'inheritance16' %}"
+        },
         inheritance_templates,
     )
     def test_exception03(self):
@@ -37,10 +38,12 @@ class ExceptionsTests(SimpleTestCase):
         Raise exception for extra {% extends %} tags
         """
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('exception03')
+            self.engine.get_template("exception03")
 
     @setup(
-        {'exception04': "{% extends 'inheritance17' %}{% block first %}{% echo 400 %}5678{% endblock %}"},
+        {
+            "exception04": "{% extends 'inheritance17' %}{% block first %}{% echo 400 %}5678{% endblock %}"
+        },
         inheritance_templates,
     )
     def test_exception04(self):
@@ -48,12 +51,12 @@ class ExceptionsTests(SimpleTestCase):
         Raise exception for custom tags used in child with {% load %} tag in parent, not in child
         """
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('exception04')
+            self.engine.get_template("exception04")
 
-    @setup({'exception05': '{% block first %}{{ block.super }}{% endblock %}'})
+    @setup({"exception05": "{% block first %}{{ block.super }}{% endblock %}"})
     def test_exception05(self):
         """
         Raise exception for block.super used in base template
         """
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.render_to_string('exception05')
+            self.engine.render_to_string("exception05")
diff --git a/tests/template_tests/syntax_tests/test_extends.py b/tests/template_tests/syntax_tests/test_extends.py
index 0689838ae8..ce073fb909 100644
--- a/tests/template_tests/syntax_tests/test_extends.py
+++ b/tests/template_tests/syntax_tests/test_extends.py
@@ -6,119 +6,119 @@ from django.test import SimpleTestCase
 from ..utils import setup
 
 inheritance_templates = {
-    'inheritance01': "1{% block first %}&{% endblock %}3{% block second %}_{% endblock %}",
-    'inheritance02': "{% extends 'inheritance01' %}"
-                     "{% block first %}2{% endblock %}{% block second %}4{% endblock %}",
-    'inheritance03': "{% extends 'inheritance02' %}",
-    'inheritance04': "{% extends 'inheritance01' %}",
-    'inheritance05': "{% extends 'inheritance02' %}",
-    'inheritance06': "{% extends foo %}",
-    'inheritance07': "{% extends 'inheritance01' %}{% block second %}5{% endblock %}",
-    'inheritance08': "{% extends 'inheritance02' %}{% block second %}5{% endblock %}",
-    'inheritance09': "{% extends 'inheritance04' %}",
-    'inheritance10': "{% extends 'inheritance04' %}      ",
-    'inheritance11': "{% extends 'inheritance04' %}"
-                     "{% block first %}2{% endblock %}{% block second %}4{% endblock %}",
-    'inheritance12': "{% extends 'inheritance07' %}{% block first %}2{% endblock %}",
-    'inheritance13': "{% extends 'inheritance02' %}"
-                     "{% block first %}a{% endblock %}{% block second %}b{% endblock %}",
-    'inheritance14': "{% extends 'inheritance01' %}{% block newblock %}NO DISPLAY{% endblock %}",
-    'inheritance15': "{% extends 'inheritance01' %}"
-                     "{% block first %}2{% block inner %}inner{% endblock %}{% endblock %}",
-    'inheritance16': "{% extends 'inheritance15' %}{% block inner %}out{% endblock %}",
-    'inheritance17': "{% load testtags %}{% block first %}1234{% endblock %}",
-    'inheritance18': "{% load testtags %}{% echo this that theother %}5678",
-    'inheritance19': "{% extends 'inheritance01' %}"
-                     "{% block first %}{% load testtags %}{% echo 400 %}5678{% endblock %}",
-    'inheritance20': "{% extends 'inheritance01' %}{% block first %}{{ block.super }}a{% endblock %}",
-    'inheritance21': "{% extends 'inheritance02' %}{% block first %}{{ block.super }}a{% endblock %}",
-    'inheritance22': "{% extends 'inheritance04' %}{% block first %}{{ block.super }}a{% endblock %}",
-    'inheritance23': "{% extends 'inheritance20' %}{% block first %}{{ block.super }}b{% endblock %}",
-    'inheritance24': "{% extends context_template %}"
-                     "{% block first %}2{% endblock %}{% block second %}4{% endblock %}",
-    'inheritance25': "{% extends context_template.1 %}"
-                     "{% block first %}2{% endblock %}{% block second %}4{% endblock %}",
-    'inheritance26': "no tags",
-    'inheritance27': "{% extends 'inheritance26' %}",
-    'inheritance 28': "{% block first %}!{% endblock %}",
-    'inheritance29': "{% extends 'inheritance 28' %}",
-    'inheritance30': "1{% if optional %}{% block opt %}2{% endblock %}{% endif %}3",
-    'inheritance31': "{% extends 'inheritance30' %}{% block opt %}two{% endblock %}",
-    'inheritance32': "{% extends 'inheritance30' %}{% block opt %}two{% endblock %}",
-    'inheritance33': "1{% if optional == 1 %}{% block opt %}2{% endblock %}{% endif %}3",
-    'inheritance34': "{% extends 'inheritance33' %}{% block opt %}two{% endblock %}",
-    'inheritance35': "{% extends 'inheritance33' %}{% block opt %}two{% endblock %}",
-    'inheritance36': "{% for n in numbers %}_{% block opt %}{{ n }}{% endblock %}{% endfor %}_",
-    'inheritance37': "{% extends 'inheritance36' %}{% block opt %}X{% endblock %}",
-    'inheritance38': "{% extends 'inheritance36' %}{% block opt %}X{% endblock %}",
-    'inheritance39': "{% extends 'inheritance30' %}{% block opt %}new{{ block.super }}{% endblock %}",
-    'inheritance40': "{% extends 'inheritance33' %}{% block opt %}new{{ block.super }}{% endblock %}",
-    'inheritance41': "{% extends 'inheritance36' %}{% block opt %}new{{ block.super }}{% endblock %}",
-    'inheritance42': "{% extends 'inheritance02'|cut:' ' %}",
-    'inheritance_empty': "{% extends %}",
-    'extends_duplicate': "{% extends 'base.html' %}{% extends 'base.html' %}",
-    'duplicate_block': "{% extends 'base.html' %}{% block content %}2{% endblock %}{% block content %}4{% endblock %}",
+    "inheritance01": "1{% block first %}&{% endblock %}3{% block second %}_{% endblock %}",
+    "inheritance02": "{% extends 'inheritance01' %}"
+    "{% block first %}2{% endblock %}{% block second %}4{% endblock %}",
+    "inheritance03": "{% extends 'inheritance02' %}",
+    "inheritance04": "{% extends 'inheritance01' %}",
+    "inheritance05": "{% extends 'inheritance02' %}",
+    "inheritance06": "{% extends foo %}",
+    "inheritance07": "{% extends 'inheritance01' %}{% block second %}5{% endblock %}",
+    "inheritance08": "{% extends 'inheritance02' %}{% block second %}5{% endblock %}",
+    "inheritance09": "{% extends 'inheritance04' %}",
+    "inheritance10": "{% extends 'inheritance04' %}      ",
+    "inheritance11": "{% extends 'inheritance04' %}"
+    "{% block first %}2{% endblock %}{% block second %}4{% endblock %}",
+    "inheritance12": "{% extends 'inheritance07' %}{% block first %}2{% endblock %}",
+    "inheritance13": "{% extends 'inheritance02' %}"
+    "{% block first %}a{% endblock %}{% block second %}b{% endblock %}",
+    "inheritance14": "{% extends 'inheritance01' %}{% block newblock %}NO DISPLAY{% endblock %}",
+    "inheritance15": "{% extends 'inheritance01' %}"
+    "{% block first %}2{% block inner %}inner{% endblock %}{% endblock %}",
+    "inheritance16": "{% extends 'inheritance15' %}{% block inner %}out{% endblock %}",
+    "inheritance17": "{% load testtags %}{% block first %}1234{% endblock %}",
+    "inheritance18": "{% load testtags %}{% echo this that theother %}5678",
+    "inheritance19": "{% extends 'inheritance01' %}"
+    "{% block first %}{% load testtags %}{% echo 400 %}5678{% endblock %}",
+    "inheritance20": "{% extends 'inheritance01' %}{% block first %}{{ block.super }}a{% endblock %}",
+    "inheritance21": "{% extends 'inheritance02' %}{% block first %}{{ block.super }}a{% endblock %}",
+    "inheritance22": "{% extends 'inheritance04' %}{% block first %}{{ block.super }}a{% endblock %}",
+    "inheritance23": "{% extends 'inheritance20' %}{% block first %}{{ block.super }}b{% endblock %}",
+    "inheritance24": "{% extends context_template %}"
+    "{% block first %}2{% endblock %}{% block second %}4{% endblock %}",
+    "inheritance25": "{% extends context_template.1 %}"
+    "{% block first %}2{% endblock %}{% block second %}4{% endblock %}",
+    "inheritance26": "no tags",
+    "inheritance27": "{% extends 'inheritance26' %}",
+    "inheritance 28": "{% block first %}!{% endblock %}",
+    "inheritance29": "{% extends 'inheritance 28' %}",
+    "inheritance30": "1{% if optional %}{% block opt %}2{% endblock %}{% endif %}3",
+    "inheritance31": "{% extends 'inheritance30' %}{% block opt %}two{% endblock %}",
+    "inheritance32": "{% extends 'inheritance30' %}{% block opt %}two{% endblock %}",
+    "inheritance33": "1{% if optional == 1 %}{% block opt %}2{% endblock %}{% endif %}3",
+    "inheritance34": "{% extends 'inheritance33' %}{% block opt %}two{% endblock %}",
+    "inheritance35": "{% extends 'inheritance33' %}{% block opt %}two{% endblock %}",
+    "inheritance36": "{% for n in numbers %}_{% block opt %}{{ n }}{% endblock %}{% endfor %}_",
+    "inheritance37": "{% extends 'inheritance36' %}{% block opt %}X{% endblock %}",
+    "inheritance38": "{% extends 'inheritance36' %}{% block opt %}X{% endblock %}",
+    "inheritance39": "{% extends 'inheritance30' %}{% block opt %}new{{ block.super }}{% endblock %}",
+    "inheritance40": "{% extends 'inheritance33' %}{% block opt %}new{{ block.super }}{% endblock %}",
+    "inheritance41": "{% extends 'inheritance36' %}{% block opt %}new{{ block.super }}{% endblock %}",
+    "inheritance42": "{% extends 'inheritance02'|cut:' ' %}",
+    "inheritance_empty": "{% extends %}",
+    "extends_duplicate": "{% extends 'base.html' %}{% extends 'base.html' %}",
+    "duplicate_block": "{% extends 'base.html' %}{% block content %}2{% endblock %}{% block content %}4{% endblock %}",
 }
 
 
 class InheritanceTests(SimpleTestCase):
-    libraries = {'testtags': 'template_tests.templatetags.testtags'}
+    libraries = {"testtags": "template_tests.templatetags.testtags"}
 
     @setup(inheritance_templates)
     def test_inheritance01(self):
         """
         Standard template with no inheritance
         """
-        output = self.engine.render_to_string('inheritance01')
-        self.assertEqual(output, '1&3_')
+        output = self.engine.render_to_string("inheritance01")
+        self.assertEqual(output, "1&3_")
 
     @setup(inheritance_templates)
     def test_inheritance02(self):
         """
         Standard two-level inheritance
         """
-        output = self.engine.render_to_string('inheritance02')
-        self.assertEqual(output, '1234')
+        output = self.engine.render_to_string("inheritance02")
+        self.assertEqual(output, "1234")
 
     @setup(inheritance_templates)
     def test_inheritance03(self):
         """
         Three-level with no redefinitions on third level
         """
-        output = self.engine.render_to_string('inheritance03')
-        self.assertEqual(output, '1234')
+        output = self.engine.render_to_string("inheritance03")
+        self.assertEqual(output, "1234")
 
     @setup(inheritance_templates)
     def test_inheritance04(self):
         """
         Two-level with no redefinitions on second level
         """
-        output = self.engine.render_to_string('inheritance04')
-        self.assertEqual(output, '1&3_')
+        output = self.engine.render_to_string("inheritance04")
+        self.assertEqual(output, "1&3_")
 
     @setup(inheritance_templates)
     def test_inheritance05(self):
         """
         Two-level with double quotes instead of single quotes
         """
-        output = self.engine.render_to_string('inheritance05')
-        self.assertEqual(output, '1234')
+        output = self.engine.render_to_string("inheritance05")
+        self.assertEqual(output, "1234")
 
     @setup(inheritance_templates)
     def test_inheritance06(self):
         """
         Three-level with variable parent-template name
         """
-        output = self.engine.render_to_string('inheritance06', {'foo': 'inheritance02'})
-        self.assertEqual(output, '1234')
+        output = self.engine.render_to_string("inheritance06", {"foo": "inheritance02"})
+        self.assertEqual(output, "1234")
 
     @setup(inheritance_templates)
     def test_inheritance07(self):
         """
         Two-level with one block defined, one block not defined
         """
-        output = self.engine.render_to_string('inheritance07')
-        self.assertEqual(output, '1&35')
+        output = self.engine.render_to_string("inheritance07")
+        self.assertEqual(output, "1&35")
 
     @setup(inheritance_templates)
     def test_inheritance08(self):
@@ -126,24 +126,24 @@ class InheritanceTests(SimpleTestCase):
         Three-level with one block defined on this level, two blocks
         defined next level
         """
-        output = self.engine.render_to_string('inheritance08')
-        self.assertEqual(output, '1235')
+        output = self.engine.render_to_string("inheritance08")
+        self.assertEqual(output, "1235")
 
     @setup(inheritance_templates)
     def test_inheritance09(self):
         """
         Three-level with second and third levels blank
         """
-        output = self.engine.render_to_string('inheritance09')
-        self.assertEqual(output, '1&3_')
+        output = self.engine.render_to_string("inheritance09")
+        self.assertEqual(output, "1&3_")
 
     @setup(inheritance_templates)
     def test_inheritance10(self):
         """
         Three-level with space NOT in a block -- should be ignored
         """
-        output = self.engine.render_to_string('inheritance10')
-        self.assertEqual(output, '1&3_')
+        output = self.engine.render_to_string("inheritance10")
+        self.assertEqual(output, "1&3_")
 
     @setup(inheritance_templates)
     def test_inheritance11(self):
@@ -151,8 +151,8 @@ class InheritanceTests(SimpleTestCase):
         Three-level with both blocks defined on this level, but none on
         second level
         """
-        output = self.engine.render_to_string('inheritance11')
-        self.assertEqual(output, '1234')
+        output = self.engine.render_to_string("inheritance11")
+        self.assertEqual(output, "1234")
 
     @setup(inheritance_templates)
     def test_inheritance12(self):
@@ -160,88 +160,88 @@ class InheritanceTests(SimpleTestCase):
         Three-level with this level providing one and second level
         providing the other
         """
-        output = self.engine.render_to_string('inheritance12')
-        self.assertEqual(output, '1235')
+        output = self.engine.render_to_string("inheritance12")
+        self.assertEqual(output, "1235")
 
     @setup(inheritance_templates)
     def test_inheritance13(self):
         """
         Three-level with this level overriding second level
         """
-        output = self.engine.render_to_string('inheritance13')
-        self.assertEqual(output, '1a3b')
+        output = self.engine.render_to_string("inheritance13")
+        self.assertEqual(output, "1a3b")
 
     @setup(inheritance_templates)
     def test_inheritance14(self):
         """
         A block defined only in a child template shouldn't be displayed
         """
-        output = self.engine.render_to_string('inheritance14')
-        self.assertEqual(output, '1&3_')
+        output = self.engine.render_to_string("inheritance14")
+        self.assertEqual(output, "1&3_")
 
     @setup(inheritance_templates)
     def test_inheritance15(self):
         """
         A block within another block
         """
-        output = self.engine.render_to_string('inheritance15')
-        self.assertEqual(output, '12inner3_')
+        output = self.engine.render_to_string("inheritance15")
+        self.assertEqual(output, "12inner3_")
 
     @setup(inheritance_templates)
     def test_inheritance16(self):
         """
         A block within another block (level 2)
         """
-        output = self.engine.render_to_string('inheritance16')
-        self.assertEqual(output, '12out3_')
+        output = self.engine.render_to_string("inheritance16")
+        self.assertEqual(output, "12out3_")
 
     @setup(inheritance_templates)
     def test_inheritance17(self):
         """
         {% load %} tag (parent -- setup for exception04)
         """
-        output = self.engine.render_to_string('inheritance17')
-        self.assertEqual(output, '1234')
+        output = self.engine.render_to_string("inheritance17")
+        self.assertEqual(output, "1234")
 
     @setup(inheritance_templates)
     def test_inheritance18(self):
         """
         {% load %} tag (standard usage, without inheritance)
         """
-        output = self.engine.render_to_string('inheritance18')
-        self.assertEqual(output, 'this that theother5678')
+        output = self.engine.render_to_string("inheritance18")
+        self.assertEqual(output, "this that theother5678")
 
     @setup(inheritance_templates)
     def test_inheritance19(self):
         """
         {% load %} tag (within a child template)
         """
-        output = self.engine.render_to_string('inheritance19')
-        self.assertEqual(output, '140056783_')
+        output = self.engine.render_to_string("inheritance19")
+        self.assertEqual(output, "140056783_")
 
     @setup(inheritance_templates)
     def test_inheritance20(self):
         """
         Two-level inheritance with {{ block.super }}
         """
-        output = self.engine.render_to_string('inheritance20')
-        self.assertEqual(output, '1&a3_')
+        output = self.engine.render_to_string("inheritance20")
+        self.assertEqual(output, "1&a3_")
 
     @setup(inheritance_templates)
     def test_inheritance21(self):
         """
         Three-level inheritance with {{ block.super }} from parent
         """
-        output = self.engine.render_to_string('inheritance21')
-        self.assertEqual(output, '12a34')
+        output = self.engine.render_to_string("inheritance21")
+        self.assertEqual(output, "12a34")
 
     @setup(inheritance_templates)
     def test_inheritance22(self):
         """
         Three-level inheritance with {{ block.super }} from grandparent
         """
-        output = self.engine.render_to_string('inheritance22')
-        self.assertEqual(output, '1&a3_')
+        output = self.engine.render_to_string("inheritance22")
+        self.assertEqual(output, "1&a3_")
 
     @setup(inheritance_templates)
     def test_inheritance23(self):
@@ -249,8 +249,8 @@ class InheritanceTests(SimpleTestCase):
         Three-level inheritance with {{ block.super }} from parent and
         grandparent
         """
-        output = self.engine.render_to_string('inheritance23')
-        self.assertEqual(output, '1&ab3_')
+        output = self.engine.render_to_string("inheritance23")
+        self.assertEqual(output, "1&ab3_")
 
     @setup(inheritance_templates)
     def test_inheritance24(self):
@@ -260,8 +260,10 @@ class InheritanceTests(SimpleTestCase):
         context_template = self.engine.from_string(
             "1{% block first %}_{% endblock %}3{% block second %}_{% endblock %}"
         )
-        output = self.engine.render_to_string('inheritance24', {'context_template': context_template})
-        self.assertEqual(output, '1234')
+        output = self.engine.render_to_string(
+            "inheritance24", {"context_template": context_template}
+        )
+        self.assertEqual(output, "1234")
 
     @setup(inheritance_templates)
     def test_inheritance25(self):
@@ -270,70 +272,74 @@ class InheritanceTests(SimpleTestCase):
         """
         context_template = [
             self.engine.from_string("Wrong"),
-            self.engine.from_string("1{% block first %}_{% endblock %}3{% block second %}_{% endblock %}"),
+            self.engine.from_string(
+                "1{% block first %}_{% endblock %}3{% block second %}_{% endblock %}"
+            ),
         ]
-        output = self.engine.render_to_string('inheritance25', {'context_template': context_template})
-        self.assertEqual(output, '1234')
+        output = self.engine.render_to_string(
+            "inheritance25", {"context_template": context_template}
+        )
+        self.assertEqual(output, "1234")
 
     @setup(inheritance_templates)
     def test_inheritance26(self):
         """
         Set up a base template to extend
         """
-        output = self.engine.render_to_string('inheritance26')
-        self.assertEqual(output, 'no tags')
+        output = self.engine.render_to_string("inheritance26")
+        self.assertEqual(output, "no tags")
 
     @setup(inheritance_templates)
     def test_inheritance27(self):
         """
         Inheritance from a template that doesn't have any blocks
         """
-        output = self.engine.render_to_string('inheritance27')
-        self.assertEqual(output, 'no tags')
+        output = self.engine.render_to_string("inheritance27")
+        self.assertEqual(output, "no tags")
 
     @setup(inheritance_templates)
     def test_inheritance_28(self):
         """
         Set up a base template with a space in it.
         """
-        output = self.engine.render_to_string('inheritance 28')
-        self.assertEqual(output, '!')
+        output = self.engine.render_to_string("inheritance 28")
+        self.assertEqual(output, "!")
 
     @setup(inheritance_templates)
     def test_inheritance29(self):
         """
         Inheritance from a template with a space in its name should work.
         """
-        output = self.engine.render_to_string('inheritance29')
-        self.assertEqual(output, '!')
+        output = self.engine.render_to_string("inheritance29")
+        self.assertEqual(output, "!")
 
     @setup(inheritance_templates)
     def test_inheritance30(self):
         """
         Base template, putting block in a conditional {% if %} tag
         """
-        output = self.engine.render_to_string('inheritance30', {'optional': True})
-        self.assertEqual(output, '123')
+        output = self.engine.render_to_string("inheritance30", {"optional": True})
+        self.assertEqual(output, "123")
 
     # Inherit from a template with block wrapped in an {% if %} tag
     # (in parent), still gets overridden
     @setup(inheritance_templates)
     def test_inheritance31(self):
-        output = self.engine.render_to_string('inheritance31', {'optional': True})
-        self.assertEqual(output, '1two3')
+        output = self.engine.render_to_string("inheritance31", {"optional": True})
+        self.assertEqual(output, "1two3")
 
     @setup(inheritance_templates)
     def test_inheritance32(self):
-        output = self.engine.render_to_string('inheritance32')
-        self.assertEqual(output, '13')
+        output = self.engine.render_to_string("inheritance32")
+        self.assertEqual(output, "13")
 
     @setup(inheritance_templates)
     def test_inheritance33(self):
         """
         Base template, putting block in a conditional {% if %} tag
         """
-        output = self.engine.render_to_string('inheritance33', {'optional': 1})
-        self.assertEqual(output, '123')
+        output = self.engine.render_to_string("inheritance33", {"optional": 1})
+        self.assertEqual(output, "123")
 
     @setup(inheritance_templates)
     def test_inheritance34(self):
@@ -341,8 +347,8 @@ class InheritanceTests(SimpleTestCase):
         Inherit from a template with block wrapped in an {% if %} tag
         (in parent), still gets overridden
         """
-        output = self.engine.render_to_string('inheritance34', {'optional': 1})
-        self.assertEqual(output, '1two3')
+        output = self.engine.render_to_string("inheritance34", {"optional": 1})
+        self.assertEqual(output, "1two3")
 
     @setup(inheritance_templates)
     def test_inheritance35(self):
@@ -350,16 +356,16 @@ class InheritanceTests(SimpleTestCase):
         Inherit from a template with block wrapped in an {% if %} tag
         (in parent), still gets overridden
         """
-        output = self.engine.render_to_string('inheritance35', {'optional': 2})
-        self.assertEqual(output, '13')
+        output = self.engine.render_to_string("inheritance35", {"optional": 2})
+        self.assertEqual(output, "13")
 
     @setup(inheritance_templates)
     def test_inheritance36(self):
         """
         Base template, putting block in a {% for %} tag
         """
-        output = self.engine.render_to_string('inheritance36', {'numbers': '123'})
-        self.assertEqual(output, '_1_2_3_')
+        output = self.engine.render_to_string("inheritance36", {"numbers": "123"})
+        self.assertEqual(output, "_1_2_3_")
 
     @setup(inheritance_templates)
     def test_inheritance37(self):
@@ -367,8 +373,8 @@ class InheritanceTests(SimpleTestCase):
         Inherit from a template with block wrapped in an {% for %} tag
         (in parent), still gets overridden
         """
-        output = self.engine.render_to_string('inheritance37', {'numbers': '123'})
-        self.assertEqual(output, '_X_X_X_')
+        output = self.engine.render_to_string("inheritance37", {"numbers": "123"})
+        self.assertEqual(output, "_X_X_X_")
 
     @setup(inheritance_templates)
     def test_inheritance38(self):
@@ -376,49 +382,51 @@ class InheritanceTests(SimpleTestCase):
         Inherit from a template with block wrapped in an {% for %} tag
         (in parent), still gets overridden
         """
-        output = self.engine.render_to_string('inheritance38')
-        self.assertEqual(output, '_')
+        output = self.engine.render_to_string("inheritance38")
+        self.assertEqual(output, "_")
 
     # The super block will still be found.
     @setup(inheritance_templates)
     def test_inheritance39(self):
-        output = self.engine.render_to_string('inheritance39', {'optional': True})
-        self.assertEqual(output, '1new23')
+        output = self.engine.render_to_string("inheritance39", {"optional": True})
+        self.assertEqual(output, "1new23")
 
     @setup(inheritance_templates)
     def test_inheritance40(self):
-        output = self.engine.render_to_string('inheritance40', {'optional': 1})
-        self.assertEqual(output, '1new23')
+        output = self.engine.render_to_string("inheritance40", {"optional": 1})
+        self.assertEqual(output, "1new23")
 
     @setup(inheritance_templates)
     def test_inheritance41(self):
-        output = self.engine.render_to_string('inheritance41', {'numbers': '123'})
-        self.assertEqual(output, '_new1_new2_new3_')
+        output = self.engine.render_to_string("inheritance41", {"numbers": "123"})
+        self.assertEqual(output, "_new1_new2_new3_")
 
     @setup(inheritance_templates)
     def test_inheritance42(self):
         """
         Expression starting and ending with a quote
         """
-        output = self.engine.render_to_string('inheritance42')
-        self.assertEqual(output, '1234')
+        output = self.engine.render_to_string("inheritance42")
+        self.assertEqual(output, "1234")
 
     @setup(inheritance_templates)
     def test_inheritance_empty(self):
-        with self.assertRaisesMessage(TemplateSyntaxError, "'extends' takes one argument"):
-            self.engine.render_to_string('inheritance_empty')
+        with self.assertRaisesMessage(
+            TemplateSyntaxError, "'extends' takes one argument"
+        ):
+            self.engine.render_to_string("inheritance_empty")
 
     @setup(inheritance_templates)
     def test_extends_duplicate(self):
         msg = "'extends' cannot appear more than once in the same template"
         with self.assertRaisesMessage(TemplateSyntaxError, msg):
-            self.engine.render_to_string('extends_duplicate')
+            self.engine.render_to_string("extends_duplicate")
 
     @setup(inheritance_templates)
     def test_duplicate_block(self):
         msg = "'block' tag with name 'content' appears more than once"
         with self.assertRaisesMessage(TemplateSyntaxError, msg):
-            self.engine.render_to_string('duplicate_block')
+            self.engine.render_to_string("duplicate_block")
 
 
 class ExtendsNodeTests(SimpleTestCase):
@@ -428,4 +436,4 @@ class ExtendsNodeTests(SimpleTestCase):
             parent_name=Node(),
             template_dirs=[],
         )
-        self.assertEqual(repr(extends_node), '<ExtendsNode: extends None>')
+        self.assertEqual(repr(extends_node), "<ExtendsNode: extends None>")
diff --git a/tests/template_tests/syntax_tests/test_filter_syntax.py b/tests/template_tests/syntax_tests/test_filter_syntax.py
index 1d37163d60..5c9128aad8 100644
--- a/tests/template_tests/syntax_tests/test_filter_syntax.py
+++ b/tests/template_tests/syntax_tests/test_filter_syntax.py
@@ -5,58 +5,65 @@ from ..utils import SomeClass, SomeOtherException, UTF8Class, setup
 
 
 class FilterSyntaxTests(SimpleTestCase):
-
-    @setup({'filter-syntax01': '{{ var|upper }}'})
+    @setup({"filter-syntax01": "{{ var|upper }}"})
     def test_filter_syntax01(self):
         """
         Basic filter usage
         """
-        output = self.engine.render_to_string('filter-syntax01', {"var": "Django is the greatest!"})
+        output = self.engine.render_to_string(
+            "filter-syntax01", {"var": "Django is the greatest!"}
+        )
         self.assertEqual(output, "DJANGO IS THE GREATEST!")
 
-    @setup({'filter-syntax02': '{{ var|upper|lower }}'})
+    @setup({"filter-syntax02": "{{ var|upper|lower }}"})
     def test_filter_syntax02(self):
         """
         Chained filters
         """
-        output = self.engine.render_to_string('filter-syntax02', {"var": "Django is the greatest!"})
+        output = self.engine.render_to_string(
+            "filter-syntax02", {"var": "Django is the greatest!"}
+        )
         self.assertEqual(output, "django is the greatest!")
 
-    @setup({'filter-syntax03': '{{ var |upper }}'})
+    @setup({"filter-syntax03": "{{ var |upper }}"})
     def test_filter_syntax03(self):
         """
         Allow spaces before the filter pipe
         """
-        output = self.engine.render_to_string('filter-syntax03', {'var': 'Django is the greatest!'})
-        self.assertEqual(output, 'DJANGO IS THE GREATEST!')
+        output = self.engine.render_to_string(
+            "filter-syntax03", {"var": "Django is the greatest!"}
+        )
+        self.assertEqual(output, "DJANGO IS THE GREATEST!")
 
-    @setup({'filter-syntax04': '{{ var| upper }}'})
+    @setup({"filter-syntax04": "{{ var| upper }}"})
     def test_filter_syntax04(self):
         """
         Allow spaces after the filter pipe
         """
-        output = self.engine.render_to_string('filter-syntax04', {'var': 'Django is the greatest!'})
-        self.assertEqual(output, 'DJANGO IS THE GREATEST!')
+        output = self.engine.render_to_string(
+            "filter-syntax04", {"var": "Django is the greatest!"}
+        )
+        self.assertEqual(output, "DJANGO IS THE GREATEST!")
 
-    @setup({'filter-syntax05': '{{ var|does_not_exist }}'})
+    @setup({"filter-syntax05": "{{ var|does_not_exist }}"})
     def test_filter_syntax05(self):
         """
         Raise TemplateSyntaxError for a nonexistent filter
         """
         msg = "Invalid filter: 'does_not_exist'"
         with self.assertRaisesMessage(TemplateSyntaxError, msg):
-            self.engine.get_template('filter-syntax05')
+            self.engine.get_template("filter-syntax05")
 
-    @setup({'filter-syntax06': '{{ var|fil(ter) }}'})
+    @setup({"filter-syntax06": "{{ var|fil(ter) }}"})
     def test_filter_syntax06(self):
         """
         Raise TemplateSyntaxError when trying to access a filter containing
         an illegal character
         """
         with self.assertRaisesMessage(TemplateSyntaxError, "Invalid filter: 'fil'"):
-            self.engine.get_template('filter-syntax06')
+            self.engine.get_template("filter-syntax06")
 
-    @setup({'filter-syntax07': "{% nothing_to_see_here %}"})
+    @setup({"filter-syntax07": "{% nothing_to_see_here %}"})
     def test_filter_syntax07(self):
         """
         Raise TemplateSyntaxError for invalid block tags
@@ -66,143 +73,149 @@ class FilterSyntaxTests(SimpleTestCase):
             "forget to register or load this tag?"
         )
         with self.assertRaisesMessage(TemplateSyntaxError, msg):
-            self.engine.get_template('filter-syntax07')
+            self.engine.get_template("filter-syntax07")
 
-    @setup({'filter-syntax08': "{% %}"})
+    @setup({"filter-syntax08": "{% %}"})
     def test_filter_syntax08(self):
         """
         Raise TemplateSyntaxError for empty block tags
         """
-        with self.assertRaisesMessage(TemplateSyntaxError, 'Empty block tag on line 1'):
-            self.engine.get_template('filter-syntax08')
+        with self.assertRaisesMessage(TemplateSyntaxError, "Empty block tag on line 1"):
+            self.engine.get_template("filter-syntax08")
 
-    @setup({'filter-syntax08-multi-line': "line 1\nline 2\nline 3{% %}\nline 4\nline 5"})
+    @setup(
+        {"filter-syntax08-multi-line": "line 1\nline 2\nline 3{% %}\nline 4\nline 5"}
+    )
     def test_filter_syntax08_multi_line(self):
         """
         Raise TemplateSyntaxError for empty block tags in templates with
         multiple lines.
         """
-        with self.assertRaisesMessage(TemplateSyntaxError, 'Empty block tag on line 3'):
-            self.engine.get_template('filter-syntax08-multi-line')
+        with self.assertRaisesMessage(TemplateSyntaxError, "Empty block tag on line 3"):
+            self.engine.get_template("filter-syntax08-multi-line")
 
-    @setup({'filter-syntax09': '{{ var|cut:"o"|upper|lower }}'})
+    @setup({"filter-syntax09": '{{ var|cut:"o"|upper|lower }}'})
     def test_filter_syntax09(self):
         """
         Chained filters, with an argument to the first one
         """
-        output = self.engine.render_to_string('filter-syntax09', {'var': 'Foo'})
-        self.assertEqual(output, 'f')
+        output = self.engine.render_to_string("filter-syntax09", {"var": "Foo"})
+        self.assertEqual(output, "f")
 
-    @setup({'filter-syntax10': r'{{ var|default_if_none:" endquote\" hah" }}'})
+    @setup({"filter-syntax10": r'{{ var|default_if_none:" endquote\" hah" }}'})
     def test_filter_syntax10(self):
         """
         Literal string as argument is always "safe" from auto-escaping.
         """
-        output = self.engine.render_to_string('filter-syntax10', {"var": None})
+        output = self.engine.render_to_string("filter-syntax10", {"var": None})
         self.assertEqual(output, ' endquote" hah')
 
-    @setup({'filter-syntax11': r'{{ var|default_if_none:var2 }}'})
+    @setup({"filter-syntax11": r"{{ var|default_if_none:var2 }}"})
     def test_filter_syntax11(self):
         """
         Variable as argument
         """
-        output = self.engine.render_to_string('filter-syntax11', {"var": None, "var2": "happy"})
-        self.assertEqual(output, 'happy')
+        output = self.engine.render_to_string(
+            "filter-syntax11", {"var": None, "var2": "happy"}
+        )
+        self.assertEqual(output, "happy")
 
-    @setup({'filter-syntax13': r'1{{ var.method3 }}2'})
+    @setup({"filter-syntax13": r"1{{ var.method3 }}2"})
     def test_filter_syntax13(self):
         """
         Fail silently for methods that raise an exception with a
         `silent_variable_failure` attribute
         """
-        output = self.engine.render_to_string('filter-syntax13', {"var": SomeClass()})
+        output = self.engine.render_to_string("filter-syntax13", {"var": SomeClass()})
         if self.engine.string_if_invalid:
             self.assertEqual(output, "1INVALID2")
         else:
             self.assertEqual(output, "12")
 
-    @setup({'filter-syntax14': r'1{{ var.method4 }}2'})
+    @setup({"filter-syntax14": r"1{{ var.method4 }}2"})
     def test_filter_syntax14(self):
         """
         In methods that raise an exception without a
         `silent_variable_attribute` set to True, the exception propagates
         """
         with self.assertRaises(SomeOtherException):
-            self.engine.render_to_string('filter-syntax14', {"var": SomeClass()})
+            self.engine.render_to_string("filter-syntax14", {"var": SomeClass()})
 
-    @setup({'filter-syntax15': r'{{ var|default_if_none:"foo\bar" }}'})
+    @setup({"filter-syntax15": r'{{ var|default_if_none:"foo\bar" }}'})
     def test_filter_syntax15(self):
         """
         Escaped backslash in argument
         """
-        output = self.engine.render_to_string('filter-syntax15', {"var": None})
-        self.assertEqual(output, r'foo\bar')
+        output = self.engine.render_to_string("filter-syntax15", {"var": None})
+        self.assertEqual(output, r"foo\bar")
 
-    @setup({'filter-syntax16': r'{{ var|default_if_none:"foo\now" }}'})
+    @setup({"filter-syntax16": r'{{ var|default_if_none:"foo\now" }}'})
     def test_filter_syntax16(self):
         """
         Escaped backslash using known escape char
         """
-        output = self.engine.render_to_string('filter-syntax16', {"var": None})
-        self.assertEqual(output, r'foo\now')
+        output = self.engine.render_to_string("filter-syntax16", {"var": None})
+        self.assertEqual(output, r"foo\now")
 
-    @setup({'filter-syntax17': r'{{ var|join:"" }}'})
+    @setup({"filter-syntax17": r'{{ var|join:"" }}'})
     def test_filter_syntax17(self):
         """
         Empty strings can be passed as arguments to filters
         """
-        output = self.engine.render_to_string('filter-syntax17', {'var': ['a', 'b', 'c']})
-        self.assertEqual(output, 'abc')
+        output = self.engine.render_to_string(
+            "filter-syntax17", {"var": ["a", "b", "c"]}
+        )
+        self.assertEqual(output, "abc")
 
-    @setup({'filter-syntax18': r'{{ var }}'})
+    @setup({"filter-syntax18": r"{{ var }}"})
     def test_filter_syntax18(self):
         """
         Strings are converted to bytestrings in the final output.
         """
-        output = self.engine.render_to_string('filter-syntax18', {'var': UTF8Class()})
-        self.assertEqual(output, '\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111')
+        output = self.engine.render_to_string("filter-syntax18", {"var": UTF8Class()})
+        self.assertEqual(output, "\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111")
 
-    @setup({'filter-syntax19': '{{ var|truncatewords:1 }}'})
+    @setup({"filter-syntax19": "{{ var|truncatewords:1 }}"})
     def test_filter_syntax19(self):
         """
         Numbers as filter arguments should work
         """
-        output = self.engine.render_to_string('filter-syntax19', {"var": "hello world"})
+        output = self.engine.render_to_string("filter-syntax19", {"var": "hello world"})
         self.assertEqual(output, "hello …")
 
-    @setup({'filter-syntax20': '{{ ""|default_if_none:"was none" }}'})
+    @setup({"filter-syntax20": '{{ ""|default_if_none:"was none" }}'})
     def test_filter_syntax20(self):
         """
         Filters should accept empty string constants
         """
-        output = self.engine.render_to_string('filter-syntax20')
+        output = self.engine.render_to_string("filter-syntax20")
         self.assertEqual(output, "")
 
-    @setup({'filter-syntax21': r'1{{ var.silent_fail_key }}2'})
+    @setup({"filter-syntax21": r"1{{ var.silent_fail_key }}2"})
     def test_filter_syntax21(self):
         """
         Fail silently for non-callable attribute and dict lookups which
         raise an exception with a "silent_variable_failure" attribute
         """
-        output = self.engine.render_to_string('filter-syntax21', {"var": SomeClass()})
+        output = self.engine.render_to_string("filter-syntax21", {"var": SomeClass()})
         if self.engine.string_if_invalid:
             self.assertEqual(output, "1INVALID2")
         else:
             self.assertEqual(output, "12")
 
-    @setup({'filter-syntax22': r'1{{ var.silent_fail_attribute }}2'})
+    @setup({"filter-syntax22": r"1{{ var.silent_fail_attribute }}2"})
     def test_filter_syntax22(self):
         """
         Fail silently for non-callable attribute and dict lookups which
         raise an exception with a `silent_variable_failure` attribute
         """
-        output = self.engine.render_to_string('filter-syntax22', {"var": SomeClass()})
+        output = self.engine.render_to_string("filter-syntax22", {"var": SomeClass()})
         if self.engine.string_if_invalid:
             self.assertEqual(output, "1INVALID2")
         else:
             self.assertEqual(output, "12")
 
-    @setup({'filter-syntax23': r'1{{ var.noisy_fail_key }}2'})
+    @setup({"filter-syntax23": r"1{{ var.noisy_fail_key }}2"})
     def test_filter_syntax23(self):
         """
         In attribute and dict lookups that raise an unexpected exception
@@ -210,9 +223,9 @@ class FilterSyntaxTests(SimpleTestCase):
         propagates
         """
         with self.assertRaises(SomeOtherException):
-            self.engine.render_to_string('filter-syntax23', {"var": SomeClass()})
+            self.engine.render_to_string("filter-syntax23", {"var": SomeClass()})
 
-    @setup({'filter-syntax24': r'1{{ var.noisy_fail_attribute }}2'})
+    @setup({"filter-syntax24": r"1{{ var.noisy_fail_attribute }}2"})
     def test_filter_syntax24(self):
         """
         In attribute and dict lookups that raise an unexpected exception
@@ -220,18 +233,18 @@ class FilterSyntaxTests(SimpleTestCase):
         propagates
         """
         with self.assertRaises(SomeOtherException):
-            self.engine.render_to_string('filter-syntax24', {"var": SomeClass()})
+            self.engine.render_to_string("filter-syntax24", {"var": SomeClass()})
 
-    @setup({'filter-syntax25': '{{ var.attribute_error_attribute }}'})
+    @setup({"filter-syntax25": "{{ var.attribute_error_attribute }}"})
     def test_filter_syntax25(self):
         """
         #16383 - Attribute errors from an @property value should be
         reraised.
         """
         with self.assertRaises(AttributeError):
-            self.engine.render_to_string('filter-syntax25', {'var': SomeClass()})
+            self.engine.render_to_string("filter-syntax25", {"var": SomeClass()})
 
-    @setup({'template': '{{ var.type_error_attribute }}'})
+    @setup({"template": "{{ var.type_error_attribute }}"})
     def test_type_error_attribute(self):
         with self.assertRaises(TypeError):
-            self.engine.render_to_string('template', {'var': SomeClass()})
+            self.engine.render_to_string("template", {"var": SomeClass()})
diff --git a/tests/template_tests/syntax_tests/test_filter_tag.py b/tests/template_tests/syntax_tests/test_filter_tag.py
index 003140a105..0722fd8b27 100644
--- a/tests/template_tests/syntax_tests/test_filter_tag.py
+++ b/tests/template_tests/syntax_tests/test_filter_tag.py
@@ -5,43 +5,42 @@ from ..utils import setup
 
 
 class FilterTagTests(SimpleTestCase):
-
-    @setup({'filter01': '{% filter upper %}{% endfilter %}'})
+    @setup({"filter01": "{% filter upper %}{% endfilter %}"})
     def test_filter01(self):
-        output = self.engine.render_to_string('filter01')
-        self.assertEqual(output, '')
+        output = self.engine.render_to_string("filter01")
+        self.assertEqual(output, "")
 
-    @setup({'filter02': '{% filter upper %}django{% endfilter %}'})
+    @setup({"filter02": "{% filter upper %}django{% endfilter %}"})
     def test_filter02(self):
-        output = self.engine.render_to_string('filter02')
-        self.assertEqual(output, 'DJANGO')
+        output = self.engine.render_to_string("filter02")
+        self.assertEqual(output, "DJANGO")
 
-    @setup({'filter03': '{% filter upper|lower %}django{% endfilter %}'})
+    @setup({"filter03": "{% filter upper|lower %}django{% endfilter %}"})
     def test_filter03(self):
-        output = self.engine.render_to_string('filter03')
-        self.assertEqual(output, 'django')
+        output = self.engine.render_to_string("filter03")
+        self.assertEqual(output, "django")
 
-    @setup({'filter04': '{% filter cut:remove %}djangospam{% endfilter %}'})
+    @setup({"filter04": "{% filter cut:remove %}djangospam{% endfilter %}"})
     def test_filter04(self):
-        output = self.engine.render_to_string('filter04', {'remove': 'spam'})
-        self.assertEqual(output, 'django')
+        output = self.engine.render_to_string("filter04", {"remove": "spam"})
+        self.assertEqual(output, "django")
 
-    @setup({'filter05': '{% filter safe %}fail{% endfilter %}'})
+    @setup({"filter05": "{% filter safe %}fail{% endfilter %}"})
     def test_filter05(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('filter05')
+            self.engine.get_template("filter05")
 
-    @setup({'filter05bis': '{% filter upper|safe %}fail{% endfilter %}'})
+    @setup({"filter05bis": "{% filter upper|safe %}fail{% endfilter %}"})
     def test_filter05bis(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('filter05bis')
+            self.engine.get_template("filter05bis")
 
-    @setup({'filter06': '{% filter escape %}fail{% endfilter %}'})
+    @setup({"filter06": "{% filter escape %}fail{% endfilter %}"})
     def test_filter06(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('filter06')
+            self.engine.get_template("filter06")
 
-    @setup({'filter06bis': '{% filter upper|escape %}fail{% endfilter %}'})
+    @setup({"filter06bis": "{% filter upper|escape %}fail{% endfilter %}"})
     def test_filter06bis(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('filter06bis')
+            self.engine.get_template("filter06bis")
diff --git a/tests/template_tests/syntax_tests/test_firstof.py b/tests/template_tests/syntax_tests/test_firstof.py
index cc8df211eb..72f0223d5d 100644
--- a/tests/template_tests/syntax_tests/test_firstof.py
+++ b/tests/template_tests/syntax_tests/test_firstof.py
@@ -5,87 +5,86 @@ from ..utils import setup
 
 
 class FirstOfTagTests(SimpleTestCase):
-
-    @setup({'firstof01': '{% firstof a b c %}'})
+    @setup({"firstof01": "{% firstof a b c %}"})
     def test_firstof01(self):
-        output = self.engine.render_to_string('firstof01', {'a': 0, 'c': 0, 'b': 0})
-        self.assertEqual(output, '')
+        output = self.engine.render_to_string("firstof01", {"a": 0, "c": 0, "b": 0})
+        self.assertEqual(output, "")
 
-    @setup({'firstof02': '{% firstof a b c %}'})
+    @setup({"firstof02": "{% firstof a b c %}"})
     def test_firstof02(self):
-        output = self.engine.render_to_string('firstof02', {'a': 1, 'c': 0, 'b': 0})
-        self.assertEqual(output, '1')
+        output = self.engine.render_to_string("firstof02", {"a": 1, "c": 0, "b": 0})
+        self.assertEqual(output, "1")
 
-    @setup({'firstof03': '{% firstof a b c %}'})
+    @setup({"firstof03": "{% firstof a b c %}"})
     def test_firstof03(self):
-        output = self.engine.render_to_string('firstof03', {'a': 0, 'c': 0, 'b': 2})
-        self.assertEqual(output, '2')
+        output = self.engine.render_to_string("firstof03", {"a": 0, "c": 0, "b": 2})
+        self.assertEqual(output, "2")
 
-    @setup({'firstof04': '{% firstof a b c %}'})
+    @setup({"firstof04": "{% firstof a b c %}"})
     def test_firstof04(self):
-        output = self.engine.render_to_string('firstof04', {'a': 0, 'c': 3, 'b': 0})
-        self.assertEqual(output, '3')
+        output = self.engine.render_to_string("firstof04", {"a": 0, "c": 3, "b": 0})
+        self.assertEqual(output, "3")
 
-    @setup({'firstof05': '{% firstof a b c %}'})
+    @setup({"firstof05": "{% firstof a b c %}"})
     def test_firstof05(self):
-        output = self.engine.render_to_string('firstof05', {'a': 1, 'c': 3, 'b': 2})
-        self.assertEqual(output, '1')
+        output = self.engine.render_to_string("firstof05", {"a": 1, "c": 3, "b": 2})
+        self.assertEqual(output, "1")
 
-    @setup({'firstof06': '{% firstof a b c %}'})
+    @setup({"firstof06": "{% firstof a b c %}"})
     def test_firstof06(self):
-        output = self.engine.render_to_string('firstof06', {'c': 3, 'b': 0})
-        self.assertEqual(output, '3')
+        output = self.engine.render_to_string("firstof06", {"c": 3, "b": 0})
+        self.assertEqual(output, "3")
 
-    @setup({'firstof07': '{% firstof a b "c" %}'})
+    @setup({"firstof07": '{% firstof a b "c" %}'})
     def test_firstof07(self):
-        output = self.engine.render_to_string('firstof07', {'a': 0})
-        self.assertEqual(output, 'c')
+        output = self.engine.render_to_string("firstof07", {"a": 0})
+        self.assertEqual(output, "c")
 
-    @setup({'firstof08': '{% firstof a b "c and d" %}'})
+    @setup({"firstof08": '{% firstof a b "c and d" %}'})
     def test_firstof08(self):
-        output = self.engine.render_to_string('firstof08', {'a': 0, 'b': 0})
-        self.assertEqual(output, 'c and d')
+        output = self.engine.render_to_string("firstof08", {"a": 0, "b": 0})
+        self.assertEqual(output, "c and d")
 
-    @setup({'firstof09': '{% firstof %}'})
+    @setup({"firstof09": "{% firstof %}"})
     def test_firstof09(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('firstof09')
+            self.engine.get_template("firstof09")
 
-    @setup({'firstof10': '{% firstof a %}'})
+    @setup({"firstof10": "{% firstof a %}"})
     def test_firstof10(self):
-        output = self.engine.render_to_string('firstof10', {'a': '<'})
-        self.assertEqual(output, '&lt;')
+        output = self.engine.render_to_string("firstof10", {"a": "<"})
+        self.assertEqual(output, "&lt;")
 
-    @setup({'firstof11': '{% firstof a b %}'})
+    @setup({"firstof11": "{% firstof a b %}"})
     def test_firstof11(self):
-        output = self.engine.render_to_string('firstof11', {'a': '<', 'b': '>'})
-        self.assertEqual(output, '&lt;')
+        output = self.engine.render_to_string("firstof11", {"a": "<", "b": ">"})
+        self.assertEqual(output, "&lt;")
 
-    @setup({'firstof12': '{% firstof a b %}'})
+    @setup({"firstof12": "{% firstof a b %}"})
     def test_firstof12(self):
-        output = self.engine.render_to_string('firstof12', {'a': '', 'b': '>'})
-        self.assertEqual(output, '&gt;')
+        output = self.engine.render_to_string("firstof12", {"a": "", "b": ">"})
+        self.assertEqual(output, "&gt;")
 
-    @setup({'firstof13': '{% autoescape off %}{% firstof a %}{% endautoescape %}'})
+    @setup({"firstof13": "{% autoescape off %}{% firstof a %}{% endautoescape %}"})
     def test_firstof13(self):
-        output = self.engine.render_to_string('firstof13', {'a': '<'})
-        self.assertEqual(output, '<')
+        output = self.engine.render_to_string("firstof13", {"a": "<"})
+        self.assertEqual(output, "<")
 
-    @setup({'firstof14': '{% firstof a|safe b %}'})
+    @setup({"firstof14": "{% firstof a|safe b %}"})
     def test_firstof14(self):
-        output = self.engine.render_to_string('firstof14', {'a': '<'})
-        self.assertEqual(output, '<')
+        output = self.engine.render_to_string("firstof14", {"a": "<"})
+        self.assertEqual(output, "<")
 
-    @setup({'firstof15': '{% firstof a b c as myvar %}'})
+    @setup({"firstof15": "{% firstof a b c as myvar %}"})
     def test_firstof15(self):
-        ctx = {'a': 0, 'b': 2, 'c': 3}
-        output = self.engine.render_to_string('firstof15', ctx)
-        self.assertEqual(ctx['myvar'], '2')
-        self.assertEqual(output, '')
+        ctx = {"a": 0, "b": 2, "c": 3}
+        output = self.engine.render_to_string("firstof15", ctx)
+        self.assertEqual(ctx["myvar"], "2")
+        self.assertEqual(output, "")
 
-    @setup({'firstof16': '{% firstof a b c as myvar %}'})
+    @setup({"firstof16": "{% firstof a b c as myvar %}"})
     def test_all_false_arguments_asvar(self):
-        ctx = {'a': 0, 'b': 0, 'c': 0}
-        output = self.engine.render_to_string('firstof16', ctx)
-        self.assertEqual(ctx['myvar'], '')
-        self.assertEqual(output, '')
+        ctx = {"a": 0, "b": 0, "c": 0}
+        output = self.engine.render_to_string("firstof16", ctx)
+        self.assertEqual(ctx["myvar"], "")
+        self.assertEqual(output, "")
diff --git a/tests/template_tests/syntax_tests/test_for.py b/tests/template_tests/syntax_tests/test_for.py
index d7db6108a2..ad1d158f9b 100644
--- a/tests/template_tests/syntax_tests/test_for.py
+++ b/tests/template_tests/syntax_tests/test_for.py
@@ -6,213 +6,333 @@ from ..utils import setup
 
 
 class ForTagTests(SimpleTestCase):
-    libraries = {'custom': 'template_tests.templatetags.custom'}
+    libraries = {"custom": "template_tests.templatetags.custom"}
 
-    @setup({'for-tag01': '{% for val in values %}{{ val }}{% endfor %}'})
+    @setup({"for-tag01": "{% for val in values %}{{ val }}{% endfor %}"})
     def test_for_tag01(self):
-        output = self.engine.render_to_string('for-tag01', {'values': [1, 2, 3]})
-        self.assertEqual(output, '123')
+        output = self.engine.render_to_string("for-tag01", {"values": [1, 2, 3]})
+        self.assertEqual(output, "123")
 
-    @setup({'for-tag02': '{% for val in values reversed %}{{ val }}{% endfor %}'})
+    @setup({"for-tag02": "{% for val in values reversed %}{{ val }}{% endfor %}"})
     def test_for_tag02(self):
-        output = self.engine.render_to_string('for-tag02', {'values': [1, 2, 3]})
-        self.assertEqual(output, '321')
+        output = self.engine.render_to_string("for-tag02", {"values": [1, 2, 3]})
+        self.assertEqual(output, "321")
 
-    @setup({'for-tag-vars01': '{% for val in values %}{{ forloop.counter }}{% endfor %}'})
+    @setup(
+        {"for-tag-vars01": "{% for val in values %}{{ forloop.counter }}{% endfor %}"}
+    )
     def test_for_tag_vars01(self):
-        output = self.engine.render_to_string('for-tag-vars01', {'values': [6, 6, 6]})
-        self.assertEqual(output, '123')
+        output = self.engine.render_to_string("for-tag-vars01", {"values": [6, 6, 6]})
+        self.assertEqual(output, "123")
 
-    @setup({'for-tag-vars02': '{% for val in values %}{{ forloop.counter0 }}{% endfor %}'})
+    @setup(
+        {"for-tag-vars02": "{% for val in values %}{{ forloop.counter0 }}{% endfor %}"}
+    )
     def test_for_tag_vars02(self):
-        output = self.engine.render_to_string('for-tag-vars02', {'values': [6, 6, 6]})
-        self.assertEqual(output, '012')
+        output = self.engine.render_to_string("for-tag-vars02", {"values": [6, 6, 6]})
+        self.assertEqual(output, "012")
 
-    @setup({'for-tag-vars03': '{% for val in values %}{{ forloop.revcounter }}{% endfor %}'})
+    @setup(
+        {
+            "for-tag-vars03": "{% for val in values %}{{ forloop.revcounter }}{% endfor %}"
+        }
+    )
     def test_for_tag_vars03(self):
-        output = self.engine.render_to_string('for-tag-vars03', {'values': [6, 6, 6]})
-        self.assertEqual(output, '321')
+        output = self.engine.render_to_string("for-tag-vars03", {"values": [6, 6, 6]})
+        self.assertEqual(output, "321")
 
-    @setup({'for-tag-vars04': '{% for val in values %}{{ forloop.revcounter0 }}{% endfor %}'})
+    @setup(
+        {
+            "for-tag-vars04": "{% for val in values %}{{ forloop.revcounter0 }}{% endfor %}"
+        }
+    )
     def test_for_tag_vars04(self):
-        output = self.engine.render_to_string('for-tag-vars04', {'values': [6, 6, 6]})
-        self.assertEqual(output, '210')
+        output = self.engine.render_to_string("for-tag-vars04", {"values": [6, 6, 6]})
+        self.assertEqual(output, "210")
 
-    @setup({'for-tag-vars05': '{% for val in values %}'
-                              '{% if forloop.first %}f{% else %}x{% endif %}{% endfor %}'})
+    @setup(
+        {
+            "for-tag-vars05": "{% for val in values %}"
+            "{% if forloop.first %}f{% else %}x{% endif %}{% endfor %}"
+        }
+    )
     def test_for_tag_vars05(self):
-        output = self.engine.render_to_string('for-tag-vars05', {'values': [6, 6, 6]})
-        self.assertEqual(output, 'fxx')
+        output = self.engine.render_to_string("for-tag-vars05", {"values": [6, 6, 6]})
+        self.assertEqual(output, "fxx")
 
-    @setup({'for-tag-vars06': '{% for val in values %}'
-                              '{% if forloop.last %}l{% else %}x{% endif %}{% endfor %}'})
+    @setup(
+        {
+            "for-tag-vars06": "{% for val in values %}"
+            "{% if forloop.last %}l{% else %}x{% endif %}{% endfor %}"
+        }
+    )
     def test_for_tag_vars06(self):
-        output = self.engine.render_to_string('for-tag-vars06', {'values': [6, 6, 6]})
-        self.assertEqual(output, 'xxl')
+        output = self.engine.render_to_string("for-tag-vars06", {"values": [6, 6, 6]})
+        self.assertEqual(output, "xxl")
 
-    @setup({'for-tag-unpack01': '{% for key,value in items %}{{ key }}:{{ value }}/{% endfor %}'})
+    @setup(
+        {
+            "for-tag-unpack01": "{% for key,value in items %}{{ key }}:{{ value }}/{% endfor %}"
+        }
+    )
     def test_for_tag_unpack01(self):
-        output = self.engine.render_to_string('for-tag-unpack01', {'items': (('one', 1), ('two', 2))})
-        self.assertEqual(output, 'one:1/two:2/')
+        output = self.engine.render_to_string(
+            "for-tag-unpack01", {"items": (("one", 1), ("two", 2))}
+        )
+        self.assertEqual(output, "one:1/two:2/")
 
-    @setup({'for-tag-unpack03': '{% for key, value in items %}{{ key }}:{{ value }}/{% endfor %}'})
+    @setup(
+        {
+            "for-tag-unpack03": "{% for key, value in items %}{{ key }}:{{ value }}/{% endfor %}"
+        }
+    )
     def test_for_tag_unpack03(self):
-        output = self.engine.render_to_string('for-tag-unpack03', {'items': (('one', 1), ('two', 2))})
-        self.assertEqual(output, 'one:1/two:2/')
+        output = self.engine.render_to_string(
+            "for-tag-unpack03", {"items": (("one", 1), ("two", 2))}
+        )
+        self.assertEqual(output, "one:1/two:2/")
 
-    @setup({'for-tag-unpack04': '{% for key , value in items %}{{ key }}:{{ value }}/{% endfor %}'})
+    @setup(
+        {
+            "for-tag-unpack04": "{% for key , value in items %}{{ key }}:{{ value }}/{% endfor %}"
+        }
+    )
     def test_for_tag_unpack04(self):
-        output = self.engine.render_to_string('for-tag-unpack04', {'items': (('one', 1), ('two', 2))})
-        self.assertEqual(output, 'one:1/two:2/')
+        output = self.engine.render_to_string(
+            "for-tag-unpack04", {"items": (("one", 1), ("two", 2))}
+        )
+        self.assertEqual(output, "one:1/two:2/")
 
-    @setup({'for-tag-unpack05': '{% for key ,value in items %}{{ key }}:{{ value }}/{% endfor %}'})
+    @setup(
+        {
+            "for-tag-unpack05": "{% for key ,value in items %}{{ key }}:{{ value }}/{% endfor %}"
+        }
+    )
     def test_for_tag_unpack05(self):
-        output = self.engine.render_to_string('for-tag-unpack05', {'items': (('one', 1), ('two', 2))})
-        self.assertEqual(output, 'one:1/two:2/')
+        output = self.engine.render_to_string(
+            "for-tag-unpack05", {"items": (("one", 1), ("two", 2))}
+        )
+        self.assertEqual(output, "one:1/two:2/")
 
-    @setup({'for-tag-unpack06': '{% for key value in items %}{{ key }}:{{ value }}/{% endfor %}'})
+    @setup(
+        {
+            "for-tag-unpack06": "{% for key value in items %}{{ key }}:{{ value }}/{% endfor %}"
+        }
+    )
     def test_for_tag_unpack06(self):
         msg = "'for' tag received an invalid argument: for key value in items"
         with self.assertRaisesMessage(TemplateSyntaxError, msg):
-            self.engine.render_to_string('for-tag-unpack06', {'items': (('one', 1), ('two', 2))})
+            self.engine.render_to_string(
+                "for-tag-unpack06", {"items": (("one", 1), ("two", 2))}
+            )
 
-    @setup({'for-tag-unpack07': '{% for key,,value in items %}{{ key }}:{{ value }}/{% endfor %}'})
+    @setup(
+        {
+            "for-tag-unpack07": "{% for key,,value in items %}{{ key }}:{{ value }}/{% endfor %}"
+        }
+    )
     def test_for_tag_unpack07(self):
         msg = "'for' tag received an invalid argument: for key,,value in items"
         with self.assertRaisesMessage(TemplateSyntaxError, msg):
-            self.engine.render_to_string('for-tag-unpack07', {'items': (('one', 1), ('two', 2))})
+            self.engine.render_to_string(
+                "for-tag-unpack07", {"items": (("one", 1), ("two", 2))}
+            )
 
-    @setup({'for-tag-unpack08': '{% for key,value, in items %}{{ key }}:{{ value }}/{% endfor %}'})
+    @setup(
+        {
+            "for-tag-unpack08": "{% for key,value, in items %}{{ key }}:{{ value }}/{% endfor %}"
+        }
+    )
     def test_for_tag_unpack08(self):
         msg = "'for' tag received an invalid argument: for key,value, in items"
         with self.assertRaisesMessage(TemplateSyntaxError, msg):
-            self.engine.render_to_string('for-tag-unpack08', {'items': (('one', 1), ('two', 2))})
+            self.engine.render_to_string(
+                "for-tag-unpack08", {"items": (("one", 1), ("two", 2))}
+            )
 
-    @setup({'double-quote': '{% for "k" in items %}{{ "k" }}/{% endfor %}'})
+    @setup({"double-quote": '{% for "k" in items %}{{ "k" }}/{% endfor %}'})
     def test_unpack_double_quote(self):
         msg = """'for' tag received an invalid argument: for "k" in items"""
         with self.assertRaisesMessage(TemplateSyntaxError, msg):
-            self.engine.render_to_string('double-quote', {'items': (1, 2)})
+            self.engine.render_to_string("double-quote", {"items": (1, 2)})
 
-    @setup({'single-quote': "{% for 'k' in items %}{{ k }}/{% endfor %}"})
+    @setup({"single-quote": "{% for 'k' in items %}{{ k }}/{% endfor %}"})
     def test_unpack_single_quote(self):
         msg = """'for' tag received an invalid argument: for 'k' in items"""
         with self.assertRaisesMessage(TemplateSyntaxError, msg):
-            self.engine.render_to_string('single-quote', {'items': (1, 2)})
+            self.engine.render_to_string("single-quote", {"items": (1, 2)})
 
-    @setup({'vertical-bar': '{% for k|upper in items %}{{ k|upper }}/{% endfor %}'})
+    @setup({"vertical-bar": "{% for k|upper in items %}{{ k|upper }}/{% endfor %}"})
     def test_unpack_vertical_bar(self):
         msg = "'for' tag received an invalid argument: for k|upper in items"
         with self.assertRaisesMessage(TemplateSyntaxError, msg):
-            self.engine.render_to_string('vertical-bar', {'items': (1, 2)})
+            self.engine.render_to_string("vertical-bar", {"items": (1, 2)})
 
-    @setup({'for-tag-unpack09': '{% for val in items %}{{ val.0 }}:{{ val.1 }}/{% endfor %}'})
+    @setup(
+        {
+            "for-tag-unpack09": "{% for val in items %}{{ val.0 }}:{{ val.1 }}/{% endfor %}"
+        }
+    )
     def test_for_tag_unpack09(self):
         """
         A single loopvar doesn't truncate the list in val.
         """
-        output = self.engine.render_to_string('for-tag-unpack09', {'items': (('one', 1), ('two', 2))})
-        self.assertEqual(output, 'one:1/two:2/')
+        output = self.engine.render_to_string(
+            "for-tag-unpack09", {"items": (("one", 1), ("two", 2))}
+        )
+        self.assertEqual(output, "one:1/two:2/")
 
-    @setup({'for-tag-unpack13': '{% for x,y,z in items %}{{ x }}:{{ y }},{{ z }}/{% endfor %}'})
+    @setup(
+        {
+            "for-tag-unpack13": "{% for x,y,z in items %}{{ x }}:{{ y }},{{ z }}/{% endfor %}"
+        }
+    )
     def test_for_tag_unpack13(self):
         output = self.engine.render_to_string(
-            'for-tag-unpack13', {'items': (('one', 1, 'carrot'), ('two', 2, 'cheese'))}
+            "for-tag-unpack13", {"items": (("one", 1, "carrot"), ("two", 2, "cheese"))}
         )
         if self.engine.string_if_invalid:
-            self.assertEqual(output, 'one:1,carrot/two:2,cheese/')
+            self.assertEqual(output, "one:1,carrot/two:2,cheese/")
         else:
-            self.assertEqual(output, 'one:1,carrot/two:2,cheese/')
+            self.assertEqual(output, "one:1,carrot/two:2,cheese/")
 
-    @setup({'for-tag-empty01': '{% for val in values %}{{ val }}{% empty %}empty text{% endfor %}'})
+    @setup(
+        {
+            "for-tag-empty01": "{% for val in values %}{{ val }}{% empty %}empty text{% endfor %}"
+        }
+    )
     def test_for_tag_empty01(self):
-        output = self.engine.render_to_string('for-tag-empty01', {'values': [1, 2, 3]})
-        self.assertEqual(output, '123')
+        output = self.engine.render_to_string("for-tag-empty01", {"values": [1, 2, 3]})
+        self.assertEqual(output, "123")
 
-    @setup({'for-tag-empty02': '{% for val in values %}{{ val }}{% empty %}values array empty{% endfor %}'})
+    @setup(
+        {
+            "for-tag-empty02": "{% for val in values %}{{ val }}{% empty %}values array empty{% endfor %}"
+        }
+    )
     def test_for_tag_empty02(self):
-        output = self.engine.render_to_string('for-tag-empty02', {'values': []})
-        self.assertEqual(output, 'values array empty')
+        output = self.engine.render_to_string("for-tag-empty02", {"values": []})
+        self.assertEqual(output, "values array empty")
 
-    @setup({'for-tag-empty03': '{% for val in values %}'
-                               '{{ val }}{% empty %}values array not found{% endfor %}'})
+    @setup(
+        {
+            "for-tag-empty03": "{% for val in values %}"
+            "{{ val }}{% empty %}values array not found{% endfor %}"
+        }
+    )
     def test_for_tag_empty03(self):
-        output = self.engine.render_to_string('for-tag-empty03')
-        self.assertEqual(output, 'values array not found')
+        output = self.engine.render_to_string("for-tag-empty03")
+        self.assertEqual(output, "values array not found")
 
-    @setup({'for-tag-filter-ws': "{% load custom %}{% for x in s|noop:'x y' %}{{ x }}{% endfor %}"})
+    @setup(
+        {
+            "for-tag-filter-ws": "{% load custom %}{% for x in s|noop:'x y' %}{{ x }}{% endfor %}"
+        }
+    )
     def test_for_tag_filter_ws(self):
         """
         #19882
         """
-        output = self.engine.render_to_string('for-tag-filter-ws', {'s': 'abc'})
-        self.assertEqual(output, 'abc')
+        output = self.engine.render_to_string("for-tag-filter-ws", {"s": "abc"})
+        self.assertEqual(output, "abc")
 
-    @setup({'for-tag-unpack-strs': '{% for x,y in items %}{{ x }}:{{ y }}/{% endfor %}'})
+    @setup(
+        {"for-tag-unpack-strs": "{% for x,y in items %}{{ x }}:{{ y }}/{% endfor %}"}
+    )
     def test_for_tag_unpack_strs(self):
-        output = self.engine.render_to_string('for-tag-unpack-strs', {'items': ('ab', 'ac')})
-        self.assertEqual(output, 'a:b/a:c/')
+        output = self.engine.render_to_string(
+            "for-tag-unpack-strs", {"items": ("ab", "ac")}
+        )
+        self.assertEqual(output, "a:b/a:c/")
 
-    @setup({'for-tag-unpack10': '{% for x,y in items %}{{ x }}:{{ y }}/{% endfor %}'})
+    @setup({"for-tag-unpack10": "{% for x,y in items %}{{ x }}:{{ y }}/{% endfor %}"})
     def test_for_tag_unpack10(self):
-        with self.assertRaisesMessage(ValueError, 'Need 2 values to unpack in for loop; got 3.'):
+        with self.assertRaisesMessage(
+            ValueError, "Need 2 values to unpack in for loop; got 3."
+        ):
             self.engine.render_to_string(
-                'for-tag-unpack10',
-                {'items': (('one', 1, 'carrot'), ('two', 2, 'orange'))},
+                "for-tag-unpack10",
+                {"items": (("one", 1, "carrot"), ("two", 2, "orange"))},
             )
 
-    @setup({'for-tag-unpack11': '{% for x,y,z in items %}{{ x }}:{{ y }},{{ z }}/{% endfor %}'})
+    @setup(
+        {
+            "for-tag-unpack11": "{% for x,y,z in items %}{{ x }}:{{ y }},{{ z }}/{% endfor %}"
+        }
+    )
     def test_for_tag_unpack11(self):
-        with self.assertRaisesMessage(ValueError, 'Need 3 values to unpack in for loop; got 2.'):
+        with self.assertRaisesMessage(
+            ValueError, "Need 3 values to unpack in for loop; got 2."
+        ):
             self.engine.render_to_string(
-                'for-tag-unpack11',
-                {'items': (('one', 1), ('two', 2))},
+                "for-tag-unpack11",
+                {"items": (("one", 1), ("two", 2))},
             )
 
-    @setup({'for-tag-unpack12': '{% for x,y,z in items %}{{ x }}:{{ y }},{{ z }}/{% endfor %}'})
+    @setup(
+        {
+            "for-tag-unpack12": "{% for x,y,z in items %}{{ x }}:{{ y }},{{ z }}/{% endfor %}"
+        }
+    )
     def test_for_tag_unpack12(self):
-        with self.assertRaisesMessage(ValueError, 'Need 3 values to unpack in for loop; got 2.'):
+        with self.assertRaisesMessage(
+            ValueError, "Need 3 values to unpack in for loop; got 2."
+        ):
             self.engine.render_to_string(
-                'for-tag-unpack12',
-                {'items': (('one', 1, 'carrot'), ('two', 2))}
+                "for-tag-unpack12", {"items": (("one", 1, "carrot"), ("two", 2))}
             )
 
-    @setup({'for-tag-unpack14': '{% for x,y in items %}{{ x }}:{{ y }}/{% endfor %}'})
+    @setup({"for-tag-unpack14": "{% for x,y in items %}{{ x }}:{{ y }}/{% endfor %}"})
     def test_for_tag_unpack14(self):
-        with self.assertRaisesMessage(ValueError, 'Need 2 values to unpack in for loop; got 1.'):
-            self.engine.render_to_string('for-tag-unpack14', {'items': (1, 2)})
+        with self.assertRaisesMessage(
+            ValueError, "Need 2 values to unpack in for loop; got 1."
+        ):
+            self.engine.render_to_string("for-tag-unpack14", {"items": (1, 2)})
 
-    @setup({
-        'main': '{% with alpha=alpha.values %}{% include "base" %}{% endwith %}_'
-                '{% with alpha=alpha.extra %}{% include "base" %}{% endwith %}',
-        'base': '{% for x, y in alpha %}{{ x }}:{{ y }},{% endfor %}'
-    })
+    @setup(
+        {
+            "main": '{% with alpha=alpha.values %}{% include "base" %}{% endwith %}_'
+            '{% with alpha=alpha.extra %}{% include "base" %}{% endwith %}',
+            "base": "{% for x, y in alpha %}{{ x }}:{{ y }},{% endfor %}",
+        }
+    )
     def test_for_tag_context(self):
         """
         ForNode.render() pops the values it pushes to the context (#28001).
         """
-        output = self.engine.render_to_string('main', {
-            'alpha': {
-                'values': [('two', 2), ('four', 4)],
-                'extra': [('six', 6), ('eight', 8)],
+        output = self.engine.render_to_string(
+            "main",
+            {
+                "alpha": {
+                    "values": [("two", 2), ("four", 4)],
+                    "extra": [("six", 6), ("eight", 8)],
+                },
             },
-        })
-        self.assertEqual(output, 'two:2,four:4,_six:6,eight:8,')
+        )
+        self.assertEqual(output, "two:2,four:4,_six:6,eight:8,")
 
-    @setup({'invalid_for_loop': '{% for x items %}{{ x }}{% endfor %}'})
+    @setup({"invalid_for_loop": "{% for x items %}{{ x }}{% endfor %}"})
     def test_invalid_arg(self):
         msg = "'for' statements should have at least four words: for x items"
         with self.assertRaisesMessage(TemplateSyntaxError, msg):
-            self.engine.render_to_string('invalid_for_loop', {'items': (1, 2)})
+            self.engine.render_to_string("invalid_for_loop", {"items": (1, 2)})
 
-    @setup({'invalid_for_loop': '{% for x from items %}{{ x }}{% endfor %}'})
+    @setup({"invalid_for_loop": "{% for x from items %}{{ x }}{% endfor %}"})
     def test_invalid_in_keyword(self):
         msg = "'for' statements should use the format 'for x in y': for x from items"
         with self.assertRaisesMessage(TemplateSyntaxError, msg):
-            self.engine.render_to_string('invalid_for_loop', {'items': (1, 2)})
+            self.engine.render_to_string("invalid_for_loop", {"items": (1, 2)})
 
 
 class ForNodeTests(SimpleTestCase):
     def test_repr(self):
-        node = ForNode('x', 'sequence', is_reversed=True, nodelist_loop=['val'], nodelist_empty=['val2'])
-        self.assertEqual(repr(node), '<ForNode: for x in sequence, tail_len: 1 reversed>')
+        node = ForNode(
+            "x",
+            "sequence",
+            is_reversed=True,
+            nodelist_loop=["val"],
+            nodelist_empty=["val2"],
+        )
+        self.assertEqual(
+            repr(node), "<ForNode: for x in sequence, tail_len: 1 reversed>"
+        )
diff --git a/tests/template_tests/syntax_tests/test_if.py b/tests/template_tests/syntax_tests/test_if.py
index 711f871af9..fda44b0672 100644
--- a/tests/template_tests/syntax_tests/test_if.py
+++ b/tests/template_tests/syntax_tests/test_if.py
@@ -6,603 +6,694 @@ from ..utils import TestObj, setup
 
 
 class IfTagTests(SimpleTestCase):
-
-    @setup({'if-tag01': '{% if foo %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag01": "{% if foo %}yes{% else %}no{% endif %}"})
     def test_if_tag01(self):
-        output = self.engine.render_to_string('if-tag01', {'foo': True})
-        self.assertEqual(output, 'yes')
+        output = self.engine.render_to_string("if-tag01", {"foo": True})
+        self.assertEqual(output, "yes")
 
-    @setup({'if-tag02': '{% if foo %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag02": "{% if foo %}yes{% else %}no{% endif %}"})
     def test_if_tag02(self):
-        output = self.engine.render_to_string('if-tag02', {'foo': False})
-        self.assertEqual(output, 'no')
+        output = self.engine.render_to_string("if-tag02", {"foo": False})
+        self.assertEqual(output, "no")
 
-    @setup({'if-tag03': '{% if foo %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag03": "{% if foo %}yes{% else %}no{% endif %}"})
     def test_if_tag03(self):
-        output = self.engine.render_to_string('if-tag03')
-        self.assertEqual(output, 'no')
+        output = self.engine.render_to_string("if-tag03")
+        self.assertEqual(output, "no")
 
-    @setup({'if-tag04': '{% if foo %}foo{% elif bar %}bar{% endif %}'})
+    @setup({"if-tag04": "{% if foo %}foo{% elif bar %}bar{% endif %}"})
     def test_if_tag04(self):
-        output = self.engine.render_to_string('if-tag04', {'foo': True})
-        self.assertEqual(output, 'foo')
+        output = self.engine.render_to_string("if-tag04", {"foo": True})
+        self.assertEqual(output, "foo")
 
-    @setup({'if-tag05': '{% if foo %}foo{% elif bar %}bar{% endif %}'})
+    @setup({"if-tag05": "{% if foo %}foo{% elif bar %}bar{% endif %}"})
     def test_if_tag05(self):
-        output = self.engine.render_to_string('if-tag05', {'bar': True})
-        self.assertEqual(output, 'bar')
+        output = self.engine.render_to_string("if-tag05", {"bar": True})
+        self.assertEqual(output, "bar")
 
-    @setup({'if-tag06': '{% if foo %}foo{% elif bar %}bar{% endif %}'})
+    @setup({"if-tag06": "{% if foo %}foo{% elif bar %}bar{% endif %}"})
     def test_if_tag06(self):
-        output = self.engine.render_to_string('if-tag06')
-        self.assertEqual(output, '')
+        output = self.engine.render_to_string("if-tag06")
+        self.assertEqual(output, "")
 
-    @setup({'if-tag07': '{% if foo %}foo{% elif bar %}bar{% else %}nothing{% endif %}'})
+    @setup({"if-tag07": "{% if foo %}foo{% elif bar %}bar{% else %}nothing{% endif %}"})
     def test_if_tag07(self):
-        output = self.engine.render_to_string('if-tag07', {'foo': True})
-        self.assertEqual(output, 'foo')
+        output = self.engine.render_to_string("if-tag07", {"foo": True})
+        self.assertEqual(output, "foo")
 
-    @setup({'if-tag08': '{% if foo %}foo{% elif bar %}bar{% else %}nothing{% endif %}'})
+    @setup({"if-tag08": "{% if foo %}foo{% elif bar %}bar{% else %}nothing{% endif %}"})
     def test_if_tag08(self):
-        output = self.engine.render_to_string('if-tag08', {'bar': True})
-        self.assertEqual(output, 'bar')
+        output = self.engine.render_to_string("if-tag08", {"bar": True})
+        self.assertEqual(output, "bar")
 
-    @setup({'if-tag09': '{% if foo %}foo{% elif bar %}bar{% else %}nothing{% endif %}'})
+    @setup({"if-tag09": "{% if foo %}foo{% elif bar %}bar{% else %}nothing{% endif %}"})
     def test_if_tag09(self):
-        output = self.engine.render_to_string('if-tag09')
-        self.assertEqual(output, 'nothing')
+        output = self.engine.render_to_string("if-tag09")
+        self.assertEqual(output, "nothing")
 
-    @setup({'if-tag10': '{% if foo %}foo{% elif bar %}bar{% elif baz %}baz{% else %}nothing{% endif %}'})
+    @setup(
+        {
+            "if-tag10": "{% if foo %}foo{% elif bar %}bar{% elif baz %}baz{% else %}nothing{% endif %}"
+        }
+    )
     def test_if_tag10(self):
-        output = self.engine.render_to_string('if-tag10', {'foo': True})
-        self.assertEqual(output, 'foo')
+        output = self.engine.render_to_string("if-tag10", {"foo": True})
+        self.assertEqual(output, "foo")
 
-    @setup({'if-tag11': '{% if foo %}foo{% elif bar %}bar{% elif baz %}baz{% else %}nothing{% endif %}'})
+    @setup(
+        {
+            "if-tag11": "{% if foo %}foo{% elif bar %}bar{% elif baz %}baz{% else %}nothing{% endif %}"
+        }
+    )
     def test_if_tag11(self):
-        output = self.engine.render_to_string('if-tag11', {'bar': True})
-        self.assertEqual(output, 'bar')
+        output = self.engine.render_to_string("if-tag11", {"bar": True})
+        self.assertEqual(output, "bar")
 
-    @setup({'if-tag12': '{% if foo %}foo{% elif bar %}bar{% elif baz %}baz{% else %}nothing{% endif %}'})
+    @setup(
+        {
+            "if-tag12": "{% if foo %}foo{% elif bar %}bar{% elif baz %}baz{% else %}nothing{% endif %}"
+        }
+    )
     def test_if_tag12(self):
-        output = self.engine.render_to_string('if-tag12', {'baz': True})
-        self.assertEqual(output, 'baz')
+        output = self.engine.render_to_string("if-tag12", {"baz": True})
+        self.assertEqual(output, "baz")
 
-    @setup({'if-tag13': '{% if foo %}foo{% elif bar %}bar{% elif baz %}baz{% else %}nothing{% endif %}'})
+    @setup(
+        {
+            "if-tag13": "{% if foo %}foo{% elif bar %}bar{% elif baz %}baz{% else %}nothing{% endif %}"
+        }
+    )
     def test_if_tag13(self):
-        output = self.engine.render_to_string('if-tag13')
-        self.assertEqual(output, 'nothing')
+        output = self.engine.render_to_string("if-tag13")
+        self.assertEqual(output, "nothing")
 
     # Filters
-    @setup({'if-tag-filter01': '{% if foo|length == 5 %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-filter01": "{% if foo|length == 5 %}yes{% else %}no{% endif %}"})
     def test_if_tag_filter01(self):
-        output = self.engine.render_to_string('if-tag-filter01', {'foo': 'abcde'})
-        self.assertEqual(output, 'yes')
+        output = self.engine.render_to_string("if-tag-filter01", {"foo": "abcde"})
+        self.assertEqual(output, "yes")
 
-    @setup({'if-tag-filter02': '{% if foo|upper == \'ABC\' %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-filter02": "{% if foo|upper == 'ABC' %}yes{% else %}no{% endif %}"})
     def test_if_tag_filter02(self):
-        output = self.engine.render_to_string('if-tag-filter02')
-        self.assertEqual(output, 'no')
+        output = self.engine.render_to_string("if-tag-filter02")
+        self.assertEqual(output, "no")
 
     # Equality
-    @setup({'if-tag-eq01': '{% if foo == bar %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-eq01": "{% if foo == bar %}yes{% else %}no{% endif %}"})
     def test_if_tag_eq01(self):
-        output = self.engine.render_to_string('if-tag-eq01')
-        self.assertEqual(output, 'yes')
+        output = self.engine.render_to_string("if-tag-eq01")
+        self.assertEqual(output, "yes")
 
-    @setup({'if-tag-eq02': '{% if foo == bar %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-eq02": "{% if foo == bar %}yes{% else %}no{% endif %}"})
     def test_if_tag_eq02(self):
-        output = self.engine.render_to_string('if-tag-eq02', {'foo': 1})
-        self.assertEqual(output, 'no')
+        output = self.engine.render_to_string("if-tag-eq02", {"foo": 1})
+        self.assertEqual(output, "no")
 
-    @setup({'if-tag-eq03': '{% if foo == bar %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-eq03": "{% if foo == bar %}yes{% else %}no{% endif %}"})
     def test_if_tag_eq03(self):
-        output = self.engine.render_to_string('if-tag-eq03', {'foo': 1, 'bar': 1})
-        self.assertEqual(output, 'yes')
+        output = self.engine.render_to_string("if-tag-eq03", {"foo": 1, "bar": 1})
+        self.assertEqual(output, "yes")
 
-    @setup({'if-tag-eq04': '{% if foo == bar %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-eq04": "{% if foo == bar %}yes{% else %}no{% endif %}"})
     def test_if_tag_eq04(self):
-        output = self.engine.render_to_string('if-tag-eq04', {'foo': 1, 'bar': 2})
-        self.assertEqual(output, 'no')
+        output = self.engine.render_to_string("if-tag-eq04", {"foo": 1, "bar": 2})
+        self.assertEqual(output, "no")
 
-    @setup({'if-tag-eq05': '{% if foo == \'\' %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-eq05": "{% if foo == '' %}yes{% else %}no{% endif %}"})
     def test_if_tag_eq05(self):
-        output = self.engine.render_to_string('if-tag-eq05')
-        self.assertEqual(output, 'no')
+        output = self.engine.render_to_string("if-tag-eq05")
+        self.assertEqual(output, "no")
 
     # Inequality
-    @setup({'if-tag-noteq01': '{% if foo != bar %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-noteq01": "{% if foo != bar %}yes{% else %}no{% endif %}"})
     def test_if_tag_noteq01(self):
-        output = self.engine.render_to_string('if-tag-noteq01')
-        self.assertEqual(output, 'no')
+        output = self.engine.render_to_string("if-tag-noteq01")
+        self.assertEqual(output, "no")
 
-    @setup({'if-tag-noteq02': '{% if foo != bar %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-noteq02": "{% if foo != bar %}yes{% else %}no{% endif %}"})
     def test_if_tag_noteq02(self):
-        output = self.engine.render_to_string('if-tag-noteq02', {'foo': 1})
-        self.assertEqual(output, 'yes')
+        output = self.engine.render_to_string("if-tag-noteq02", {"foo": 1})
+        self.assertEqual(output, "yes")
 
-    @setup({'if-tag-noteq03': '{% if foo != bar %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-noteq03": "{% if foo != bar %}yes{% else %}no{% endif %}"})
     def test_if_tag_noteq03(self):
-        output = self.engine.render_to_string('if-tag-noteq03', {'foo': 1, 'bar': 1})
-        self.assertEqual(output, 'no')
+        output = self.engine.render_to_string("if-tag-noteq03", {"foo": 1, "bar": 1})
+        self.assertEqual(output, "no")
 
-    @setup({'if-tag-noteq04': '{% if foo != bar %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-noteq04": "{% if foo != bar %}yes{% else %}no{% endif %}"})
     def test_if_tag_noteq04(self):
-        output = self.engine.render_to_string('if-tag-noteq04', {'foo': 1, 'bar': 2})
-        self.assertEqual(output, 'yes')
+        output = self.engine.render_to_string("if-tag-noteq04", {"foo": 1, "bar": 2})
+        self.assertEqual(output, "yes")
 
-    @setup({'if-tag-noteq05': '{% if foo != "" %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-noteq05": '{% if foo != "" %}yes{% else %}no{% endif %}'})
     def test_if_tag_noteq05(self):
-        output = self.engine.render_to_string('if-tag-noteq05')
-        self.assertEqual(output, 'yes')
+        output = self.engine.render_to_string("if-tag-noteq05")
+        self.assertEqual(output, "yes")
 
     # Comparison
-    @setup({'if-tag-gt-01': '{% if 2 > 1 %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-gt-01": "{% if 2 > 1 %}yes{% else %}no{% endif %}"})
     def test_if_tag_gt_01(self):
-        output = self.engine.render_to_string('if-tag-gt-01')
-        self.assertEqual(output, 'yes')
+        output = self.engine.render_to_string("if-tag-gt-01")
+        self.assertEqual(output, "yes")
 
-    @setup({'if-tag-gt-02': '{% if 1 > 1 %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-gt-02": "{% if 1 > 1 %}yes{% else %}no{% endif %}"})
     def test_if_tag_gt_02(self):
-        output = self.engine.render_to_string('if-tag-gt-02')
-        self.assertEqual(output, 'no')
+        output = self.engine.render_to_string("if-tag-gt-02")
+        self.assertEqual(output, "no")
 
-    @setup({'if-tag-gte-01': '{% if 1 >= 1 %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-gte-01": "{% if 1 >= 1 %}yes{% else %}no{% endif %}"})
     def test_if_tag_gte_01(self):
-        output = self.engine.render_to_string('if-tag-gte-01')
-        self.assertEqual(output, 'yes')
+        output = self.engine.render_to_string("if-tag-gte-01")
+        self.assertEqual(output, "yes")
 
-    @setup({'if-tag-gte-02': '{% if 1 >= 2 %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-gte-02": "{% if 1 >= 2 %}yes{% else %}no{% endif %}"})
     def test_if_tag_gte_02(self):
-        output = self.engine.render_to_string('if-tag-gte-02')
-        self.assertEqual(output, 'no')
+        output = self.engine.render_to_string("if-tag-gte-02")
+        self.assertEqual(output, "no")
 
-    @setup({'if-tag-lt-01': '{% if 1 < 2 %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-lt-01": "{% if 1 < 2 %}yes{% else %}no{% endif %}"})
     def test_if_tag_lt_01(self):
-        output = self.engine.render_to_string('if-tag-lt-01')
-        self.assertEqual(output, 'yes')
+        output = self.engine.render_to_string("if-tag-lt-01")
+        self.assertEqual(output, "yes")
 
-    @setup({'if-tag-lt-02': '{% if 1 < 1 %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-lt-02": "{% if 1 < 1 %}yes{% else %}no{% endif %}"})
     def test_if_tag_lt_02(self):
-        output = self.engine.render_to_string('if-tag-lt-02')
-        self.assertEqual(output, 'no')
+        output = self.engine.render_to_string("if-tag-lt-02")
+        self.assertEqual(output, "no")
 
-    @setup({'if-tag-lte-01': '{% if 1 <= 1 %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-lte-01": "{% if 1 <= 1 %}yes{% else %}no{% endif %}"})
     def test_if_tag_lte_01(self):
-        output = self.engine.render_to_string('if-tag-lte-01')
-        self.assertEqual(output, 'yes')
+        output = self.engine.render_to_string("if-tag-lte-01")
+        self.assertEqual(output, "yes")
 
-    @setup({'if-tag-lte-02': '{% if 2 <= 1 %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-lte-02": "{% if 2 <= 1 %}yes{% else %}no{% endif %}"})
     def test_if_tag_lte_02(self):
-        output = self.engine.render_to_string('if-tag-lte-02')
-        self.assertEqual(output, 'no')
+        output = self.engine.render_to_string("if-tag-lte-02")
+        self.assertEqual(output, "no")
 
     # Contains
-    @setup({'if-tag-in-01': '{% if 1 in x %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-in-01": "{% if 1 in x %}yes{% else %}no{% endif %}"})
     def test_if_tag_in_01(self):
-        output = self.engine.render_to_string('if-tag-in-01', {'x': [1]})
-        self.assertEqual(output, 'yes')
+        output = self.engine.render_to_string("if-tag-in-01", {"x": [1]})
+        self.assertEqual(output, "yes")
 
-    @setup({'if-tag-in-02': '{% if 2 in x %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-in-02": "{% if 2 in x %}yes{% else %}no{% endif %}"})
     def test_if_tag_in_02(self):
-        output = self.engine.render_to_string('if-tag-in-02', {'x': [1]})
-        self.assertEqual(output, 'no')
+        output = self.engine.render_to_string("if-tag-in-02", {"x": [1]})
+        self.assertEqual(output, "no")
 
-    @setup({'if-tag-not-in-01': '{% if 1 not in x %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-not-in-01": "{% if 1 not in x %}yes{% else %}no{% endif %}"})
     def test_if_tag_not_in_01(self):
-        output = self.engine.render_to_string('if-tag-not-in-01', {'x': [1]})
-        self.assertEqual(output, 'no')
+        output = self.engine.render_to_string("if-tag-not-in-01", {"x": [1]})
+        self.assertEqual(output, "no")
 
-    @setup({'if-tag-not-in-02': '{% if 2 not in x %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-not-in-02": "{% if 2 not in x %}yes{% else %}no{% endif %}"})
     def test_if_tag_not_in_02(self):
-        output = self.engine.render_to_string('if-tag-not-in-02', {'x': [1]})
-        self.assertEqual(output, 'yes')
+        output = self.engine.render_to_string("if-tag-not-in-02", {"x": [1]})
+        self.assertEqual(output, "yes")
 
     # AND
-    @setup({'if-tag-and01': '{% if foo and bar %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-and01": "{% if foo and bar %}yes{% else %}no{% endif %}"})
     def test_if_tag_and01(self):
-        output = self.engine.render_to_string('if-tag-and01', {'foo': True, 'bar': True})
-        self.assertEqual(output, 'yes')
+        output = self.engine.render_to_string(
+            "if-tag-and01", {"foo": True, "bar": True}
+        )
+        self.assertEqual(output, "yes")
 
-    @setup({'if-tag-and02': '{% if foo and bar %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-and02": "{% if foo and bar %}yes{% else %}no{% endif %}"})
     def test_if_tag_and02(self):
-        output = self.engine.render_to_string('if-tag-and02', {'foo': True, 'bar': False})
-        self.assertEqual(output, 'no')
+        output = self.engine.render_to_string(
+            "if-tag-and02", {"foo": True, "bar": False}
+        )
+        self.assertEqual(output, "no")
 
-    @setup({'if-tag-and03': '{% if foo and bar %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-and03": "{% if foo and bar %}yes{% else %}no{% endif %}"})
     def test_if_tag_and03(self):
-        output = self.engine.render_to_string('if-tag-and03', {'foo': False, 'bar': True})
-        self.assertEqual(output, 'no')
+        output = self.engine.render_to_string(
+            "if-tag-and03", {"foo": False, "bar": True}
+        )
+        self.assertEqual(output, "no")
 
-    @setup({'if-tag-and04': '{% if foo and bar %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-and04": "{% if foo and bar %}yes{% else %}no{% endif %}"})
     def test_if_tag_and04(self):
-        output = self.engine.render_to_string('if-tag-and04', {'foo': False, 'bar': False})
-        self.assertEqual(output, 'no')
+        output = self.engine.render_to_string(
+            "if-tag-and04", {"foo": False, "bar": False}
+        )
+        self.assertEqual(output, "no")
 
-    @setup({'if-tag-and05': '{% if foo and bar %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-and05": "{% if foo and bar %}yes{% else %}no{% endif %}"})
     def test_if_tag_and05(self):
-        output = self.engine.render_to_string('if-tag-and05', {'foo': False})
-        self.assertEqual(output, 'no')
+        output = self.engine.render_to_string("if-tag-and05", {"foo": False})
+        self.assertEqual(output, "no")
 
-    @setup({'if-tag-and06': '{% if foo and bar %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-and06": "{% if foo and bar %}yes{% else %}no{% endif %}"})
     def test_if_tag_and06(self):
-        output = self.engine.render_to_string('if-tag-and06', {'bar': False})
-        self.assertEqual(output, 'no')
+        output = self.engine.render_to_string("if-tag-and06", {"bar": False})
+        self.assertEqual(output, "no")
 
-    @setup({'if-tag-and07': '{% if foo and bar %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-and07": "{% if foo and bar %}yes{% else %}no{% endif %}"})
     def test_if_tag_and07(self):
-        output = self.engine.render_to_string('if-tag-and07', {'foo': True})
-        self.assertEqual(output, 'no')
+        output = self.engine.render_to_string("if-tag-and07", {"foo": True})
+        self.assertEqual(output, "no")
 
-    @setup({'if-tag-and08': '{% if foo and bar %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-and08": "{% if foo and bar %}yes{% else %}no{% endif %}"})
     def test_if_tag_and08(self):
-        output = self.engine.render_to_string('if-tag-and08', {'bar': True})
-        self.assertEqual(output, 'no')
+        output = self.engine.render_to_string("if-tag-and08", {"bar": True})
+        self.assertEqual(output, "no")
 
     # OR
-    @setup({'if-tag-or01': '{% if foo or bar %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-or01": "{% if foo or bar %}yes{% else %}no{% endif %}"})
     def test_if_tag_or01(self):
-        output = self.engine.render_to_string('if-tag-or01', {'foo': True, 'bar': True})
-        self.assertEqual(output, 'yes')
+        output = self.engine.render_to_string("if-tag-or01", {"foo": True, "bar": True})
+        self.assertEqual(output, "yes")
 
-    @setup({'if-tag-or02': '{% if foo or bar %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-or02": "{% if foo or bar %}yes{% else %}no{% endif %}"})
     def test_if_tag_or02(self):
-        output = self.engine.render_to_string('if-tag-or02', {'foo': True, 'bar': False})
-        self.assertEqual(output, 'yes')
+        output = self.engine.render_to_string(
+            "if-tag-or02", {"foo": True, "bar": False}
+        )
+        self.assertEqual(output, "yes")
 
-    @setup({'if-tag-or03': '{% if foo or bar %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-or03": "{% if foo or bar %}yes{% else %}no{% endif %}"})
     def test_if_tag_or03(self):
-        output = self.engine.render_to_string('if-tag-or03', {'foo': False, 'bar': True})
-        self.assertEqual(output, 'yes')
+        output = self.engine.render_to_string(
+            "if-tag-or03", {"foo": False, "bar": True}
+        )
+        self.assertEqual(output, "yes")
 
-    @setup({'if-tag-or04': '{% if foo or bar %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-or04": "{% if foo or bar %}yes{% else %}no{% endif %}"})
     def test_if_tag_or04(self):
-        output = self.engine.render_to_string('if-tag-or04', {'foo': False, 'bar': False})
-        self.assertEqual(output, 'no')
+        output = self.engine.render_to_string(
+            "if-tag-or04", {"foo": False, "bar": False}
+        )
+        self.assertEqual(output, "no")
 
-    @setup({'if-tag-or05': '{% if foo or bar %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-or05": "{% if foo or bar %}yes{% else %}no{% endif %}"})
     def test_if_tag_or05(self):
-        output = self.engine.render_to_string('if-tag-or05', {'foo': False})
-        self.assertEqual(output, 'no')
+        output = self.engine.render_to_string("if-tag-or05", {"foo": False})
+        self.assertEqual(output, "no")
 
-    @setup({'if-tag-or06': '{% if foo or bar %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-or06": "{% if foo or bar %}yes{% else %}no{% endif %}"})
     def test_if_tag_or06(self):
-        output = self.engine.render_to_string('if-tag-or06', {'bar': False})
-        self.assertEqual(output, 'no')
+        output = self.engine.render_to_string("if-tag-or06", {"bar": False})
+        self.assertEqual(output, "no")
 
-    @setup({'if-tag-or07': '{% if foo or bar %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-or07": "{% if foo or bar %}yes{% else %}no{% endif %}"})
     def test_if_tag_or07(self):
-        output = self.engine.render_to_string('if-tag-or07', {'foo': True})
-        self.assertEqual(output, 'yes')
+        output = self.engine.render_to_string("if-tag-or07", {"foo": True})
+        self.assertEqual(output, "yes")
 
-    @setup({'if-tag-or08': '{% if foo or bar %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-or08": "{% if foo or bar %}yes{% else %}no{% endif %}"})
     def test_if_tag_or08(self):
-        output = self.engine.render_to_string('if-tag-or08', {'bar': True})
-        self.assertEqual(output, 'yes')
+        output = self.engine.render_to_string("if-tag-or08", {"bar": True})
+        self.assertEqual(output, "yes")
 
-    @setup({'if-tag-or09': '{% if foo or bar or baz %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-or09": "{% if foo or bar or baz %}yes{% else %}no{% endif %}"})
     def test_if_tag_or09(self):
         """
         multiple ORs
         """
-        output = self.engine.render_to_string('if-tag-or09', {'baz': True})
-        self.assertEqual(output, 'yes')
+        output = self.engine.render_to_string("if-tag-or09", {"baz": True})
+        self.assertEqual(output, "yes")
 
     # NOT
-    @setup({'if-tag-not01': '{% if not foo %}no{% else %}yes{% endif %}'})
+    @setup({"if-tag-not01": "{% if not foo %}no{% else %}yes{% endif %}"})
     def test_if_tag_not01(self):
-        output = self.engine.render_to_string('if-tag-not01', {'foo': True})
-        self.assertEqual(output, 'yes')
+        output = self.engine.render_to_string("if-tag-not01", {"foo": True})
+        self.assertEqual(output, "yes")
 
-    @setup({'if-tag-not02': '{% if not not foo %}no{% else %}yes{% endif %}'})
+    @setup({"if-tag-not02": "{% if not not foo %}no{% else %}yes{% endif %}"})
     def test_if_tag_not02(self):
-        output = self.engine.render_to_string('if-tag-not02', {'foo': True})
-        self.assertEqual(output, 'no')
+        output = self.engine.render_to_string("if-tag-not02", {"foo": True})
+        self.assertEqual(output, "no")
 
-    @setup({'if-tag-not06': '{% if foo and not bar %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-not06": "{% if foo and not bar %}yes{% else %}no{% endif %}"})
     def test_if_tag_not06(self):
-        output = self.engine.render_to_string('if-tag-not06')
-        self.assertEqual(output, 'no')
+        output = self.engine.render_to_string("if-tag-not06")
+        self.assertEqual(output, "no")
 
-    @setup({'if-tag-not07': '{% if foo and not bar %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-not07": "{% if foo and not bar %}yes{% else %}no{% endif %}"})
     def test_if_tag_not07(self):
-        output = self.engine.render_to_string('if-tag-not07', {'foo': True, 'bar': True})
-        self.assertEqual(output, 'no')
+        output = self.engine.render_to_string(
+            "if-tag-not07", {"foo": True, "bar": True}
+        )
+        self.assertEqual(output, "no")
 
-    @setup({'if-tag-not08': '{% if foo and not bar %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-not08": "{% if foo and not bar %}yes{% else %}no{% endif %}"})
     def test_if_tag_not08(self):
-        output = self.engine.render_to_string('if-tag-not08', {'foo': True, 'bar': False})
-        self.assertEqual(output, 'yes')
+        output = self.engine.render_to_string(
+            "if-tag-not08", {"foo": True, "bar": False}
+        )
+        self.assertEqual(output, "yes")
 
-    @setup({'if-tag-not09': '{% if foo and not bar %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-not09": "{% if foo and not bar %}yes{% else %}no{% endif %}"})
     def test_if_tag_not09(self):
-        output = self.engine.render_to_string('if-tag-not09', {'foo': False, 'bar': True})
-        self.assertEqual(output, 'no')
+        output = self.engine.render_to_string(
+            "if-tag-not09", {"foo": False, "bar": True}
+        )
+        self.assertEqual(output, "no")
 
-    @setup({'if-tag-not10': '{% if foo and not bar %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-not10": "{% if foo and not bar %}yes{% else %}no{% endif %}"})
     def test_if_tag_not10(self):
-        output = self.engine.render_to_string('if-tag-not10', {'foo': False, 'bar': False})
-        self.assertEqual(output, 'no')
+        output = self.engine.render_to_string(
+            "if-tag-not10", {"foo": False, "bar": False}
+        )
+        self.assertEqual(output, "no")
 
-    @setup({'if-tag-not11': '{% if not foo and bar %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-not11": "{% if not foo and bar %}yes{% else %}no{% endif %}"})
     def test_if_tag_not11(self):
-        output = self.engine.render_to_string('if-tag-not11')
-        self.assertEqual(output, 'no')
+        output = self.engine.render_to_string("if-tag-not11")
+        self.assertEqual(output, "no")
 
-    @setup({'if-tag-not12': '{% if not foo and bar %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-not12": "{% if not foo and bar %}yes{% else %}no{% endif %}"})
     def test_if_tag_not12(self):
-        output = self.engine.render_to_string('if-tag-not12', {'foo': True, 'bar': True})
-        self.assertEqual(output, 'no')
+        output = self.engine.render_to_string(
+            "if-tag-not12", {"foo": True, "bar": True}
+        )
+        self.assertEqual(output, "no")
 
-    @setup({'if-tag-not13': '{% if not foo and bar %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-not13": "{% if not foo and bar %}yes{% else %}no{% endif %}"})
     def test_if_tag_not13(self):
-        output = self.engine.render_to_string('if-tag-not13', {'foo': True, 'bar': False})
-        self.assertEqual(output, 'no')
+        output = self.engine.render_to_string(
+            "if-tag-not13", {"foo": True, "bar": False}
+        )
+        self.assertEqual(output, "no")
 
-    @setup({'if-tag-not14': '{% if not foo and bar %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-not14": "{% if not foo and bar %}yes{% else %}no{% endif %}"})
     def test_if_tag_not14(self):
-        output = self.engine.render_to_string('if-tag-not14', {'foo': False, 'bar': True})
-        self.assertEqual(output, 'yes')
+        output = self.engine.render_to_string(
+            "if-tag-not14", {"foo": False, "bar": True}
+        )
+        self.assertEqual(output, "yes")
 
-    @setup({'if-tag-not15': '{% if not foo and bar %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-not15": "{% if not foo and bar %}yes{% else %}no{% endif %}"})
     def test_if_tag_not15(self):
-        output = self.engine.render_to_string('if-tag-not15', {'foo': False, 'bar': False})
-        self.assertEqual(output, 'no')
+        output = self.engine.render_to_string(
+            "if-tag-not15", {"foo": False, "bar": False}
+        )
+        self.assertEqual(output, "no")
 
-    @setup({'if-tag-not16': '{% if foo or not bar %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-not16": "{% if foo or not bar %}yes{% else %}no{% endif %}"})
     def test_if_tag_not16(self):
-        output = self.engine.render_to_string('if-tag-not16')
-        self.assertEqual(output, 'yes')
+        output = self.engine.render_to_string("if-tag-not16")
+        self.assertEqual(output, "yes")
 
-    @setup({'if-tag-not17': '{% if foo or not bar %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-not17": "{% if foo or not bar %}yes{% else %}no{% endif %}"})
     def test_if_tag_not17(self):
-        output = self.engine.render_to_string('if-tag-not17', {'foo': True, 'bar': True})
-        self.assertEqual(output, 'yes')
+        output = self.engine.render_to_string(
+            "if-tag-not17", {"foo": True, "bar": True}
+        )
+        self.assertEqual(output, "yes")
 
-    @setup({'if-tag-not18': '{% if foo or not bar %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-not18": "{% if foo or not bar %}yes{% else %}no{% endif %}"})
     def test_if_tag_not18(self):
-        output = self.engine.render_to_string('if-tag-not18', {'foo': True, 'bar': False})
-        self.assertEqual(output, 'yes')
+        output = self.engine.render_to_string(
+            "if-tag-not18", {"foo": True, "bar": False}
+        )
+        self.assertEqual(output, "yes")
 
-    @setup({'if-tag-not19': '{% if foo or not bar %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-not19": "{% if foo or not bar %}yes{% else %}no{% endif %}"})
     def test_if_tag_not19(self):
-        output = self.engine.render_to_string('if-tag-not19', {'foo': False, 'bar': True})
-        self.assertEqual(output, 'no')
+        output = self.engine.render_to_string(
+            "if-tag-not19", {"foo": False, "bar": True}
+        )
+        self.assertEqual(output, "no")
 
-    @setup({'if-tag-not20': '{% if foo or not bar %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-not20": "{% if foo or not bar %}yes{% else %}no{% endif %}"})
     def test_if_tag_not20(self):
-        output = self.engine.render_to_string('if-tag-not20', {'foo': False, 'bar': False})
-        self.assertEqual(output, 'yes')
+        output = self.engine.render_to_string(
+            "if-tag-not20", {"foo": False, "bar": False}
+        )
+        self.assertEqual(output, "yes")
 
-    @setup({'if-tag-not21': '{% if not foo or bar %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-not21": "{% if not foo or bar %}yes{% else %}no{% endif %}"})
     def test_if_tag_not21(self):
-        output = self.engine.render_to_string('if-tag-not21')
-        self.assertEqual(output, 'yes')
+        output = self.engine.render_to_string("if-tag-not21")
+        self.assertEqual(output, "yes")
 
-    @setup({'if-tag-not22': '{% if not foo or bar %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-not22": "{% if not foo or bar %}yes{% else %}no{% endif %}"})
     def test_if_tag_not22(self):
-        output = self.engine.render_to_string('if-tag-not22', {'foo': True, 'bar': True})
-        self.assertEqual(output, 'yes')
+        output = self.engine.render_to_string(
+            "if-tag-not22", {"foo": True, "bar": True}
+        )
+        self.assertEqual(output, "yes")
 
-    @setup({'if-tag-not23': '{% if not foo or bar %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-not23": "{% if not foo or bar %}yes{% else %}no{% endif %}"})
     def test_if_tag_not23(self):
-        output = self.engine.render_to_string('if-tag-not23', {'foo': True, 'bar': False})
-        self.assertEqual(output, 'no')
+        output = self.engine.render_to_string(
+            "if-tag-not23", {"foo": True, "bar": False}
+        )
+        self.assertEqual(output, "no")
 
-    @setup({'if-tag-not24': '{% if not foo or bar %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-not24": "{% if not foo or bar %}yes{% else %}no{% endif %}"})
     def test_if_tag_not24(self):
-        output = self.engine.render_to_string('if-tag-not24', {'foo': False, 'bar': True})
-        self.assertEqual(output, 'yes')
+        output = self.engine.render_to_string(
+            "if-tag-not24", {"foo": False, "bar": True}
+        )
+        self.assertEqual(output, "yes")
 
-    @setup({'if-tag-not25': '{% if not foo or bar %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-not25": "{% if not foo or bar %}yes{% else %}no{% endif %}"})
     def test_if_tag_not25(self):
-        output = self.engine.render_to_string('if-tag-not25', {'foo': False, 'bar': False})
-        self.assertEqual(output, 'yes')
+        output = self.engine.render_to_string(
+            "if-tag-not25", {"foo": False, "bar": False}
+        )
+        self.assertEqual(output, "yes")
 
-    @setup({'if-tag-not26': '{% if not foo and not bar %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-not26": "{% if not foo and not bar %}yes{% else %}no{% endif %}"})
     def test_if_tag_not26(self):
-        output = self.engine.render_to_string('if-tag-not26')
-        self.assertEqual(output, 'yes')
+        output = self.engine.render_to_string("if-tag-not26")
+        self.assertEqual(output, "yes")
 
-    @setup({'if-tag-not27': '{% if not foo and not bar %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-not27": "{% if not foo and not bar %}yes{% else %}no{% endif %}"})
     def test_if_tag_not27(self):
-        output = self.engine.render_to_string('if-tag-not27', {'foo': True, 'bar': True})
-        self.assertEqual(output, 'no')
+        output = self.engine.render_to_string(
+            "if-tag-not27", {"foo": True, "bar": True}
+        )
+        self.assertEqual(output, "no")
 
-    @setup({'if-tag-not28': '{% if not foo and not bar %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-not28": "{% if not foo and not bar %}yes{% else %}no{% endif %}"})
     def test_if_tag_not28(self):
-        output = self.engine.render_to_string('if-tag-not28', {'foo': True, 'bar': False})
-        self.assertEqual(output, 'no')
+        output = self.engine.render_to_string(
+            "if-tag-not28", {"foo": True, "bar": False}
+        )
+        self.assertEqual(output, "no")
 
-    @setup({'if-tag-not29': '{% if not foo and not bar %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-not29": "{% if not foo and not bar %}yes{% else %}no{% endif %}"})
     def test_if_tag_not29(self):
-        output = self.engine.render_to_string('if-tag-not29', {'foo': False, 'bar': True})
-        self.assertEqual(output, 'no')
+        output = self.engine.render_to_string(
+            "if-tag-not29", {"foo": False, "bar": True}
+        )
+        self.assertEqual(output, "no")
 
-    @setup({'if-tag-not30': '{% if not foo and not bar %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-not30": "{% if not foo and not bar %}yes{% else %}no{% endif %}"})
     def test_if_tag_not30(self):
-        output = self.engine.render_to_string('if-tag-not30', {'foo': False, 'bar': False})
-        self.assertEqual(output, 'yes')
+        output = self.engine.render_to_string(
+            "if-tag-not30", {"foo": False, "bar": False}
+        )
+        self.assertEqual(output, "yes")
 
-    @setup({'if-tag-not31': '{% if not foo or not bar %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-not31": "{% if not foo or not bar %}yes{% else %}no{% endif %}"})
     def test_if_tag_not31(self):
-        output = self.engine.render_to_string('if-tag-not31')
-        self.assertEqual(output, 'yes')
+        output = self.engine.render_to_string("if-tag-not31")
+        self.assertEqual(output, "yes")
 
-    @setup({'if-tag-not32': '{% if not foo or not bar %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-not32": "{% if not foo or not bar %}yes{% else %}no{% endif %}"})
     def test_if_tag_not32(self):
-        output = self.engine.render_to_string('if-tag-not32', {'foo': True, 'bar': True})
-        self.assertEqual(output, 'no')
+        output = self.engine.render_to_string(
+            "if-tag-not32", {"foo": True, "bar": True}
+        )
+        self.assertEqual(output, "no")
 
-    @setup({'if-tag-not33': '{% if not foo or not bar %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-not33": "{% if not foo or not bar %}yes{% else %}no{% endif %}"})
     def test_if_tag_not33(self):
-        output = self.engine.render_to_string('if-tag-not33', {'foo': True, 'bar': False})
-        self.assertEqual(output, 'yes')
+        output = self.engine.render_to_string(
+            "if-tag-not33", {"foo": True, "bar": False}
+        )
+        self.assertEqual(output, "yes")
 
-    @setup({'if-tag-not34': '{% if not foo or not bar %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-not34": "{% if not foo or not bar %}yes{% else %}no{% endif %}"})
     def test_if_tag_not34(self):
-        output = self.engine.render_to_string('if-tag-not34', {'foo': False, 'bar': True})
-        self.assertEqual(output, 'yes')
+        output = self.engine.render_to_string(
+            "if-tag-not34", {"foo": False, "bar": True}
+        )
+        self.assertEqual(output, "yes")
 
-    @setup({'if-tag-not35': '{% if not foo or not bar %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-not35": "{% if not foo or not bar %}yes{% else %}no{% endif %}"})
     def test_if_tag_not35(self):
-        output = self.engine.render_to_string('if-tag-not35', {'foo': False, 'bar': False})
-        self.assertEqual(output, 'yes')
+        output = self.engine.render_to_string(
+            "if-tag-not35", {"foo": False, "bar": False}
+        )
+        self.assertEqual(output, "yes")
 
     # Various syntax errors
-    @setup({'if-tag-error01': '{% if %}yes{% endif %}'})
+    @setup({"if-tag-error01": "{% if %}yes{% endif %}"})
     def test_if_tag_error01(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('if-tag-error01')
+            self.engine.get_template("if-tag-error01")
 
-    @setup({'if-tag-error02': '{% if foo and %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-error02": "{% if foo and %}yes{% else %}no{% endif %}"})
     def test_if_tag_error02(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.render_to_string('if-tag-error02', {'foo': True})
+            self.engine.render_to_string("if-tag-error02", {"foo": True})
 
-    @setup({'if-tag-error03': '{% if foo or %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-error03": "{% if foo or %}yes{% else %}no{% endif %}"})
     def test_if_tag_error03(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.render_to_string('if-tag-error03', {'foo': True})
+            self.engine.render_to_string("if-tag-error03", {"foo": True})
 
-    @setup({'if-tag-error04': '{% if not foo and %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-error04": "{% if not foo and %}yes{% else %}no{% endif %}"})
     def test_if_tag_error04(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.render_to_string('if-tag-error04', {'foo': True})
+            self.engine.render_to_string("if-tag-error04", {"foo": True})
 
-    @setup({'if-tag-error05': '{% if not foo or %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-error05": "{% if not foo or %}yes{% else %}no{% endif %}"})
     def test_if_tag_error05(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.render_to_string('if-tag-error05', {'foo': True})
+            self.engine.render_to_string("if-tag-error05", {"foo": True})
 
-    @setup({'if-tag-error06': '{% if abc def %}yes{% endif %}'})
+    @setup({"if-tag-error06": "{% if abc def %}yes{% endif %}"})
     def test_if_tag_error06(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('if-tag-error06')
+            self.engine.get_template("if-tag-error06")
 
-    @setup({'if-tag-error07': '{% if not %}yes{% endif %}'})
+    @setup({"if-tag-error07": "{% if not %}yes{% endif %}"})
     def test_if_tag_error07(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('if-tag-error07')
+            self.engine.get_template("if-tag-error07")
 
-    @setup({'if-tag-error08': '{% if and %}yes{% endif %}'})
+    @setup({"if-tag-error08": "{% if and %}yes{% endif %}"})
     def test_if_tag_error08(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('if-tag-error08')
+            self.engine.get_template("if-tag-error08")
 
-    @setup({'if-tag-error09': '{% if or %}yes{% endif %}'})
+    @setup({"if-tag-error09": "{% if or %}yes{% endif %}"})
     def test_if_tag_error09(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('if-tag-error09')
+            self.engine.get_template("if-tag-error09")
 
-    @setup({'if-tag-error10': '{% if == %}yes{% endif %}'})
+    @setup({"if-tag-error10": "{% if == %}yes{% endif %}"})
     def test_if_tag_error10(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('if-tag-error10')
+            self.engine.get_template("if-tag-error10")
 
-    @setup({'if-tag-error11': '{% if 1 == %}yes{% endif %}'})
+    @setup({"if-tag-error11": "{% if 1 == %}yes{% endif %}"})
     def test_if_tag_error11(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('if-tag-error11')
+            self.engine.get_template("if-tag-error11")
 
-    @setup({'if-tag-error12': '{% if a not b %}yes{% endif %}'})
+    @setup({"if-tag-error12": "{% if a not b %}yes{% endif %}"})
     def test_if_tag_error12(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('if-tag-error12')
+            self.engine.get_template("if-tag-error12")
 
-    @setup({'else-if-tag-error01': '{% if foo is bar %} yes {% else if foo is not bar %} no {% endif %}'})
+    @setup(
+        {
+            "else-if-tag-error01": "{% if foo is bar %} yes {% else if foo is not bar %} no {% endif %}"
+        }
+    )
     def test_else_if_tag_error01(self):
         error_message = 'Malformed template tag at line 1: "else if foo is not bar"'
         with self.assertRaisesMessage(TemplateSyntaxError, error_message):
-            self.engine.get_template('else-if-tag-error01')
+            self.engine.get_template("else-if-tag-error01")
 
-    @setup({'if-tag-shortcircuit01': '{% if x.is_true or x.is_bad %}yes{% else %}no{% endif %}'})
+    @setup(
+        {
+            "if-tag-shortcircuit01": "{% if x.is_true or x.is_bad %}yes{% else %}no{% endif %}"
+        }
+    )
     def test_if_tag_shortcircuit01(self):
         """
         If evaluations are shortcircuited where possible
         """
-        output = self.engine.render_to_string('if-tag-shortcircuit01', {'x': TestObj()})
-        self.assertEqual(output, 'yes')
+        output = self.engine.render_to_string("if-tag-shortcircuit01", {"x": TestObj()})
+        self.assertEqual(output, "yes")
 
-    @setup({'if-tag-shortcircuit02': '{% if x.is_false and x.is_bad %}yes{% else %}no{% endif %}'})
+    @setup(
+        {
+            "if-tag-shortcircuit02": "{% if x.is_false and x.is_bad %}yes{% else %}no{% endif %}"
+        }
+    )
     def test_if_tag_shortcircuit02(self):
         """
         The is_bad() function should not be evaluated. If it is, an
         exception is raised.
         """
-        output = self.engine.render_to_string('if-tag-shortcircuit02', {'x': TestObj()})
-        self.assertEqual(output, 'no')
+        output = self.engine.render_to_string("if-tag-shortcircuit02", {"x": TestObj()})
+        self.assertEqual(output, "no")
 
-    @setup({'if-tag-badarg01': '{% if x|default_if_none:y %}yes{% endif %}'})
+    @setup({"if-tag-badarg01": "{% if x|default_if_none:y %}yes{% endif %}"})
     def test_if_tag_badarg01(self):
         """Nonexistent args"""
-        output = self.engine.render_to_string('if-tag-badarg01')
-        self.assertEqual(output, '')
+        output = self.engine.render_to_string("if-tag-badarg01")
+        self.assertEqual(output, "")
 
-    @setup({'if-tag-badarg02': '{% if x|default_if_none:y %}yes{% endif %}'})
+    @setup({"if-tag-badarg02": "{% if x|default_if_none:y %}yes{% endif %}"})
     def test_if_tag_badarg02(self):
-        output = self.engine.render_to_string('if-tag-badarg02', {'y': 0})
-        self.assertEqual(output, '')
+        output = self.engine.render_to_string("if-tag-badarg02", {"y": 0})
+        self.assertEqual(output, "")
 
-    @setup({'if-tag-badarg03': '{% if x|default_if_none:y %}yes{% endif %}'})
+    @setup({"if-tag-badarg03": "{% if x|default_if_none:y %}yes{% endif %}"})
     def test_if_tag_badarg03(self):
-        output = self.engine.render_to_string('if-tag-badarg03', {'y': 1})
-        self.assertEqual(output, 'yes')
+        output = self.engine.render_to_string("if-tag-badarg03", {"y": 1})
+        self.assertEqual(output, "yes")
 
-    @setup({'if-tag-badarg04': '{% if x|default_if_none:y %}yes{% else %}no{% endif %}'})
+    @setup(
+        {"if-tag-badarg04": "{% if x|default_if_none:y %}yes{% else %}no{% endif %}"}
+    )
     def test_if_tag_badarg04(self):
-        output = self.engine.render_to_string('if-tag-badarg04')
-        self.assertEqual(output, 'no')
+        output = self.engine.render_to_string("if-tag-badarg04")
+        self.assertEqual(output, "no")
 
-    @setup({'if-tag-single-eq': '{% if foo = bar %}yes{% else %}no{% endif %}'})
+    @setup({"if-tag-single-eq": "{% if foo = bar %}yes{% else %}no{% endif %}"})
     def test_if_tag_single_eq(self):
         # A single equals sign is a syntax error.
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.render_to_string('if-tag-single-eq', {'foo': 1})
+            self.engine.render_to_string("if-tag-single-eq", {"foo": 1})
 
-    @setup({'template': '{% if foo is True %}yes{% else %}no{% endif %}'})
+    @setup({"template": "{% if foo is True %}yes{% else %}no{% endif %}"})
     def test_if_is_match(self):
-        output = self.engine.render_to_string('template', {'foo': True})
-        self.assertEqual(output, 'yes')
+        output = self.engine.render_to_string("template", {"foo": True})
+        self.assertEqual(output, "yes")
 
-    @setup({'template': '{% if foo is True %}yes{% else %}no{% endif %}'})
+    @setup({"template": "{% if foo is True %}yes{% else %}no{% endif %}"})
     def test_if_is_no_match(self):
-        output = self.engine.render_to_string('template', {'foo': 1})
-        self.assertEqual(output, 'no')
+        output = self.engine.render_to_string("template", {"foo": 1})
+        self.assertEqual(output, "no")
 
-    @setup({'template': '{% if foo is bar %}yes{% else %}no{% endif %}'})
+    @setup({"template": "{% if foo is bar %}yes{% else %}no{% endif %}"})
     def test_if_is_variable_missing(self):
-        output = self.engine.render_to_string('template', {'foo': 1})
-        self.assertEqual(output, 'no')
+        output = self.engine.render_to_string("template", {"foo": 1})
+        self.assertEqual(output, "no")
 
-    @setup({'template': '{% if foo is bar %}yes{% else %}no{% endif %}'})
+    @setup({"template": "{% if foo is bar %}yes{% else %}no{% endif %}"})
     def test_if_is_both_variables_missing(self):
-        output = self.engine.render_to_string('template', {})
-        self.assertEqual(output, 'yes')
+        output = self.engine.render_to_string("template", {})
+        self.assertEqual(output, "yes")
 
-    @setup({'template': '{% if foo is not None %}yes{% else %}no{% endif %}'})
+    @setup({"template": "{% if foo is not None %}yes{% else %}no{% endif %}"})
     def test_if_is_not_match(self):
         # For this to act as a regression test, it's important not to use
         # foo=True because True is (not None)
-        output = self.engine.render_to_string('template', {'foo': False})
-        self.assertEqual(output, 'yes')
+        output = self.engine.render_to_string("template", {"foo": False})
+        self.assertEqual(output, "yes")
 
-    @setup({'template': '{% if foo is not None %}yes{% else %}no{% endif %}'})
+    @setup({"template": "{% if foo is not None %}yes{% else %}no{% endif %}"})
     def test_if_is_not_no_match(self):
-        output = self.engine.render_to_string('template', {'foo': None})
-        self.assertEqual(output, 'no')
+        output = self.engine.render_to_string("template", {"foo": None})
+        self.assertEqual(output, "no")
 
-    @setup({'template': '{% if foo is not bar %}yes{% else %}no{% endif %}'})
+    @setup({"template": "{% if foo is not bar %}yes{% else %}no{% endif %}"})
     def test_if_is_not_variable_missing(self):
-        output = self.engine.render_to_string('template', {'foo': False})
-        self.assertEqual(output, 'yes')
+        output = self.engine.render_to_string("template", {"foo": False})
+        self.assertEqual(output, "yes")
 
-    @setup({'template': '{% if foo is not bar %}yes{% else %}no{% endif %}'})
+    @setup({"template": "{% if foo is not bar %}yes{% else %}no{% endif %}"})
     def test_if_is_not_both_variables_missing(self):
-        output = self.engine.render_to_string('template', {})
-        self.assertEqual(output, 'no')
+        output = self.engine.render_to_string("template", {})
+        self.assertEqual(output, "no")
 
 
 class IfNodeTests(SimpleTestCase):
     def test_repr(self):
         node = IfNode(conditions_nodelists=[])
-        self.assertEqual(repr(node), '<IfNode>')
+        self.assertEqual(repr(node), "<IfNode>")
diff --git a/tests/template_tests/syntax_tests/test_if_changed.py b/tests/template_tests/syntax_tests/test_if_changed.py
index fd48a42389..3835e52d78 100644
--- a/tests/template_tests/syntax_tests/test_if_changed.py
+++ b/tests/template_tests/syntax_tests/test_if_changed.py
@@ -5,159 +5,255 @@ from ..utils import setup
 
 
 class IfChangedTagTests(SimpleTestCase):
-    libraries = {'custom': 'template_tests.templatetags.custom'}
+    libraries = {"custom": "template_tests.templatetags.custom"}
 
-    @setup({'ifchanged01': '{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% endfor %}'})
+    @setup(
+        {
+            "ifchanged01": "{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% endfor %}"
+        }
+    )
     def test_ifchanged01(self):
-        output = self.engine.render_to_string('ifchanged01', {'num': (1, 2, 3)})
-        self.assertEqual(output, '123')
+        output = self.engine.render_to_string("ifchanged01", {"num": (1, 2, 3)})
+        self.assertEqual(output, "123")
 
-    @setup({'ifchanged02': '{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% endfor %}'})
+    @setup(
+        {
+            "ifchanged02": "{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% endfor %}"
+        }
+    )
     def test_ifchanged02(self):
-        output = self.engine.render_to_string('ifchanged02', {'num': (1, 1, 3)})
-        self.assertEqual(output, '13')
+        output = self.engine.render_to_string("ifchanged02", {"num": (1, 1, 3)})
+        self.assertEqual(output, "13")
 
-    @setup({'ifchanged03': '{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% endfor %}'})
+    @setup(
+        {
+            "ifchanged03": "{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% endfor %}"
+        }
+    )
     def test_ifchanged03(self):
-        output = self.engine.render_to_string('ifchanged03', {'num': (1, 1, 1)})
-        self.assertEqual(output, '1')
+        output = self.engine.render_to_string("ifchanged03", {"num": (1, 1, 1)})
+        self.assertEqual(output, "1")
 
-    @setup({'ifchanged04': '{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}'
-                           '{% for x in numx %}{% ifchanged %}{{ x }}{% endifchanged %}'
-                           '{% endfor %}{% endfor %}'})
+    @setup(
+        {
+            "ifchanged04": "{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}"
+            "{% for x in numx %}{% ifchanged %}{{ x }}{% endifchanged %}"
+            "{% endfor %}{% endfor %}"
+        }
+    )
     def test_ifchanged04(self):
-        output = self.engine.render_to_string('ifchanged04', {'num': (1, 2, 3), 'numx': (2, 2, 2)})
-        self.assertEqual(output, '122232')
+        output = self.engine.render_to_string(
+            "ifchanged04", {"num": (1, 2, 3), "numx": (2, 2, 2)}
+        )
+        self.assertEqual(output, "122232")
 
-    @setup({'ifchanged05': '{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}'
-                           '{% for x in numx %}{% ifchanged %}{{ x }}{% endifchanged %}'
-                           '{% endfor %}{% endfor %}'})
+    @setup(
+        {
+            "ifchanged05": "{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}"
+            "{% for x in numx %}{% ifchanged %}{{ x }}{% endifchanged %}"
+            "{% endfor %}{% endfor %}"
+        }
+    )
     def test_ifchanged05(self):
-        output = self.engine.render_to_string('ifchanged05', {'num': (1, 1, 1), 'numx': (1, 2, 3)})
-        self.assertEqual(output, '1123123123')
+        output = self.engine.render_to_string(
+            "ifchanged05", {"num": (1, 1, 1), "numx": (1, 2, 3)}
+        )
+        self.assertEqual(output, "1123123123")
 
-    @setup({'ifchanged06': '{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}'
-                           '{% for x in numx %}{% ifchanged %}{{ x }}{% endifchanged %}'
-                           '{% endfor %}{% endfor %}'})
+    @setup(
+        {
+            "ifchanged06": "{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}"
+            "{% for x in numx %}{% ifchanged %}{{ x }}{% endifchanged %}"
+            "{% endfor %}{% endfor %}"
+        }
+    )
     def test_ifchanged06(self):
-        output = self.engine.render_to_string('ifchanged06', {'num': (1, 1, 1), 'numx': (2, 2, 2)})
-        self.assertEqual(output, '1222')
+        output = self.engine.render_to_string(
+            "ifchanged06", {"num": (1, 1, 1), "numx": (2, 2, 2)}
+        )
+        self.assertEqual(output, "1222")
 
-    @setup({'ifchanged07': '{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}'
-                           '{% for x in numx %}{% ifchanged %}{{ x }}{% endifchanged %}'
-                           '{% for y in numy %}{% ifchanged %}{{ y }}{% endifchanged %}'
-                           '{% endfor %}{% endfor %}{% endfor %}'})
+    @setup(
+        {
+            "ifchanged07": "{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}"
+            "{% for x in numx %}{% ifchanged %}{{ x }}{% endifchanged %}"
+            "{% for y in numy %}{% ifchanged %}{{ y }}{% endifchanged %}"
+            "{% endfor %}{% endfor %}{% endfor %}"
+        }
+    )
     def test_ifchanged07(self):
-        output = self.engine.render_to_string('ifchanged07', {'num': (1, 1, 1), 'numx': (2, 2, 2), 'numy': (3, 3, 3)})
-        self.assertEqual(output, '1233323332333')
+        output = self.engine.render_to_string(
+            "ifchanged07", {"num": (1, 1, 1), "numx": (2, 2, 2), "numy": (3, 3, 3)}
+        )
+        self.assertEqual(output, "1233323332333")
 
-    @setup({'ifchanged08': '{% for data in datalist %}{% for c,d in data %}'
-                           '{% if c %}{% ifchanged %}{{ d }}{% endifchanged %}'
-                           '{% endif %}{% endfor %}{% endfor %}'})
+    @setup(
+        {
+            "ifchanged08": "{% for data in datalist %}{% for c,d in data %}"
+            "{% if c %}{% ifchanged %}{{ d }}{% endifchanged %}"
+            "{% endif %}{% endfor %}{% endfor %}"
+        }
+    )
     def test_ifchanged08(self):
-        output = self.engine.render_to_string('ifchanged08', {'datalist': [
-            [(1, 'a'), (1, 'a'), (0, 'b'), (1, 'c')],
-            [(0, 'a'), (1, 'c'), (1, 'd'), (1, 'd'), (0, 'e')]
-        ]})
-        self.assertEqual(output, 'accd')
+        output = self.engine.render_to_string(
+            "ifchanged08",
+            {
+                "datalist": [
+                    [(1, "a"), (1, "a"), (0, "b"), (1, "c")],
+                    [(0, "a"), (1, "c"), (1, "d"), (1, "d"), (0, "e")],
+                ]
+            },
+        )
+        self.assertEqual(output, "accd")
 
-    @setup({'ifchanged-param01': '{% for n in num %}{% ifchanged n %}..{% endifchanged %}'
-                                 '{{ n }}{% endfor %}'})
+    @setup(
+        {
+            "ifchanged-param01": "{% for n in num %}{% ifchanged n %}..{% endifchanged %}"
+            "{{ n }}{% endfor %}"
+        }
+    )
     def test_ifchanged_param01(self):
         """
         Test one parameter given to ifchanged.
         """
-        output = self.engine.render_to_string('ifchanged-param01', {'num': (1, 2, 3)})
-        self.assertEqual(output, '..1..2..3')
+        output = self.engine.render_to_string("ifchanged-param01", {"num": (1, 2, 3)})
+        self.assertEqual(output, "..1..2..3")
 
-    @setup({'ifchanged-param02': '{% for n in num %}{% for x in numx %}{% ifchanged n %}..{% endifchanged %}'
-                                 '{{ x }}{% endfor %}{% endfor %}'})
+    @setup(
+        {
+            "ifchanged-param02": "{% for n in num %}{% for x in numx %}{% ifchanged n %}..{% endifchanged %}"
+            "{{ x }}{% endfor %}{% endfor %}"
+        }
+    )
     def test_ifchanged_param02(self):
-        output = self.engine.render_to_string('ifchanged-param02', {'num': (1, 2, 3), 'numx': (5, 6, 7)})
-        self.assertEqual(output, '..567..567..567')
+        output = self.engine.render_to_string(
+            "ifchanged-param02", {"num": (1, 2, 3), "numx": (5, 6, 7)}
+        )
+        self.assertEqual(output, "..567..567..567")
 
-    @setup({'ifchanged-param03': '{% for n in num %}{{ n }}{% for x in numx %}'
-                                 '{% ifchanged x n %}{{ x }}{% endifchanged %}'
-                                 '{% endfor %}{% endfor %}'})
+    @setup(
+        {
+            "ifchanged-param03": "{% for n in num %}{{ n }}{% for x in numx %}"
+            "{% ifchanged x n %}{{ x }}{% endifchanged %}"
+            "{% endfor %}{% endfor %}"
+        }
+    )
     def test_ifchanged_param03(self):
         """
         Test multiple parameters to ifchanged.
         """
-        output = self.engine.render_to_string('ifchanged-param03', {'num': (1, 1, 2), 'numx': (5, 6, 6)})
-        self.assertEqual(output, '156156256')
+        output = self.engine.render_to_string(
+            "ifchanged-param03", {"num": (1, 1, 2), "numx": (5, 6, 6)}
+        )
+        self.assertEqual(output, "156156256")
 
-    @setup({'ifchanged-param04': '{% for d in days %}{% ifchanged %}{{ d.day }}{% endifchanged %}'
-                                 '{% for h in d.hours %}{% ifchanged d h %}{{ h }}{% endifchanged %}'
-                                 '{% endfor %}{% endfor %}'})
+    @setup(
+        {
+            "ifchanged-param04": "{% for d in days %}{% ifchanged %}{{ d.day }}{% endifchanged %}"
+            "{% for h in d.hours %}{% ifchanged d h %}{{ h }}{% endifchanged %}"
+            "{% endfor %}{% endfor %}"
+        }
+    )
     def test_ifchanged_param04(self):
         """
         Test a date+hour like construct, where the hour of the last day is
         the same but the date had changed, so print the hour anyway.
         """
         output = self.engine.render_to_string(
-            'ifchanged-param04',
-            {'days': [{'hours': [1, 2, 3], 'day': 1}, {'hours': [3], 'day': 2}]},
+            "ifchanged-param04",
+            {"days": [{"hours": [1, 2, 3], "day": 1}, {"hours": [3], "day": 2}]},
         )
-        self.assertEqual(output, '112323')
+        self.assertEqual(output, "112323")
 
-    @setup({'ifchanged-param05': '{% for d in days %}{% ifchanged d.day %}{{ d.day }}{% endifchanged %}'
-                                 '{% for h in d.hours %}{% ifchanged d.day h %}{{ h }}{% endifchanged %}'
-                                 '{% endfor %}{% endfor %}'})
+    @setup(
+        {
+            "ifchanged-param05": "{% for d in days %}{% ifchanged d.day %}{{ d.day }}{% endifchanged %}"
+            "{% for h in d.hours %}{% ifchanged d.day h %}{{ h }}{% endifchanged %}"
+            "{% endfor %}{% endfor %}"
+        }
+    )
     def test_ifchanged_param05(self):
         """
         Logically the same as above, just written with explicit ifchanged
         for the day.
         """
         output = self.engine.render_to_string(
-            'ifchanged-param05',
-            {'days': [{'hours': [1, 2, 3], 'day': 1}, {'hours': [3], 'day': 2}]},
+            "ifchanged-param05",
+            {"days": [{"hours": [1, 2, 3], "day": 1}, {"hours": [3], "day": 2}]},
         )
-        self.assertEqual(output, '112323')
+        self.assertEqual(output, "112323")
 
-    @setup({'ifchanged-else01': '{% for id in ids %}{{ id }}'
-                                '{% ifchanged id %}-first{% else %}-other{% endifchanged %}'
-                                ',{% endfor %}'})
+    @setup(
+        {
+            "ifchanged-else01": "{% for id in ids %}{{ id }}"
+            "{% ifchanged id %}-first{% else %}-other{% endifchanged %}"
+            ",{% endfor %}"
+        }
+    )
     def test_ifchanged_else01(self):
         """
         Test the else clause of ifchanged.
         """
-        output = self.engine.render_to_string('ifchanged-else01', {'ids': [1, 1, 2, 2, 2, 3]})
-        self.assertEqual(output, '1-first,1-other,2-first,2-other,2-other,3-first,')
+        output = self.engine.render_to_string(
+            "ifchanged-else01", {"ids": [1, 1, 2, 2, 2, 3]}
+        )
+        self.assertEqual(output, "1-first,1-other,2-first,2-other,2-other,3-first,")
 
-    @setup({'ifchanged-else02': '{% for id in ids %}{{ id }}-'
-                                '{% ifchanged id %}{% cycle "red" "blue" %}{% else %}gray{% endifchanged %}'
-                                ',{% endfor %}'})
+    @setup(
+        {
+            "ifchanged-else02": "{% for id in ids %}{{ id }}-"
+            '{% ifchanged id %}{% cycle "red" "blue" %}{% else %}gray{% endifchanged %}'
+            ",{% endfor %}"
+        }
+    )
     def test_ifchanged_else02(self):
-        output = self.engine.render_to_string('ifchanged-else02', {'ids': [1, 1, 2, 2, 2, 3]})
-        self.assertEqual(output, '1-red,1-gray,2-blue,2-gray,2-gray,3-red,')
+        output = self.engine.render_to_string(
+            "ifchanged-else02", {"ids": [1, 1, 2, 2, 2, 3]}
+        )
+        self.assertEqual(output, "1-red,1-gray,2-blue,2-gray,2-gray,3-red,")
 
-    @setup({'ifchanged-else03': '{% for id in ids %}{{ id }}'
-                                '{% ifchanged id %}-{% cycle "red" "blue" %}{% else %}{% endifchanged %}'
-                                ',{% endfor %}'})
+    @setup(
+        {
+            "ifchanged-else03": "{% for id in ids %}{{ id }}"
+            '{% ifchanged id %}-{% cycle "red" "blue" %}{% else %}{% endifchanged %}'
+            ",{% endfor %}"
+        }
+    )
     def test_ifchanged_else03(self):
-        output = self.engine.render_to_string('ifchanged-else03', {'ids': [1, 1, 2, 2, 2, 3]})
-        self.assertEqual(output, '1-red,1,2-blue,2,2,3-red,')
+        output = self.engine.render_to_string(
+            "ifchanged-else03", {"ids": [1, 1, 2, 2, 2, 3]}
+        )
+        self.assertEqual(output, "1-red,1,2-blue,2,2,3-red,")
 
-    @setup({'ifchanged-else04': '{% for id in ids %}'
-                                '{% ifchanged %}***{{ id }}*{% else %}...{% endifchanged %}'
-                                '{{ forloop.counter }}{% endfor %}'})
+    @setup(
+        {
+            "ifchanged-else04": "{% for id in ids %}"
+            "{% ifchanged %}***{{ id }}*{% else %}...{% endifchanged %}"
+            "{{ forloop.counter }}{% endfor %}"
+        }
+    )
     def test_ifchanged_else04(self):
-        output = self.engine.render_to_string('ifchanged-else04', {'ids': [1, 1, 2, 2, 2, 3, 4]})
-        self.assertEqual(output, '***1*1...2***2*3...4...5***3*6***4*7')
+        output = self.engine.render_to_string(
+            "ifchanged-else04", {"ids": [1, 1, 2, 2, 2, 3, 4]}
+        )
+        self.assertEqual(output, "***1*1...2***2*3...4...5***3*6***4*7")
 
-    @setup({'ifchanged-filter-ws': '{% load custom %}{% for n in num %}'
-                                   '{% ifchanged n|noop:"x y" %}..{% endifchanged %}{{ n }}'
-                                   '{% endfor %}'})
+    @setup(
+        {
+            "ifchanged-filter-ws": "{% load custom %}{% for n in num %}"
+            '{% ifchanged n|noop:"x y" %}..{% endifchanged %}{{ n }}'
+            "{% endfor %}"
+        }
+    )
     def test_ifchanged_filter_ws(self):
         """
         Test whitespace in filter arguments
         """
-        output = self.engine.render_to_string('ifchanged-filter-ws', {'num': (1, 2, 3)})
-        self.assertEqual(output, '..1..2..3')
+        output = self.engine.render_to_string("ifchanged-filter-ws", {"num": (1, 2, 3)})
+        self.assertEqual(output, "..1..2..3")
 
 
 class IfChangedTests(SimpleTestCase):
-
     @classmethod
     def setUpClass(cls):
         cls.engine = Engine()
@@ -168,8 +264,8 @@ class IfChangedTests(SimpleTestCase):
         #15849 -- ifchanged should be thread-safe.
         """
         template = self.engine.from_string(
-            '[0{% for x in foo %},{% with var=get_value %}{% ifchanged %}'
-            '{{ var }}{% endifchanged %}{% endwith %}{% endfor %}]'
+            "[0{% for x in foo %},{% with var=get_value %}{% ifchanged %}"
+            "{{ var }}{% endifchanged %}{% endwith %}{% endfor %}]"
         )
 
         # Using generator to mimic concurrency.
@@ -181,45 +277,69 @@ class IfChangedTests(SimpleTestCase):
             # Simulate that another thread is now rendering.
             # When the IfChangeNode stores state at 'self' it stays at '3' and skip the last yielded value below.
             iter2 = iter([1, 2, 3])
-            output2 = template.render(Context({'foo': range(3), 'get_value': lambda: next(iter2)}))
+            output2 = template.render(
+                Context({"foo": range(3), "get_value": lambda: next(iter2)})
+            )
             self.assertEqual(
-                output2, '[0,1,2,3]', 'Expected [0,1,2,3] in second parallel template, got {}'.format(output2)
+                output2,
+                "[0,1,2,3]",
+                "Expected [0,1,2,3] in second parallel template, got {}".format(
+                    output2
+                ),
             )
             yield 3
 
         gen1 = gen()
-        output1 = template.render(Context({'foo': range(3), 'get_value': lambda: next(gen1)}))
-        self.assertEqual(output1, '[0,1,2,3]', 'Expected [0,1,2,3] in first template, got {}'.format(output1))
+        output1 = template.render(
+            Context({"foo": range(3), "get_value": lambda: next(gen1)})
+        )
+        self.assertEqual(
+            output1,
+            "[0,1,2,3]",
+            "Expected [0,1,2,3] in first template, got {}".format(output1),
+        )
 
     def test_ifchanged_render_once(self):
         """
         #19890. The content of ifchanged template tag was rendered twice.
         """
-        template = self.engine.from_string('{% ifchanged %}{% cycle "1st time" "2nd time" %}{% endifchanged %}')
+        template = self.engine.from_string(
+            '{% ifchanged %}{% cycle "1st time" "2nd time" %}{% endifchanged %}'
+        )
         output = template.render(Context({}))
-        self.assertEqual(output, '1st time')
+        self.assertEqual(output, "1st time")
 
     def test_include(self):
         """
         #23516 -- This works as a regression test only if the cached loader
         isn't used. Hence we don't use the @setup decorator.
         """
-        engine = Engine(loaders=[
-            ('django.template.loaders.locmem.Loader', {
-                'template': '{% for x in vars %}{% include "include" %}{% endfor %}',
-                'include': '{% ifchanged %}{{ x }}{% endifchanged %}',
-            }),
-        ])
-        output = engine.render_to_string('template', {'vars': [1, 1, 2, 2, 3, 3]})
+        engine = Engine(
+            loaders=[
+                (
+                    "django.template.loaders.locmem.Loader",
+                    {
+                        "template": '{% for x in vars %}{% include "include" %}{% endfor %}',
+                        "include": "{% ifchanged %}{{ x }}{% endifchanged %}",
+                    },
+                ),
+            ]
+        )
+        output = engine.render_to_string("template", {"vars": [1, 1, 2, 2, 3, 3]})
         self.assertEqual(output, "123")
 
     def test_include_state(self):
         """Tests the node state for different IncludeNodes (#27974)."""
-        engine = Engine(loaders=[
-            ('django.template.loaders.locmem.Loader', {
-                'template': '{% for x in vars %}{% include "include" %}{% include "include" %}{% endfor %}',
-                'include': '{% ifchanged %}{{ x }}{% endifchanged %}',
-            }),
-        ])
-        output = engine.render_to_string('template', {'vars': [1, 1, 2, 2, 3, 3]})
-        self.assertEqual(output, '112233')
+        engine = Engine(
+            loaders=[
+                (
+                    "django.template.loaders.locmem.Loader",
+                    {
+                        "template": '{% for x in vars %}{% include "include" %}{% include "include" %}{% endfor %}',
+                        "include": "{% ifchanged %}{{ x }}{% endifchanged %}",
+                    },
+                ),
+            ]
+        )
+        output = engine.render_to_string("template", {"vars": [1, 1, 2, 2, 3, 3]})
+        self.assertEqual(output, "112233")
diff --git a/tests/template_tests/syntax_tests/test_include.py b/tests/template_tests/syntax_tests/test_include.py
index 6dac87b7f2..add2ca139f 100644
--- a/tests/template_tests/syntax_tests/test_include.py
+++ b/tests/template_tests/syntax_tests/test_include.py
@@ -1,5 +1,9 @@
 from django.template import (
-    Context, Engine, TemplateDoesNotExist, TemplateSyntaxError, loader,
+    Context,
+    Engine,
+    TemplateDoesNotExist,
+    TemplateSyntaxError,
+    loader,
 )
 from django.template.loader_tags import IncludeNode
 from django.test import SimpleTestCase
@@ -8,201 +12,227 @@ from ..utils import setup
 from .test_basic import basic_templates
 
 include_fail_templates = {
-    'include-fail1': '{% load bad_tag %}{% badtag %}',
-    'include-fail2': '{% load broken_tag %}',
+    "include-fail1": "{% load bad_tag %}{% badtag %}",
+    "include-fail2": "{% load broken_tag %}",
 }
 
 
 class IncludeTagTests(SimpleTestCase):
-    libraries = {'bad_tag': 'template_tests.templatetags.bad_tag'}
+    libraries = {"bad_tag": "template_tests.templatetags.bad_tag"}
 
-    @setup({'include01': '{% include "basic-syntax01" %}'}, basic_templates)
+    @setup({"include01": '{% include "basic-syntax01" %}'}, basic_templates)
     def test_include01(self):
-        output = self.engine.render_to_string('include01')
-        self.assertEqual(output, 'something cool')
+        output = self.engine.render_to_string("include01")
+        self.assertEqual(output, "something cool")
 
-    @setup({'include02': '{% include "basic-syntax02" %}'}, basic_templates)
+    @setup({"include02": '{% include "basic-syntax02" %}'}, basic_templates)
     def test_include02(self):
-        output = self.engine.render_to_string('include02', {'headline': 'Included'})
-        self.assertEqual(output, 'Included')
+        output = self.engine.render_to_string("include02", {"headline": "Included"})
+        self.assertEqual(output, "Included")
 
-    @setup({'include03': '{% include template_name %}'}, basic_templates)
+    @setup({"include03": "{% include template_name %}"}, basic_templates)
     def test_include03(self):
         output = self.engine.render_to_string(
-            'include03',
-            {'template_name': 'basic-syntax02', 'headline': 'Included'},
+            "include03",
+            {"template_name": "basic-syntax02", "headline": "Included"},
         )
-        self.assertEqual(output, 'Included')
+        self.assertEqual(output, "Included")
 
-    @setup({'include04': 'a{% include "nonexistent" %}b'})
+    @setup({"include04": 'a{% include "nonexistent" %}b'})
     def test_include04(self):
-        template = self.engine.get_template('include04')
+        template = self.engine.get_template("include04")
         with self.assertRaises(TemplateDoesNotExist):
             template.render(Context({}))
 
-    @setup({
-        'include 05': 'template with a space',
-        'include06': '{% include "include 05"%}',
-    })
+    @setup(
+        {
+            "include 05": "template with a space",
+            "include06": '{% include "include 05"%}',
+        }
+    )
     def test_include06(self):
-        output = self.engine.render_to_string('include06')
+        output = self.engine.render_to_string("include06")
         self.assertEqual(output, "template with a space")
 
-    @setup({'include07': '{% include "basic-syntax02" with headline="Inline" %}'}, basic_templates)
+    @setup(
+        {"include07": '{% include "basic-syntax02" with headline="Inline" %}'},
+        basic_templates,
+    )
     def test_include07(self):
-        output = self.engine.render_to_string('include07', {'headline': 'Included'})
-        self.assertEqual(output, 'Inline')
+        output = self.engine.render_to_string("include07", {"headline": "Included"})
+        self.assertEqual(output, "Inline")
 
-    @setup({'include08': '{% include headline with headline="Dynamic" %}'}, basic_templates)
+    @setup(
+        {"include08": '{% include headline with headline="Dynamic" %}'}, basic_templates
+    )
     def test_include08(self):
-        output = self.engine.render_to_string('include08', {'headline': 'basic-syntax02'})
-        self.assertEqual(output, 'Dynamic')
+        output = self.engine.render_to_string(
+            "include08", {"headline": "basic-syntax02"}
+        )
+        self.assertEqual(output, "Dynamic")
 
     @setup(
-        {'include09': '{{ first }}--'
-                      '{% include "basic-syntax03" with first=second|lower|upper second=first|upper %}'
-                      '--{{ second }}'},
+        {
+            "include09": "{{ first }}--"
+            '{% include "basic-syntax03" with first=second|lower|upper second=first|upper %}'
+            "--{{ second }}"
+        },
         basic_templates,
     )
     def test_include09(self):
-        output = self.engine.render_to_string('include09', {'first': 'Ul', 'second': 'lU'})
-        self.assertEqual(output, 'Ul--LU --- UL--lU')
+        output = self.engine.render_to_string(
+            "include09", {"first": "Ul", "second": "lU"}
+        )
+        self.assertEqual(output, "Ul--LU --- UL--lU")
 
-    @setup({'include10': '{% include "basic-syntax03" only %}'}, basic_templates)
+    @setup({"include10": '{% include "basic-syntax03" only %}'}, basic_templates)
     def test_include10(self):
-        output = self.engine.render_to_string('include10', {'first': '1'})
+        output = self.engine.render_to_string("include10", {"first": "1"})
         if self.engine.string_if_invalid:
-            self.assertEqual(output, 'INVALID --- INVALID')
+            self.assertEqual(output, "INVALID --- INVALID")
         else:
-            self.assertEqual(output, ' --- ')
+            self.assertEqual(output, " --- ")
 
-    @setup({'include11': '{% include "basic-syntax03" only with second=2 %}'}, basic_templates)
+    @setup(
+        {"include11": '{% include "basic-syntax03" only with second=2 %}'},
+        basic_templates,
+    )
     def test_include11(self):
-        output = self.engine.render_to_string('include11', {'first': '1'})
+        output = self.engine.render_to_string("include11", {"first": "1"})
         if self.engine.string_if_invalid:
-            self.assertEqual(output, 'INVALID --- 2')
+            self.assertEqual(output, "INVALID --- 2")
         else:
-            self.assertEqual(output, ' --- 2')
+            self.assertEqual(output, " --- 2")
 
-    @setup({'include12': '{% include "basic-syntax03" with first=1 only %}'}, basic_templates)
+    @setup(
+        {"include12": '{% include "basic-syntax03" with first=1 only %}'},
+        basic_templates,
+    )
     def test_include12(self):
-        output = self.engine.render_to_string('include12', {'second': '2'})
+        output = self.engine.render_to_string("include12", {"second": "2"})
         if self.engine.string_if_invalid:
-            self.assertEqual(output, '1 --- INVALID')
+            self.assertEqual(output, "1 --- INVALID")
         else:
-            self.assertEqual(output, '1 --- ')
+            self.assertEqual(output, "1 --- ")
 
     @setup(
-        {'include13': '{% autoescape off %}{% include "basic-syntax03" %}{% endautoescape %}'},
+        {
+            "include13": '{% autoescape off %}{% include "basic-syntax03" %}{% endautoescape %}'
+        },
         basic_templates,
     )
     def test_include13(self):
-        output = self.engine.render_to_string('include13', {'first': '&'})
+        output = self.engine.render_to_string("include13", {"first": "&"})
         if self.engine.string_if_invalid:
-            self.assertEqual(output, '& --- INVALID')
+            self.assertEqual(output, "& --- INVALID")
         else:
-            self.assertEqual(output, '& --- ')
+            self.assertEqual(output, "& --- ")
 
     @setup(
-        {'include14': '{% autoescape off %}'
-                      '{% include "basic-syntax03" with first=var1 only %}'
-                      '{% endautoescape %}'},
+        {
+            "include14": "{% autoescape off %}"
+            '{% include "basic-syntax03" with first=var1 only %}'
+            "{% endautoescape %}"
+        },
         basic_templates,
     )
     def test_include14(self):
-        output = self.engine.render_to_string('include14', {'var1': '&'})
+        output = self.engine.render_to_string("include14", {"var1": "&"})
         if self.engine.string_if_invalid:
-            self.assertEqual(output, '& --- INVALID')
+            self.assertEqual(output, "& --- INVALID")
         else:
-            self.assertEqual(output, '& --- ')
+            self.assertEqual(output, "& --- ")
 
     # Include syntax errors
-    @setup({'include-error01': '{% include "basic-syntax01" with %}'})
+    @setup({"include-error01": '{% include "basic-syntax01" with %}'})
     def test_include_error01(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('include-error01')
+            self.engine.get_template("include-error01")
 
-    @setup({'include-error02': '{% include "basic-syntax01" with "no key" %}'})
+    @setup({"include-error02": '{% include "basic-syntax01" with "no key" %}'})
     def test_include_error02(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('include-error02')
+            self.engine.get_template("include-error02")
 
-    @setup({'include-error03': '{% include "basic-syntax01" with dotted.arg="error" %}'})
+    @setup(
+        {"include-error03": '{% include "basic-syntax01" with dotted.arg="error" %}'}
+    )
     def test_include_error03(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('include-error03')
+            self.engine.get_template("include-error03")
 
-    @setup({'include-error04': '{% include "basic-syntax01" something_random %}'})
+    @setup({"include-error04": '{% include "basic-syntax01" something_random %}'})
     def test_include_error04(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('include-error04')
+            self.engine.get_template("include-error04")
 
-    @setup({'include-error05': '{% include "basic-syntax01" foo="duplicate" foo="key" %}'})
+    @setup(
+        {"include-error05": '{% include "basic-syntax01" foo="duplicate" foo="key" %}'}
+    )
     def test_include_error05(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('include-error05')
+            self.engine.get_template("include-error05")
 
-    @setup({'include-error06': '{% include "basic-syntax01" only only %}'})
+    @setup({"include-error06": '{% include "basic-syntax01" only only %}'})
     def test_include_error06(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('include-error06')
+            self.engine.get_template("include-error06")
 
     @setup(include_fail_templates)
     def test_include_fail1(self):
         with self.assertRaises(RuntimeError):
-            self.engine.get_template('include-fail1')
+            self.engine.get_template("include-fail1")
 
     @setup(include_fail_templates)
     def test_include_fail2(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('include-fail2')
+            self.engine.get_template("include-fail2")
 
-    @setup({'include-error07': '{% include "include-fail1" %}'}, include_fail_templates)
+    @setup({"include-error07": '{% include "include-fail1" %}'}, include_fail_templates)
     def test_include_error07(self):
-        template = self.engine.get_template('include-error07')
+        template = self.engine.get_template("include-error07")
         with self.assertRaises(RuntimeError):
             template.render(Context())
 
-    @setup({'include-error08': '{% include "include-fail2" %}'}, include_fail_templates)
+    @setup({"include-error08": '{% include "include-fail2" %}'}, include_fail_templates)
     def test_include_error08(self):
-        template = self.engine.get_template('include-error08')
+        template = self.engine.get_template("include-error08")
         with self.assertRaises(TemplateSyntaxError):
             template.render(Context())
 
-    @setup({'include-error09': '{% include failed_include %}'}, include_fail_templates)
+    @setup({"include-error09": "{% include failed_include %}"}, include_fail_templates)
     def test_include_error09(self):
-        context = Context({'failed_include': 'include-fail1'})
-        template = self.engine.get_template('include-error09')
+        context = Context({"failed_include": "include-fail1"})
+        template = self.engine.get_template("include-error09")
         with self.assertRaises(RuntimeError):
             template.render(context)
 
-    @setup({'include-error10': '{% include failed_include %}'}, include_fail_templates)
+    @setup({"include-error10": "{% include failed_include %}"}, include_fail_templates)
     def test_include_error10(self):
-        context = Context({'failed_include': 'include-fail2'})
-        template = self.engine.get_template('include-error10')
+        context = Context({"failed_include": "include-fail2"})
+        template = self.engine.get_template("include-error10")
         with self.assertRaises(TemplateSyntaxError):
             template.render(context)
 
-    @setup({'include_empty': '{% include %}'})
+    @setup({"include_empty": "{% include %}"})
     def test_include_empty(self):
         msg = (
             "'include' tag takes at least one argument: the name of the "
             "template to be included."
         )
         with self.assertRaisesMessage(TemplateSyntaxError, msg):
-            self.engine.get_template('include_empty')
+            self.engine.get_template("include_empty")
 
 
 class IncludeTests(SimpleTestCase):
-
     def test_include_missing_template(self):
         """
         The correct template is identified as not existing
         when {% include %} specifies a template that does not exist.
         """
         engine = Engine(app_dirs=True, debug=True)
-        template = engine.get_template('test_include_error.html')
-        with self.assertRaisesMessage(TemplateDoesNotExist, 'missing.html'):
+        template = engine.get_template("test_include_error.html")
+        with self.assertRaisesMessage(TemplateDoesNotExist, "missing.html"):
             template.render(Context())
 
     def test_extends_include_missing_baseloader(self):
@@ -212,24 +242,30 @@ class IncludeTests(SimpleTestCase):
         template has an {% include %} of something that does not exist.
         """
         engine = Engine(app_dirs=True, debug=True)
-        template = engine.get_template('test_extends_error.html')
-        with self.assertRaisesMessage(TemplateDoesNotExist, 'missing.html'):
+        template = engine.get_template("test_extends_error.html")
+        with self.assertRaisesMessage(TemplateDoesNotExist, "missing.html"):
             template.render(Context())
 
     def test_extends_include_missing_cachedloader(self):
-        engine = Engine(debug=True, loaders=[
-            ('django.template.loaders.cached.Loader', [
-                'django.template.loaders.app_directories.Loader',
-            ]),
-        ])
+        engine = Engine(
+            debug=True,
+            loaders=[
+                (
+                    "django.template.loaders.cached.Loader",
+                    [
+                        "django.template.loaders.app_directories.Loader",
+                    ],
+                ),
+            ],
+        )
 
-        template = engine.get_template('test_extends_error.html')
-        with self.assertRaisesMessage(TemplateDoesNotExist, 'missing.html'):
+        template = engine.get_template("test_extends_error.html")
+        with self.assertRaisesMessage(TemplateDoesNotExist, "missing.html"):
             template.render(Context())
 
         # Repeat to ensure it still works when loading from the cache
-        template = engine.get_template('test_extends_error.html')
-        with self.assertRaisesMessage(TemplateDoesNotExist, 'missing.html'):
+        template = engine.get_template("test_extends_error.html")
+        with self.assertRaisesMessage(TemplateDoesNotExist, "missing.html"):
             template.render(Context())
 
     def test_include_template_argument(self):
@@ -237,37 +273,39 @@ class IncludeTests(SimpleTestCase):
         Support any render() supporting object
         """
         engine = Engine()
-        ctx = Context({
-            'tmpl': engine.from_string('This worked!'),
-        })
-        outer_tmpl = engine.from_string('{% include tmpl %}')
+        ctx = Context(
+            {
+                "tmpl": engine.from_string("This worked!"),
+            }
+        )
+        outer_tmpl = engine.from_string("{% include tmpl %}")
         output = outer_tmpl.render(ctx)
-        self.assertEqual(output, 'This worked!')
+        self.assertEqual(output, "This worked!")
 
     def test_include_template_iterable(self):
         engine = Engine.get_default()
-        outer_temp = engine.from_string('{% include var %}')
+        outer_temp = engine.from_string("{% include var %}")
         tests = [
-            ('admin/fail.html', 'index.html'),
-            ['admin/fail.html', 'index.html'],
+            ("admin/fail.html", "index.html"),
+            ["admin/fail.html", "index.html"],
         ]
         for template_names in tests:
             with self.subTest(template_names):
-                output = outer_temp.render(Context({'var': template_names}))
-                self.assertEqual(output, 'index\n')
+                output = outer_temp.render(Context({"var": template_names}))
+                self.assertEqual(output, "index\n")
 
     def test_include_template_none(self):
         engine = Engine.get_default()
-        outer_temp = engine.from_string('{% include var %}')
-        ctx = Context({'var': None})
-        msg = 'No template names provided'
+        outer_temp = engine.from_string("{% include var %}")
+        ctx = Context({"var": None})
+        msg = "No template names provided"
         with self.assertRaisesMessage(TemplateDoesNotExist, msg):
             outer_temp.render(ctx)
 
     def test_include_from_loader_get_template(self):
-        tmpl = loader.get_template('include_tpl.html')  # {% include tmpl %}
-        output = tmpl.render({'tmpl': loader.get_template('index.html')})
-        self.assertEqual(output, 'index\n\n')
+        tmpl = loader.get_template("include_tpl.html")  # {% include tmpl %}
+        output = tmpl.render({"tmpl": loader.get_template("index.html")})
+        self.assertEqual(output, "index\n\n")
 
     def test_include_immediate_missing(self):
         """
@@ -279,21 +317,22 @@ class IncludeTests(SimpleTestCase):
     def test_include_recursive(self):
         comments = [
             {
-                'comment': 'A1',
-                'children': [
-                    {'comment': 'B1', 'children': []},
-                    {'comment': 'B2', 'children': []},
-                    {'comment': 'B3', 'children': [
-                        {'comment': 'C1', 'children': []}
-                    ]},
-                ]
+                "comment": "A1",
+                "children": [
+                    {"comment": "B1", "children": []},
+                    {"comment": "B2", "children": []},
+                    {"comment": "B3", "children": [{"comment": "C1", "children": []}]},
+                ],
             }
         ]
         engine = Engine(app_dirs=True)
-        t = engine.get_template('recursive_include.html')
+        t = engine.get_template("recursive_include.html")
         self.assertEqual(
             "Recursion!  A1  Recursion!  B1   B2   B3  Recursion!  C1",
-            t.render(Context({'comments': comments})).replace(' ', '').replace('\n', ' ').strip(),
+            t.render(Context({"comments": comments}))
+            .replace(" ", "")
+            .replace("\n", " ")
+            .strip(),
         )
 
     def test_include_cache(self):
@@ -306,20 +345,26 @@ class IncludeTests(SimpleTestCase):
         This works as a regression test only if the cached loader
         isn't used, so the @setup decorator isn't used.
         """
-        engine = Engine(loaders=[
-            ('django.template.loaders.locmem.Loader', {
-                'template': '{% for x in vars %}{% include "include" %}{% endfor %}',
-                'include': '{% include "next" %}',
-                'next': '{% load custom %}{% counter %}'
-            }),
-        ], libraries={'custom': 'template_tests.templatetags.custom'})
-        output = engine.render_to_string('template', {'vars': range(9)})
-        self.assertEqual(output, '012345678')
+        engine = Engine(
+            loaders=[
+                (
+                    "django.template.loaders.locmem.Loader",
+                    {
+                        "template": '{% for x in vars %}{% include "include" %}{% endfor %}',
+                        "include": '{% include "next" %}',
+                        "next": "{% load custom %}{% counter %}",
+                    },
+                ),
+            ],
+            libraries={"custom": "template_tests.templatetags.custom"},
+        )
+        output = engine.render_to_string("template", {"vars": range(9)})
+        self.assertEqual(output, "012345678")
 
 
 class IncludeNodeTests(SimpleTestCase):
     def test_repr(self):
-        include_node = IncludeNode('app/template.html')
+        include_node = IncludeNode("app/template.html")
         self.assertEqual(
             repr(include_node),
             "<IncludeNode: template='app/template.html'>",
diff --git a/tests/template_tests/syntax_tests/test_invalid_string.py b/tests/template_tests/syntax_tests/test_invalid_string.py
index b05abcfdf3..e65ac938ec 100644
--- a/tests/template_tests/syntax_tests/test_invalid_string.py
+++ b/tests/template_tests/syntax_tests/test_invalid_string.py
@@ -4,59 +4,63 @@ from ..utils import setup
 
 
 class InvalidStringTests(SimpleTestCase):
-    libraries = {'i18n': 'django.templatetags.i18n'}
+    libraries = {"i18n": "django.templatetags.i18n"}
 
-    @setup({'invalidstr01': '{{ var|default:"Foo" }}'})
+    @setup({"invalidstr01": '{{ var|default:"Foo" }}'})
     def test_invalidstr01(self):
-        output = self.engine.render_to_string('invalidstr01')
+        output = self.engine.render_to_string("invalidstr01")
         if self.engine.string_if_invalid:
-            self.assertEqual(output, 'INVALID')
+            self.assertEqual(output, "INVALID")
         else:
-            self.assertEqual(output, 'Foo')
+            self.assertEqual(output, "Foo")
 
-    @setup({'invalidstr02': '{{ var|default_if_none:"Foo" }}'})
+    @setup({"invalidstr02": '{{ var|default_if_none:"Foo" }}'})
     def test_invalidstr02(self):
-        output = self.engine.render_to_string('invalidstr02')
+        output = self.engine.render_to_string("invalidstr02")
         if self.engine.string_if_invalid:
-            self.assertEqual(output, 'INVALID')
+            self.assertEqual(output, "INVALID")
         else:
-            self.assertEqual(output, '')
+            self.assertEqual(output, "")
 
-    @setup({'invalidstr03': '{% for v in var %}({{ v }}){% endfor %}'})
+    @setup({"invalidstr03": "{% for v in var %}({{ v }}){% endfor %}"})
     def test_invalidstr03(self):
-        output = self.engine.render_to_string('invalidstr03')
-        self.assertEqual(output, '')
+        output = self.engine.render_to_string("invalidstr03")
+        self.assertEqual(output, "")
 
-    @setup({'invalidstr04': '{% if var %}Yes{% else %}No{% endif %}'})
+    @setup({"invalidstr04": "{% if var %}Yes{% else %}No{% endif %}"})
     def test_invalidstr04(self):
-        output = self.engine.render_to_string('invalidstr04')
-        self.assertEqual(output, 'No')
+        output = self.engine.render_to_string("invalidstr04")
+        self.assertEqual(output, "No")
 
-    @setup({'invalidstr04_2': '{% if var|default:"Foo" %}Yes{% else %}No{% endif %}'})
+    @setup({"invalidstr04_2": '{% if var|default:"Foo" %}Yes{% else %}No{% endif %}'})
     def test_invalidstr04_2(self):
-        output = self.engine.render_to_string('invalidstr04_2')
-        self.assertEqual(output, 'Yes')
+        output = self.engine.render_to_string("invalidstr04_2")
+        self.assertEqual(output, "Yes")
 
-    @setup({'invalidstr05': '{{ var }}'})
+    @setup({"invalidstr05": "{{ var }}"})
     def test_invalidstr05(self):
-        output = self.engine.render_to_string('invalidstr05')
+        output = self.engine.render_to_string("invalidstr05")
         if self.engine.string_if_invalid:
-            self.assertEqual(output, 'INVALID')
+            self.assertEqual(output, "INVALID")
         else:
-            self.assertEqual(output, '')
+            self.assertEqual(output, "")
 
-    @setup({'invalidstr06': '{{ var.prop }}'})
+    @setup({"invalidstr06": "{{ var.prop }}"})
     def test_invalidstr06(self):
-        output = self.engine.render_to_string('invalidstr06')
+        output = self.engine.render_to_string("invalidstr06")
         if self.engine.string_if_invalid:
-            self.assertEqual(output, 'INVALID')
+            self.assertEqual(output, "INVALID")
         else:
-            self.assertEqual(output, '')
+            self.assertEqual(output, "")
 
-    @setup({'invalidstr07': '{% load i18n %}{% blocktranslate %}{{ var }}{% endblocktranslate %}'})
+    @setup(
+        {
+            "invalidstr07": "{% load i18n %}{% blocktranslate %}{{ var }}{% endblocktranslate %}"
+        }
+    )
     def test_invalidstr07(self):
-        output = self.engine.render_to_string('invalidstr07')
+        output = self.engine.render_to_string("invalidstr07")
         if self.engine.string_if_invalid:
-            self.assertEqual(output, 'INVALID')
+            self.assertEqual(output, "INVALID")
         else:
-            self.assertEqual(output, '')
+            self.assertEqual(output, "")
diff --git a/tests/template_tests/syntax_tests/test_list_index.py b/tests/template_tests/syntax_tests/test_list_index.py
index d1be0cb1a4..261e7dfdba 100644
--- a/tests/template_tests/syntax_tests/test_list_index.py
+++ b/tests/template_tests/syntax_tests/test_list_index.py
@@ -4,72 +4,77 @@ from ..utils import setup
 
 
 class ListIndexTests(SimpleTestCase):
-
-    @setup({'list-index01': '{{ var.1 }}'})
+    @setup({"list-index01": "{{ var.1 }}"})
     def test_list_index01(self):
         """
         List-index syntax allows a template to access a certain item of a
         subscriptable object.
         """
-        output = self.engine.render_to_string('list-index01', {'var': ['first item', 'second item']})
-        self.assertEqual(output, 'second item')
+        output = self.engine.render_to_string(
+            "list-index01", {"var": ["first item", "second item"]}
+        )
+        self.assertEqual(output, "second item")
 
-    @setup({'list-index02': '{{ var.5 }}'})
+    @setup({"list-index02": "{{ var.5 }}"})
     def test_list_index02(self):
         """
         Fail silently when the list index is out of range.
         """
-        output = self.engine.render_to_string('list-index02', {'var': ['first item', 'second item']})
+        output = self.engine.render_to_string(
+            "list-index02", {"var": ["first item", "second item"]}
+        )
         if self.engine.string_if_invalid:
-            self.assertEqual(output, 'INVALID')
+            self.assertEqual(output, "INVALID")
         else:
-            self.assertEqual(output, '')
+            self.assertEqual(output, "")
 
-    @setup({'list-index03': '{{ var.1 }}'})
+    @setup({"list-index03": "{{ var.1 }}"})
     def test_list_index03(self):
         """
         Fail silently when the list index is out of range.
         """
-        output = self.engine.render_to_string('list-index03', {'var': None})
+        output = self.engine.render_to_string("list-index03", {"var": None})
         if self.engine.string_if_invalid:
-            self.assertEqual(output, 'INVALID')
+            self.assertEqual(output, "INVALID")
         else:
-            self.assertEqual(output, '')
+            self.assertEqual(output, "")
 
-    @setup({'list-index04': '{{ var.1 }}'})
+    @setup({"list-index04": "{{ var.1 }}"})
     def test_list_index04(self):
         """
         Fail silently when variable is a dict without the specified key.
         """
-        output = self.engine.render_to_string('list-index04', {'var': {}})
+        output = self.engine.render_to_string("list-index04", {"var": {}})
         if self.engine.string_if_invalid:
-            self.assertEqual(output, 'INVALID')
+            self.assertEqual(output, "INVALID")
         else:
-            self.assertEqual(output, '')
+            self.assertEqual(output, "")
 
-    @setup({'list-index05': '{{ var.1 }}'})
+    @setup({"list-index05": "{{ var.1 }}"})
     def test_list_index05(self):
         """
         Dictionary lookup wins out when dict's key is a string.
         """
-        output = self.engine.render_to_string('list-index05', {'var': {'1': "hello"}})
-        self.assertEqual(output, 'hello')
+        output = self.engine.render_to_string("list-index05", {"var": {"1": "hello"}})
+        self.assertEqual(output, "hello")
 
-    @setup({'list-index06': '{{ var.1 }}'})
+    @setup({"list-index06": "{{ var.1 }}"})
     def test_list_index06(self):
         """
         But list-index lookup wins out when dict's key is an int, which
         behind the scenes is really a dictionary lookup (for a dict)
         after converting the key to an int.
         """
-        output = self.engine.render_to_string('list-index06', {"var": {1: "hello"}})
-        self.assertEqual(output, 'hello')
+        output = self.engine.render_to_string("list-index06", {"var": {1: "hello"}})
+        self.assertEqual(output, "hello")
 
-    @setup({'list-index07': '{{ var.1 }}'})
+    @setup({"list-index07": "{{ var.1 }}"})
     def test_list_index07(self):
         """
         Dictionary lookup wins out when there is a string and int version
         of the key.
         """
-        output = self.engine.render_to_string('list-index07', {"var": {'1': "hello", 1: "world"}})
-        self.assertEqual(output, 'hello')
+        output = self.engine.render_to_string(
+            "list-index07", {"var": {"1": "hello", 1: "world"}}
+        )
+        self.assertEqual(output, "hello")
diff --git a/tests/template_tests/syntax_tests/test_load.py b/tests/template_tests/syntax_tests/test_load.py
index 919bbf1346..ae5f1d4b48 100644
--- a/tests/template_tests/syntax_tests/test_load.py
+++ b/tests/template_tests/syntax_tests/test_load.py
@@ -6,70 +6,82 @@ from ..utils import setup
 
 class LoadTagTests(SimpleTestCase):
     libraries = {
-        'subpackage.echo': 'template_tests.templatetags.subpackage.echo',
-        'testtags': 'template_tests.templatetags.testtags',
+        "subpackage.echo": "template_tests.templatetags.subpackage.echo",
+        "testtags": "template_tests.templatetags.testtags",
     }
 
-    @setup({'load01': '{% load testtags subpackage.echo %}{% echo test %} {% echo2 "test" %}'})
+    @setup(
+        {
+            "load01": '{% load testtags subpackage.echo %}{% echo test %} {% echo2 "test" %}'
+        }
+    )
     def test_load01(self):
-        output = self.engine.render_to_string('load01')
-        self.assertEqual(output, 'test test')
+        output = self.engine.render_to_string("load01")
+        self.assertEqual(output, "test test")
 
-    @setup({'load02': '{% load subpackage.echo %}{% echo2 "test" %}'})
+    @setup({"load02": '{% load subpackage.echo %}{% echo2 "test" %}'})
     def test_load02(self):
-        output = self.engine.render_to_string('load02')
-        self.assertEqual(output, 'test')
+        output = self.engine.render_to_string("load02")
+        self.assertEqual(output, "test")
 
     # {% load %} tag, importing individual tags
-    @setup({'load03': '{% load echo from testtags %}{% echo this that theother %}'})
+    @setup({"load03": "{% load echo from testtags %}{% echo this that theother %}"})
     def test_load03(self):
-        output = self.engine.render_to_string('load03')
-        self.assertEqual(output, 'this that theother')
+        output = self.engine.render_to_string("load03")
+        self.assertEqual(output, "this that theother")
 
-    @setup({'load04': '{% load echo other_echo from testtags %}'
-                      '{% echo this that theother %} {% other_echo and another thing %}'})
+    @setup(
+        {
+            "load04": "{% load echo other_echo from testtags %}"
+            "{% echo this that theother %} {% other_echo and another thing %}"
+        }
+    )
     def test_load04(self):
-        output = self.engine.render_to_string('load04')
-        self.assertEqual(output, 'this that theother and another thing')
+        output = self.engine.render_to_string("load04")
+        self.assertEqual(output, "this that theother and another thing")
 
-    @setup({'load05': '{% load echo upper from testtags %}'
-                      '{% echo this that theother %} {{ statement|upper }}'})
+    @setup(
+        {
+            "load05": "{% load echo upper from testtags %}"
+            "{% echo this that theother %} {{ statement|upper }}"
+        }
+    )
     def test_load05(self):
-        output = self.engine.render_to_string('load05', {'statement': 'not shouting'})
-        self.assertEqual(output, 'this that theother NOT SHOUTING')
+        output = self.engine.render_to_string("load05", {"statement": "not shouting"})
+        self.assertEqual(output, "this that theother NOT SHOUTING")
 
-    @setup({'load06': '{% load echo2 from subpackage.echo %}{% echo2 "test" %}'})
+    @setup({"load06": '{% load echo2 from subpackage.echo %}{% echo2 "test" %}'})
     def test_load06(self):
-        output = self.engine.render_to_string('load06')
-        self.assertEqual(output, 'test')
+        output = self.engine.render_to_string("load06")
+        self.assertEqual(output, "test")
 
     # {% load %} tag errors
-    @setup({'load07': '{% load echo other_echo bad_tag from testtags %}'})
+    @setup({"load07": "{% load echo other_echo bad_tag from testtags %}"})
     def test_load07(self):
         msg = "'bad_tag' is not a valid tag or filter in tag library 'testtags'"
         with self.assertRaisesMessage(TemplateSyntaxError, msg):
-            self.engine.get_template('load07')
+            self.engine.get_template("load07")
 
-    @setup({'load08': '{% load echo other_echo bad_tag from %}'})
+    @setup({"load08": "{% load echo other_echo bad_tag from %}"})
     def test_load08(self):
         msg = "'echo' is not a registered tag library. Must be one of:\nsubpackage.echo\ntesttags"
         with self.assertRaisesMessage(TemplateSyntaxError, msg):
-            self.engine.get_template('load08')
+            self.engine.get_template("load08")
 
-    @setup({'load09': '{% load from testtags %}'})
+    @setup({"load09": "{% load from testtags %}"})
     def test_load09(self):
         msg = "'from' is not a registered tag library. Must be one of:\nsubpackage.echo\ntesttags"
         with self.assertRaisesMessage(TemplateSyntaxError, msg):
-            self.engine.get_template('load09')
+            self.engine.get_template("load09")
 
-    @setup({'load10': '{% load echo from bad_library %}'})
+    @setup({"load10": "{% load echo from bad_library %}"})
     def test_load10(self):
         msg = "'bad_library' is not a registered tag library. Must be one of:\nsubpackage.echo\ntesttags"
         with self.assertRaisesMessage(TemplateSyntaxError, msg):
-            self.engine.get_template('load10')
+            self.engine.get_template("load10")
 
-    @setup({'load12': '{% load subpackage.missing %}'})
+    @setup({"load12": "{% load subpackage.missing %}"})
     def test_load12(self):
         msg = "'subpackage.missing' is not a registered tag library. Must be one of:\nsubpackage.echo\ntesttags"
         with self.assertRaisesMessage(TemplateSyntaxError, msg):
-            self.engine.get_template('load12')
+            self.engine.get_template("load12")
diff --git a/tests/template_tests/syntax_tests/test_lorem.py b/tests/template_tests/syntax_tests/test_lorem.py
index 4c81aadc66..846a2bc593 100644
--- a/tests/template_tests/syntax_tests/test_lorem.py
+++ b/tests/template_tests/syntax_tests/test_lorem.py
@@ -6,37 +6,36 @@ from ..utils import setup
 
 
 class LoremTagTests(SimpleTestCase):
-
-    @setup({'lorem1': '{% lorem 3 w %}'})
+    @setup({"lorem1": "{% lorem 3 w %}"})
     def test_lorem1(self):
-        output = self.engine.render_to_string('lorem1')
-        self.assertEqual(output, 'lorem ipsum dolor')
+        output = self.engine.render_to_string("lorem1")
+        self.assertEqual(output, "lorem ipsum dolor")
 
-    @setup({'lorem_random': '{% lorem 3 w random %}'})
+    @setup({"lorem_random": "{% lorem 3 w random %}"})
     def test_lorem_random(self):
-        output = self.engine.render_to_string('lorem_random')
-        words = output.split(' ')
+        output = self.engine.render_to_string("lorem_random")
+        words = output.split(" ")
         self.assertEqual(len(words), 3)
         for word in words:
             self.assertIn(word, WORDS)
 
-    @setup({'lorem_default': '{% lorem %}'})
+    @setup({"lorem_default": "{% lorem %}"})
     def test_lorem_default(self):
-        output = self.engine.render_to_string('lorem_default')
+        output = self.engine.render_to_string("lorem_default")
         self.assertEqual(output, COMMON_P)
 
-    @setup({'lorem_syntax_error': '{% lorem 1 2 3 4 %}'})
+    @setup({"lorem_syntax_error": "{% lorem 1 2 3 4 %}"})
     def test_lorem_syntax(self):
         msg = "Incorrect format for 'lorem' tag"
         with self.assertRaisesMessage(TemplateSyntaxError, msg):
-            self.engine.render_to_string('lorem_syntax_error')
+            self.engine.render_to_string("lorem_syntax_error")
 
-    @setup({'lorem_multiple_paragraphs': '{% lorem 2 p %}'})
+    @setup({"lorem_multiple_paragraphs": "{% lorem 2 p %}"})
     def test_lorem_multiple_paragraphs(self):
-        output = self.engine.render_to_string('lorem_multiple_paragraphs')
-        self.assertEqual(output.count('<p>'), 2)
+        output = self.engine.render_to_string("lorem_multiple_paragraphs")
+        self.assertEqual(output.count("<p>"), 2)
 
-    @setup({'lorem_incorrect_count': '{% lorem two p %}'})
+    @setup({"lorem_incorrect_count": "{% lorem two p %}"})
     def test_lorem_incorrect_count(self):
-        output = self.engine.render_to_string('lorem_incorrect_count')
-        self.assertEqual(output.count('<p>'), 1)
+        output = self.engine.render_to_string("lorem_incorrect_count")
+        self.assertEqual(output.count("<p>"), 1)
diff --git a/tests/template_tests/syntax_tests/test_multiline.py b/tests/template_tests/syntax_tests/test_multiline.py
index a95e12986a..fc576da63e 100644
--- a/tests/template_tests/syntax_tests/test_multiline.py
+++ b/tests/template_tests/syntax_tests/test_multiline.py
@@ -13,8 +13,7 @@ gentlemen.
 
 
 class MultilineTests(SimpleTestCase):
-
-    @setup({'multiline01': multiline_string})
+    @setup({"multiline01": multiline_string})
     def test_multiline01(self):
-        output = self.engine.render_to_string('multiline01')
+        output = self.engine.render_to_string("multiline01")
         self.assertEqual(output, multiline_string)
diff --git a/tests/template_tests/syntax_tests/test_named_endblock.py b/tests/template_tests/syntax_tests/test_named_endblock.py
index 73a66a34d0..2230edf52b 100644
--- a/tests/template_tests/syntax_tests/test_named_endblock.py
+++ b/tests/template_tests/syntax_tests/test_named_endblock.py
@@ -5,49 +5,76 @@ from ..utils import setup
 
 
 class NamedEndblockTests(SimpleTestCase):
-
-    @setup({'namedendblocks01': '1{% block first %}_{% block second %}'
-                                '2{% endblock second %}_{% endblock first %}3'})
+    @setup(
+        {
+            "namedendblocks01": "1{% block first %}_{% block second %}"
+            "2{% endblock second %}_{% endblock first %}3"
+        }
+    )
     def test_namedendblocks01(self):
-        output = self.engine.render_to_string('namedendblocks01')
-        self.assertEqual(output, '1_2_3')
+        output = self.engine.render_to_string("namedendblocks01")
+        self.assertEqual(output, "1_2_3")
 
     # Unbalanced blocks
-    @setup({'namedendblocks02': '1{% block first %}_{% block second %}'
-                                '2{% endblock first %}_{% endblock second %}3'})
+    @setup(
+        {
+            "namedendblocks02": "1{% block first %}_{% block second %}"
+            "2{% endblock first %}_{% endblock second %}3"
+        }
+    )
     def test_namedendblocks02(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('namedendblocks02')
+            self.engine.get_template("namedendblocks02")
 
-    @setup({'namedendblocks03': '1{% block first %}_{% block second %}'
-                                '2{% endblock %}_{% endblock second %}3'})
+    @setup(
+        {
+            "namedendblocks03": "1{% block first %}_{% block second %}"
+            "2{% endblock %}_{% endblock second %}3"
+        }
+    )
     def test_namedendblocks03(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('namedendblocks03')
+            self.engine.get_template("namedendblocks03")
 
-    @setup({'namedendblocks04': '1{% block first %}_{% block second %}'
-                                '2{% endblock second %}_{% endblock third %}3'})
+    @setup(
+        {
+            "namedendblocks04": "1{% block first %}_{% block second %}"
+            "2{% endblock second %}_{% endblock third %}3"
+        }
+    )
     def test_namedendblocks04(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('namedendblocks04')
+            self.engine.get_template("namedendblocks04")
 
-    @setup({'namedendblocks05': '1{% block first %}_{% block second %}2{% endblock first %}'})
+    @setup(
+        {
+            "namedendblocks05": "1{% block first %}_{% block second %}2{% endblock first %}"
+        }
+    )
     def test_namedendblocks05(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('namedendblocks05')
+            self.engine.get_template("namedendblocks05")
 
     # Mixed named and unnamed endblocks
-    @setup({'namedendblocks06': '1{% block first %}_{% block second %}'
-                                '2{% endblock %}_{% endblock first %}3'})
+    @setup(
+        {
+            "namedendblocks06": "1{% block first %}_{% block second %}"
+            "2{% endblock %}_{% endblock first %}3"
+        }
+    )
     def test_namedendblocks06(self):
         """
         Mixed named and unnamed endblocks
         """
-        output = self.engine.render_to_string('namedendblocks06')
-        self.assertEqual(output, '1_2_3')
+        output = self.engine.render_to_string("namedendblocks06")
+        self.assertEqual(output, "1_2_3")
 
-    @setup({'namedendblocks07': '1{% block first %}_{% block second %}'
-                                '2{% endblock second %}_{% endblock %}3'})
+    @setup(
+        {
+            "namedendblocks07": "1{% block first %}_{% block second %}"
+            "2{% endblock second %}_{% endblock %}3"
+        }
+    )
     def test_namedendblocks07(self):
-        output = self.engine.render_to_string('namedendblocks07')
-        self.assertEqual(output, '1_2_3')
+        output = self.engine.render_to_string("namedendblocks07")
+        self.assertEqual(output, "1_2_3")
diff --git a/tests/template_tests/syntax_tests/test_now.py b/tests/template_tests/syntax_tests/test_now.py
index ac2a167b4f..a0a05ed0a7 100644
--- a/tests/template_tests/syntax_tests/test_now.py
+++ b/tests/template_tests/syntax_tests/test_now.py
@@ -8,60 +8,91 @@ from ..utils import setup
 
 
 class NowTagTests(SimpleTestCase):
-
-    @setup({'now01': '{% now "j n Y" %}'})
+    @setup({"now01": '{% now "j n Y" %}'})
     def test_now01(self):
         """
         Simple case
         """
-        output = self.engine.render_to_string('now01')
-        self.assertEqual(output, "%d %d %d" % (
-            datetime.now().day, datetime.now().month, datetime.now().year,
-        ))
+        output = self.engine.render_to_string("now01")
+        self.assertEqual(
+            output,
+            "%d %d %d"
+            % (
+                datetime.now().day,
+                datetime.now().month,
+                datetime.now().year,
+            ),
+        )
 
     # Check parsing of locale strings
-    @setup({'now02': '{% now "DATE_FORMAT" %}'})
+    @setup({"now02": '{% now "DATE_FORMAT" %}'})
     def test_now02(self):
-        output = self.engine.render_to_string('now02')
+        output = self.engine.render_to_string("now02")
         self.assertEqual(output, date_format(datetime.now()))
 
-    @setup({'now03': '{% now \'j n Y\' %}'})
+    @setup({"now03": "{% now 'j n Y' %}"})
     def test_now03(self):
         """
         #15092 - Also accept simple quotes
         """
-        output = self.engine.render_to_string('now03')
-        self.assertEqual(output, "%d %d %d" % (
-            datetime.now().day, datetime.now().month, datetime.now().year,
-        ))
+        output = self.engine.render_to_string("now03")
+        self.assertEqual(
+            output,
+            "%d %d %d"
+            % (
+                datetime.now().day,
+                datetime.now().month,
+                datetime.now().year,
+            ),
+        )
 
-    @setup({'now04': '{% now \'DATE_FORMAT\' %}'})
+    @setup({"now04": "{% now 'DATE_FORMAT' %}"})
     def test_now04(self):
-        output = self.engine.render_to_string('now04')
+        output = self.engine.render_to_string("now04")
         self.assertEqual(output, date_format(datetime.now()))
 
-    @setup({'now05': '{% now \'j "n" Y\'%}'})
+    @setup({"now05": "{% now 'j \"n\" Y'%}"})
     def test_now05(self):
-        output = self.engine.render_to_string('now05')
-        self.assertEqual(output, '%d "%d" %d' % (
-            datetime.now().day, datetime.now().month, datetime.now().year,
-        ))
+        output = self.engine.render_to_string("now05")
+        self.assertEqual(
+            output,
+            '%d "%d" %d'
+            % (
+                datetime.now().day,
+                datetime.now().month,
+                datetime.now().year,
+            ),
+        )
 
-    @setup({'now06': '{% now "j \'n\' Y"%}'})
+    @setup({"now06": "{% now \"j 'n' Y\"%}"})
     def test_now06(self):
-        output = self.engine.render_to_string('now06')
-        self.assertEqual(output, "%d '%d' %d" % (
-            datetime.now().day, datetime.now().month, datetime.now().year,
-        ))
+        output = self.engine.render_to_string("now06")
+        self.assertEqual(
+            output,
+            "%d '%d' %d"
+            % (
+                datetime.now().day,
+                datetime.now().month,
+                datetime.now().year,
+            ),
+        )
 
-    @setup({'now07': '{% now "j n Y" as N %}-{{N}}-'})
+    @setup({"now07": '{% now "j n Y" as N %}-{{N}}-'})
     def test_now07(self):
-        output = self.engine.render_to_string('now07')
-        self.assertEqual(output, '-%d %d %d-' % (
-            datetime.now().day, datetime.now().month, datetime.now().year,
-        ))
+        output = self.engine.render_to_string("now07")
+        self.assertEqual(
+            output,
+            "-%d %d %d-"
+            % (
+                datetime.now().day,
+                datetime.now().month,
+                datetime.now().year,
+            ),
+        )
 
-    @setup({'no_args': '{% now %}'})
+    @setup({"no_args": "{% now %}"})
     def test_now_args(self):
-        with self.assertRaisesMessage(TemplateSyntaxError, "'now' statement takes one argument"):
-            self.engine.render_to_string('no_args')
+        with self.assertRaisesMessage(
+            TemplateSyntaxError, "'now' statement takes one argument"
+        ):
+            self.engine.render_to_string("no_args")
diff --git a/tests/template_tests/syntax_tests/test_numpy.py b/tests/template_tests/syntax_tests/test_numpy.py
index 09d57ebcc2..2c78b45358 100644
--- a/tests/template_tests/syntax_tests/test_numpy.py
+++ b/tests/template_tests/syntax_tests/test_numpy.py
@@ -12,29 +12,28 @@ except ImportError:
 
 @skipIf(numpy is False, "Numpy must be installed to run these tests.")
 class NumpyTests(SimpleTestCase):
-
-    @setup({'numpy-array-index01': '{{ var.1 }}'})
+    @setup({"numpy-array-index01": "{{ var.1 }}"})
     def test_numpy_array_index01(self):
         """
         Numpy's array-index syntax allows a template to access a certain
         item of a subscriptable object.
         """
         output = self.engine.render_to_string(
-            'numpy-array-index01',
-            {'var': numpy.array(["first item", "second item"])},
+            "numpy-array-index01",
+            {"var": numpy.array(["first item", "second item"])},
         )
-        self.assertEqual(output, 'second item')
+        self.assertEqual(output, "second item")
 
-    @setup({'numpy-array-index02': '{{ var.5 }}'})
+    @setup({"numpy-array-index02": "{{ var.5 }}"})
     def test_numpy_array_index02(self):
         """
         Fail silently when the array index is out of range.
         """
         output = self.engine.render_to_string(
-            'numpy-array-index02',
-            {'var': numpy.array(["first item", "second item"])},
+            "numpy-array-index02",
+            {"var": numpy.array(["first item", "second item"])},
         )
         if self.engine.string_if_invalid:
-            self.assertEqual(output, 'INVALID')
+            self.assertEqual(output, "INVALID")
         else:
-            self.assertEqual(output, '')
+            self.assertEqual(output, "")
diff --git a/tests/template_tests/syntax_tests/test_regroup.py b/tests/template_tests/syntax_tests/test_regroup.py
index 2c0135587e..eca5e0d5f9 100644
--- a/tests/template_tests/syntax_tests/test_regroup.py
+++ b/tests/template_tests/syntax_tests/test_regroup.py
@@ -7,115 +7,152 @@ from ..utils import setup
 
 
 class RegroupTagTests(SimpleTestCase):
-
-    @setup({'regroup01': ''
-                         '{% regroup data by bar as grouped %}'
-                         '{% for group in grouped %}'
-                         '{{ group.grouper }}:'
-                         '{% for item in group.list %}'
-                         '{{ item.foo }}'
-                         '{% endfor %},'
-                         '{% endfor %}'})
+    @setup(
+        {
+            "regroup01": ""
+            "{% regroup data by bar as grouped %}"
+            "{% for group in grouped %}"
+            "{{ group.grouper }}:"
+            "{% for item in group.list %}"
+            "{{ item.foo }}"
+            "{% endfor %},"
+            "{% endfor %}"
+        }
+    )
     def test_regroup01(self):
-        output = self.engine.render_to_string('regroup01', {
-            'data': [{'foo': 'c', 'bar': 1},
-                     {'foo': 'd', 'bar': 1},
-                     {'foo': 'a', 'bar': 2},
-                     {'foo': 'b', 'bar': 2},
-                     {'foo': 'x', 'bar': 3}],
-        })
-        self.assertEqual(output, '1:cd,2:ab,3:x,')
+        output = self.engine.render_to_string(
+            "regroup01",
+            {
+                "data": [
+                    {"foo": "c", "bar": 1},
+                    {"foo": "d", "bar": 1},
+                    {"foo": "a", "bar": 2},
+                    {"foo": "b", "bar": 2},
+                    {"foo": "x", "bar": 3},
+                ],
+            },
+        )
+        self.assertEqual(output, "1:cd,2:ab,3:x,")
 
-    @setup({'regroup02': ''
-                         '{% regroup data by bar as grouped %}'
-                         '{% for group in grouped %}'
-                         '{{ group.grouper }}:'
-                         '{% for item in group.list %}'
-                         '{{ item.foo }}'
-                         '{% endfor %}'
-                         '{% endfor %}'})
+    @setup(
+        {
+            "regroup02": ""
+            "{% regroup data by bar as grouped %}"
+            "{% for group in grouped %}"
+            "{{ group.grouper }}:"
+            "{% for item in group.list %}"
+            "{{ item.foo }}"
+            "{% endfor %}"
+            "{% endfor %}"
+        }
+    )
     def test_regroup02(self):
         """
         Test for silent failure when target variable isn't found
         """
-        output = self.engine.render_to_string('regroup02', {})
-        self.assertEqual(output, '')
+        output = self.engine.render_to_string("regroup02", {})
+        self.assertEqual(output, "")
 
-    @setup({'regroup03': ''
-                         '{% regroup data by at|date:"m" as grouped %}'
-                         '{% for group in grouped %}'
-                         '{{ group.grouper }}:'
-                         '{% for item in group.list %}'
-                         '{{ item.at|date:"d" }}'
-                         '{% endfor %},'
-                         '{% endfor %}'})
+    @setup(
+        {
+            "regroup03": ""
+            '{% regroup data by at|date:"m" as grouped %}'
+            "{% for group in grouped %}"
+            "{{ group.grouper }}:"
+            "{% for item in group.list %}"
+            '{{ item.at|date:"d" }}'
+            "{% endfor %},"
+            "{% endfor %}"
+        }
+    )
     def test_regroup03(self):
         """
         Regression tests for #17675
         The date template filter has expects_localtime = True
         """
-        output = self.engine.render_to_string('regroup03', {
-            'data': [{'at': date(2012, 2, 14)},
-                     {'at': date(2012, 2, 28)},
-                     {'at': date(2012, 7, 4)}],
-        })
-        self.assertEqual(output, '02:1428,07:04,')
+        output = self.engine.render_to_string(
+            "regroup03",
+            {
+                "data": [
+                    {"at": date(2012, 2, 14)},
+                    {"at": date(2012, 2, 28)},
+                    {"at": date(2012, 7, 4)},
+                ],
+            },
+        )
+        self.assertEqual(output, "02:1428,07:04,")
 
-    @setup({'regroup04': ''
-                         '{% regroup data by bar|join:"" as grouped %}'
-                         '{% for group in grouped %}'
-                         '{{ group.grouper }}:'
-                         '{% for item in group.list %}'
-                         '{{ item.foo|first }}'
-                         '{% endfor %},'
-                         '{% endfor %}'})
+    @setup(
+        {
+            "regroup04": ""
+            '{% regroup data by bar|join:"" as grouped %}'
+            "{% for group in grouped %}"
+            "{{ group.grouper }}:"
+            "{% for item in group.list %}"
+            "{{ item.foo|first }}"
+            "{% endfor %},"
+            "{% endfor %}"
+        }
+    )
     def test_regroup04(self):
         """
         The join template filter has needs_autoescape = True
         """
-        output = self.engine.render_to_string('regroup04', {
-            'data': [{'foo': 'x', 'bar': ['ab', 'c']},
-                     {'foo': 'y', 'bar': ['a', 'bc']},
-                     {'foo': 'z', 'bar': ['a', 'd']}],
-        })
-        self.assertEqual(output, 'abc:xy,ad:z,')
+        output = self.engine.render_to_string(
+            "regroup04",
+            {
+                "data": [
+                    {"foo": "x", "bar": ["ab", "c"]},
+                    {"foo": "y", "bar": ["a", "bc"]},
+                    {"foo": "z", "bar": ["a", "d"]},
+                ],
+            },
+        )
+        self.assertEqual(output, "abc:xy,ad:z,")
 
     # Test syntax errors
-    @setup({'regroup05': '{% regroup data by bar as %}'})
+    @setup({"regroup05": "{% regroup data by bar as %}"})
     def test_regroup05(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('regroup05')
+            self.engine.get_template("regroup05")
 
-    @setup({'regroup06': '{% regroup data by bar thisaintright grouped %}'})
+    @setup({"regroup06": "{% regroup data by bar thisaintright grouped %}"})
     def test_regroup06(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('regroup06')
+            self.engine.get_template("regroup06")
 
-    @setup({'regroup07': '{% regroup data thisaintright bar as grouped %}'})
+    @setup({"regroup07": "{% regroup data thisaintright bar as grouped %}"})
     def test_regroup07(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('regroup07')
+            self.engine.get_template("regroup07")
 
-    @setup({'regroup08': '{% regroup data by bar as grouped toomanyargs %}'})
+    @setup({"regroup08": "{% regroup data by bar as grouped toomanyargs %}"})
     def test_regroup08(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('regroup08')
+            self.engine.get_template("regroup08")
 
-    @setup({'regroup_unpack': '{% regroup data by bar as grouped %}'
-                              '{% for grouper, group in grouped %}'
-                              '{{ grouper }}:'
-                              '{% for item in group %}'
-                              '{{ item.foo }}'
-                              '{% endfor %},'
-                              '{% endfor %}'})
+    @setup(
+        {
+            "regroup_unpack": "{% regroup data by bar as grouped %}"
+            "{% for grouper, group in grouped %}"
+            "{{ grouper }}:"
+            "{% for item in group %}"
+            "{{ item.foo }}"
+            "{% endfor %},"
+            "{% endfor %}"
+        }
+    )
     def test_regroup_unpack(self):
-        output = self.engine.render_to_string('regroup_unpack', {
-            'data': [
-                {'foo': 'c', 'bar': 1},
-                {'foo': 'd', 'bar': 1},
-                {'foo': 'a', 'bar': 2},
-                {'foo': 'b', 'bar': 2},
-                {'foo': 'x', 'bar': 3},
-            ],
-        })
-        self.assertEqual(output, '1:cd,2:ab,3:x,')
+        output = self.engine.render_to_string(
+            "regroup_unpack",
+            {
+                "data": [
+                    {"foo": "c", "bar": 1},
+                    {"foo": "d", "bar": 1},
+                    {"foo": "a", "bar": 2},
+                    {"foo": "b", "bar": 2},
+                    {"foo": "x", "bar": 3},
+                ],
+            },
+        )
+        self.assertEqual(output, "1:cd,2:ab,3:x,")
diff --git a/tests/template_tests/syntax_tests/test_resetcycle.py b/tests/template_tests/syntax_tests/test_resetcycle.py
index 7c3bfc55fb..6d7365a6ec 100644
--- a/tests/template_tests/syntax_tests/test_resetcycle.py
+++ b/tests/template_tests/syntax_tests/test_resetcycle.py
@@ -5,91 +5,128 @@ from ..utils import setup
 
 
 class ResetCycleTagTests(SimpleTestCase):
-
-    @setup({'resetcycle01': "{% resetcycle %}"})
+    @setup({"resetcycle01": "{% resetcycle %}"})
     def test_resetcycle01(self):
         with self.assertRaisesMessage(TemplateSyntaxError, "No cycles in template."):
-            self.engine.get_template('resetcycle01')
+            self.engine.get_template("resetcycle01")
 
-    @setup({'resetcycle02': "{% resetcycle undefinedcycle %}"})
+    @setup({"resetcycle02": "{% resetcycle undefinedcycle %}"})
     def test_resetcycle02(self):
-        with self.assertRaisesMessage(TemplateSyntaxError, "Named cycle 'undefinedcycle' does not exist."):
-            self.engine.get_template('resetcycle02')
+        with self.assertRaisesMessage(
+            TemplateSyntaxError, "Named cycle 'undefinedcycle' does not exist."
+        ):
+            self.engine.get_template("resetcycle02")
 
-    @setup({'resetcycle03': "{% cycle 'a' 'b' %}{% resetcycle undefinedcycle %}"})
+    @setup({"resetcycle03": "{% cycle 'a' 'b' %}{% resetcycle undefinedcycle %}"})
     def test_resetcycle03(self):
-        with self.assertRaisesMessage(TemplateSyntaxError, "Named cycle 'undefinedcycle' does not exist."):
-            self.engine.get_template('resetcycle03')
+        with self.assertRaisesMessage(
+            TemplateSyntaxError, "Named cycle 'undefinedcycle' does not exist."
+        ):
+            self.engine.get_template("resetcycle03")
 
-    @setup({'resetcycle04': "{% cycle 'a' 'b' as ab %}{% resetcycle undefinedcycle %}"})
+    @setup({"resetcycle04": "{% cycle 'a' 'b' as ab %}{% resetcycle undefinedcycle %}"})
     def test_resetcycle04(self):
-        with self.assertRaisesMessage(TemplateSyntaxError, "Named cycle 'undefinedcycle' does not exist."):
-            self.engine.get_template('resetcycle04')
+        with self.assertRaisesMessage(
+            TemplateSyntaxError, "Named cycle 'undefinedcycle' does not exist."
+        ):
+            self.engine.get_template("resetcycle04")
 
-    @setup({'resetcycle05': "{% for i in test %}{% cycle 'a' 'b' %}{% resetcycle %}{% endfor %}"})
+    @setup(
+        {
+            "resetcycle05": "{% for i in test %}{% cycle 'a' 'b' %}{% resetcycle %}{% endfor %}"
+        }
+    )
     def test_resetcycle05(self):
-        output = self.engine.render_to_string('resetcycle05', {'test': list(range(5))})
-        self.assertEqual(output, 'aaaaa')
+        output = self.engine.render_to_string("resetcycle05", {"test": list(range(5))})
+        self.assertEqual(output, "aaaaa")
 
-    @setup({'resetcycle06': "{% cycle 'a' 'b' 'c' as abc %}"
-                            "{% for i in test %}"
-                            "{% cycle abc %}"
-                            "{% cycle '-' '+' %}"
-                            "{% resetcycle %}"
-                            "{% endfor %}"})
+    @setup(
+        {
+            "resetcycle06": "{% cycle 'a' 'b' 'c' as abc %}"
+            "{% for i in test %}"
+            "{% cycle abc %}"
+            "{% cycle '-' '+' %}"
+            "{% resetcycle %}"
+            "{% endfor %}"
+        }
+    )
     def test_resetcycle06(self):
-        output = self.engine.render_to_string('resetcycle06', {'test': list(range(5))})
-        self.assertEqual(output, 'ab-c-a-b-c-')
+        output = self.engine.render_to_string("resetcycle06", {"test": list(range(5))})
+        self.assertEqual(output, "ab-c-a-b-c-")
 
-    @setup({'resetcycle07': "{% cycle 'a' 'b' 'c' as abc %}"
-                            "{% for i in test %}"
-                            "{% resetcycle abc %}"
-                            "{% cycle abc %}"
-                            "{% cycle '-' '+' %}"
-                            "{% endfor %}"})
+    @setup(
+        {
+            "resetcycle07": "{% cycle 'a' 'b' 'c' as abc %}"
+            "{% for i in test %}"
+            "{% resetcycle abc %}"
+            "{% cycle abc %}"
+            "{% cycle '-' '+' %}"
+            "{% endfor %}"
+        }
+    )
     def test_resetcycle07(self):
-        output = self.engine.render_to_string('resetcycle07', {'test': list(range(5))})
-        self.assertEqual(output, 'aa-a+a-a+a-')
+        output = self.engine.render_to_string("resetcycle07", {"test": list(range(5))})
+        self.assertEqual(output, "aa-a+a-a+a-")
 
-    @setup({'resetcycle08': "{% for i in outer %}"
-                            "{% for j in inner %}"
-                            "{% cycle 'a' 'b' %}"
-                            "{% endfor %}"
-                            "{% resetcycle %}"
-                            "{% endfor %}"})
+    @setup(
+        {
+            "resetcycle08": "{% for i in outer %}"
+            "{% for j in inner %}"
+            "{% cycle 'a' 'b' %}"
+            "{% endfor %}"
+            "{% resetcycle %}"
+            "{% endfor %}"
+        }
+    )
     def test_resetcycle08(self):
-        output = self.engine.render_to_string('resetcycle08', {'outer': list(range(2)), 'inner': list(range(3))})
-        self.assertEqual(output, 'abaaba')
+        output = self.engine.render_to_string(
+            "resetcycle08", {"outer": list(range(2)), "inner": list(range(3))}
+        )
+        self.assertEqual(output, "abaaba")
 
-    @setup({'resetcycle09': "{% for i in outer %}"
-                            "{% cycle 'a' 'b' %}"
-                            "{% for j in inner %}"
-                            "{% cycle 'X' 'Y' %}"
-                            "{% endfor %}"
-                            "{% resetcycle %}"
-                            "{% endfor %}"})
+    @setup(
+        {
+            "resetcycle09": "{% for i in outer %}"
+            "{% cycle 'a' 'b' %}"
+            "{% for j in inner %}"
+            "{% cycle 'X' 'Y' %}"
+            "{% endfor %}"
+            "{% resetcycle %}"
+            "{% endfor %}"
+        }
+    )
     def test_resetcycle09(self):
-        output = self.engine.render_to_string('resetcycle09', {'outer': list(range(2)), 'inner': list(range(3))})
-        self.assertEqual(output, 'aXYXbXYX')
+        output = self.engine.render_to_string(
+            "resetcycle09", {"outer": list(range(2)), "inner": list(range(3))}
+        )
+        self.assertEqual(output, "aXYXbXYX")
 
-    @setup({'resetcycle10': "{% for i in test %}"
-                            "{% cycle 'X' 'Y' 'Z' as XYZ %}"
-                            "{% cycle 'a' 'b' 'c' as abc %}"
-                            "{% if i == 1 %}"
-                            "{% resetcycle abc %}"
-                            "{% endif %}"
-                            "{% endfor %}"})
+    @setup(
+        {
+            "resetcycle10": "{% for i in test %}"
+            "{% cycle 'X' 'Y' 'Z' as XYZ %}"
+            "{% cycle 'a' 'b' 'c' as abc %}"
+            "{% if i == 1 %}"
+            "{% resetcycle abc %}"
+            "{% endif %}"
+            "{% endfor %}"
+        }
+    )
     def test_resetcycle10(self):
-        output = self.engine.render_to_string('resetcycle10', {'test': list(range(5))})
-        self.assertEqual(output, 'XaYbZaXbYc')
+        output = self.engine.render_to_string("resetcycle10", {"test": list(range(5))})
+        self.assertEqual(output, "XaYbZaXbYc")
 
-    @setup({'resetcycle11': "{% for i in test %}"
-                            "{% cycle 'X' 'Y' 'Z' as XYZ %}"
-                            "{% cycle 'a' 'b' 'c' as abc %}"
-                            "{% if i == 1 %}"
-                            "{% resetcycle XYZ %}"
-                            "{% endif %}"
-                            "{% endfor %}"})
+    @setup(
+        {
+            "resetcycle11": "{% for i in test %}"
+            "{% cycle 'X' 'Y' 'Z' as XYZ %}"
+            "{% cycle 'a' 'b' 'c' as abc %}"
+            "{% if i == 1 %}"
+            "{% resetcycle XYZ %}"
+            "{% endif %}"
+            "{% endfor %}"
+        }
+    )
     def test_resetcycle11(self):
-        output = self.engine.render_to_string('resetcycle11', {'test': list(range(5))})
-        self.assertEqual(output, 'XaYbXcYaZb')
+        output = self.engine.render_to_string("resetcycle11", {"test": list(range(5))})
+        self.assertEqual(output, "XaYbXcYaZb")
diff --git a/tests/template_tests/syntax_tests/test_setup.py b/tests/template_tests/syntax_tests/test_setup.py
index 07377cea3f..a05cea4292 100644
--- a/tests/template_tests/syntax_tests/test_setup.py
+++ b/tests/template_tests/syntax_tests/test_setup.py
@@ -4,7 +4,6 @@ from ..utils import setup
 
 
 class SetupTests(SimpleTestCase):
-
     def test_setup(self):
         """
         Let's just make sure setup runs cases in the right order.
@@ -13,16 +12,18 @@ class SetupTests(SimpleTestCase):
 
         @setup({})
         def method(self):
-            cases.append([
-                self.engine.string_if_invalid,
-                self.engine.debug,
-            ])
+            cases.append(
+                [
+                    self.engine.string_if_invalid,
+                    self.engine.debug,
+                ]
+            )
 
         method(self)
 
-        self.assertEqual(cases[0], ['', False])
-        self.assertEqual(cases[1], ['', False])
-        self.assertEqual(cases[2], ['INVALID', False])
-        self.assertEqual(cases[3], ['INVALID', False])
-        self.assertEqual(cases[4], ['', True])
-        self.assertEqual(cases[5], ['', True])
+        self.assertEqual(cases[0], ["", False])
+        self.assertEqual(cases[1], ["", False])
+        self.assertEqual(cases[2], ["INVALID", False])
+        self.assertEqual(cases[3], ["INVALID", False])
+        self.assertEqual(cases[4], ["", True])
+        self.assertEqual(cases[5], ["", True])
diff --git a/tests/template_tests/syntax_tests/test_simple_tag.py b/tests/template_tests/syntax_tests/test_simple_tag.py
index 5e6ce4733e..79bffe05fa 100644
--- a/tests/template_tests/syntax_tests/test_simple_tag.py
+++ b/tests/template_tests/syntax_tests/test_simple_tag.py
@@ -5,19 +5,19 @@ from ..utils import setup
 
 
 class SimpleTagTests(SimpleTestCase):
-    libraries = {'custom': 'template_tests.templatetags.custom'}
+    libraries = {"custom": "template_tests.templatetags.custom"}
 
-    @setup({'simpletag-renamed01': '{% load custom %}{% minusone 7 %}'})
+    @setup({"simpletag-renamed01": "{% load custom %}{% minusone 7 %}"})
     def test_simpletag_renamed01(self):
-        output = self.engine.render_to_string('simpletag-renamed01')
-        self.assertEqual(output, '6')
+        output = self.engine.render_to_string("simpletag-renamed01")
+        self.assertEqual(output, "6")
 
-    @setup({'simpletag-renamed02': '{% load custom %}{% minustwo 7 %}'})
+    @setup({"simpletag-renamed02": "{% load custom %}{% minustwo 7 %}"})
     def test_simpletag_renamed02(self):
-        output = self.engine.render_to_string('simpletag-renamed02')
-        self.assertEqual(output, '5')
+        output = self.engine.render_to_string("simpletag-renamed02")
+        self.assertEqual(output, "5")
 
-    @setup({'simpletag-renamed03': '{% load custom %}{% minustwo_overridden_name 7 %}'})
+    @setup({"simpletag-renamed03": "{% load custom %}{% minustwo_overridden_name 7 %}"})
     def test_simpletag_renamed03(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('simpletag-renamed03')
+            self.engine.get_template("simpletag-renamed03")
diff --git a/tests/template_tests/syntax_tests/test_spaceless.py b/tests/template_tests/syntax_tests/test_spaceless.py
index 398b7919a1..8bb20dba6c 100644
--- a/tests/template_tests/syntax_tests/test_spaceless.py
+++ b/tests/template_tests/syntax_tests/test_spaceless.py
@@ -4,35 +4,54 @@ from ..utils import setup
 
 
 class SpacelessTagTests(SimpleTestCase):
-
-    @setup({'spaceless01': "{% spaceless %} <b>    <i> text </i>    </b> {% endspaceless %}"})
+    @setup(
+        {
+            "spaceless01": "{% spaceless %} <b>    <i> text </i>    </b> {% endspaceless %}"
+        }
+    )
     def test_spaceless01(self):
-        output = self.engine.render_to_string('spaceless01')
+        output = self.engine.render_to_string("spaceless01")
         self.assertEqual(output, "<b><i> text </i></b>")
 
-    @setup({'spaceless02': "{% spaceless %} <b> \n <i> text </i> \n </b> {% endspaceless %}"})
+    @setup(
+        {
+            "spaceless02": "{% spaceless %} <b> \n <i> text </i> \n </b> {% endspaceless %}"
+        }
+    )
     def test_spaceless02(self):
-        output = self.engine.render_to_string('spaceless02')
+        output = self.engine.render_to_string("spaceless02")
         self.assertEqual(output, "<b><i> text </i></b>")
 
-    @setup({'spaceless03': "{% spaceless %}<b><i>text</i></b>{% endspaceless %}"})
+    @setup({"spaceless03": "{% spaceless %}<b><i>text</i></b>{% endspaceless %}"})
     def test_spaceless03(self):
-        output = self.engine.render_to_string('spaceless03')
+        output = self.engine.render_to_string("spaceless03")
         self.assertEqual(output, "<b><i>text</i></b>")
 
-    @setup({'spaceless04': "{% spaceless %}<b>   <i>{{ text }}</i>  </b>{% endspaceless %}"})
+    @setup(
+        {
+            "spaceless04": "{% spaceless %}<b>   <i>{{ text }}</i>  </b>{% endspaceless %}"
+        }
+    )
     def test_spaceless04(self):
-        output = self.engine.render_to_string('spaceless04', {'text': 'This & that'})
+        output = self.engine.render_to_string("spaceless04", {"text": "This & that"})
         self.assertEqual(output, "<b><i>This &amp; that</i></b>")
 
-    @setup({'spaceless05': "{% autoescape off %}{% spaceless %}"
-                           "<b>   <i>{{ text }}</i>  </b>{% endspaceless %}"
-                           "{% endautoescape %}"})
+    @setup(
+        {
+            "spaceless05": "{% autoescape off %}{% spaceless %}"
+            "<b>   <i>{{ text }}</i>  </b>{% endspaceless %}"
+            "{% endautoescape %}"
+        }
+    )
     def test_spaceless05(self):
-        output = self.engine.render_to_string('spaceless05', {'text': 'This & that'})
+        output = self.engine.render_to_string("spaceless05", {"text": "This & that"})
         self.assertEqual(output, "<b><i>This & that</i></b>")
 
-    @setup({'spaceless06': "{% spaceless %}<b>   <i>{{ text|safe }}</i>  </b>{% endspaceless %}"})
+    @setup(
+        {
+            "spaceless06": "{% spaceless %}<b>   <i>{{ text|safe }}</i>  </b>{% endspaceless %}"
+        }
+    )
     def test_spaceless06(self):
-        output = self.engine.render_to_string('spaceless06', {'text': 'This & that'})
+        output = self.engine.render_to_string("spaceless06", {"text": "This & that"})
         self.assertEqual(output, "<b><i>This & that</i></b>")
diff --git a/tests/template_tests/syntax_tests/test_static.py b/tests/template_tests/syntax_tests/test_static.py
index 6f27d555bf..cd63350cb5 100644
--- a/tests/template_tests/syntax_tests/test_static.py
+++ b/tests/template_tests/syntax_tests/test_static.py
@@ -8,78 +8,107 @@ from django.test import SimpleTestCase, override_settings
 from ..utils import setup
 
 
-@override_settings(INSTALLED_APPS=[], MEDIA_URL='media/', STATIC_URL='static/')
+@override_settings(INSTALLED_APPS=[], MEDIA_URL="media/", STATIC_URL="static/")
 class StaticTagTests(SimpleTestCase):
-    libraries = {'static': 'django.templatetags.static'}
+    libraries = {"static": "django.templatetags.static"}
 
-    @setup({'static-prefixtag01': '{% load static %}{% get_static_prefix %}'})
+    @setup({"static-prefixtag01": "{% load static %}{% get_static_prefix %}"})
     def test_static_prefixtag01(self):
-        output = self.engine.render_to_string('static-prefixtag01')
+        output = self.engine.render_to_string("static-prefixtag01")
         self.assertEqual(output, settings.STATIC_URL)
 
-    @setup({'static-prefixtag02': '{% load static %}'
-                                  '{% get_static_prefix as static_prefix %}{{ static_prefix }}'})
+    @setup(
+        {
+            "static-prefixtag02": "{% load static %}"
+            "{% get_static_prefix as static_prefix %}{{ static_prefix }}"
+        }
+    )
     def test_static_prefixtag02(self):
-        output = self.engine.render_to_string('static-prefixtag02')
+        output = self.engine.render_to_string("static-prefixtag02")
         self.assertEqual(output, settings.STATIC_URL)
 
-    @setup({'static-prefixtag03': '{% load static %}{% get_media_prefix %}'})
+    @setup({"static-prefixtag03": "{% load static %}{% get_media_prefix %}"})
     def test_static_prefixtag03(self):
-        output = self.engine.render_to_string('static-prefixtag03')
+        output = self.engine.render_to_string("static-prefixtag03")
         self.assertEqual(output, settings.MEDIA_URL)
 
-    @setup({'static-prefixtag04': '{% load static %}'
-                                  '{% get_media_prefix as media_prefix %}{{ media_prefix }}'})
+    @setup(
+        {
+            "static-prefixtag04": "{% load static %}"
+            "{% get_media_prefix as media_prefix %}{{ media_prefix }}"
+        }
+    )
     def test_static_prefixtag04(self):
-        output = self.engine.render_to_string('static-prefixtag04')
+        output = self.engine.render_to_string("static-prefixtag04")
         self.assertEqual(output, settings.MEDIA_URL)
 
-    @setup({'t': '{% load static %}{% get_media_prefix ad media_prefix %}{{ media_prefix }}'})
+    @setup(
+        {
+            "t": "{% load static %}{% get_media_prefix ad media_prefix %}{{ media_prefix }}"
+        }
+    )
     def test_static_prefixtag_without_as(self):
         msg = "First argument in 'get_media_prefix' must be 'as'"
         with self.assertRaisesMessage(TemplateSyntaxError, msg):
-            self.engine.render_to_string('t')
+            self.engine.render_to_string("t")
 
-    @setup({'static-statictag01': '{% load static %}{% static "admin/base.css" %}'})
+    @setup({"static-statictag01": '{% load static %}{% static "admin/base.css" %}'})
     def test_static_statictag01(self):
-        output = self.engine.render_to_string('static-statictag01')
-        self.assertEqual(output, urljoin(settings.STATIC_URL, 'admin/base.css'))
+        output = self.engine.render_to_string("static-statictag01")
+        self.assertEqual(output, urljoin(settings.STATIC_URL, "admin/base.css"))
 
-    @setup({'static-statictag02': '{% load static %}{% static base_css %}'})
+    @setup({"static-statictag02": "{% load static %}{% static base_css %}"})
     def test_static_statictag02(self):
-        output = self.engine.render_to_string('static-statictag02', {'base_css': 'admin/base.css'})
-        self.assertEqual(output, urljoin(settings.STATIC_URL, 'admin/base.css'))
+        output = self.engine.render_to_string(
+            "static-statictag02", {"base_css": "admin/base.css"}
+        )
+        self.assertEqual(output, urljoin(settings.STATIC_URL, "admin/base.css"))
 
-    @setup({'static-statictag03': '{% load static %}{% static "admin/base.css" as foo %}{{ foo }}'})
+    @setup(
+        {
+            "static-statictag03": '{% load static %}{% static "admin/base.css" as foo %}{{ foo }}'
+        }
+    )
     def test_static_statictag03(self):
-        output = self.engine.render_to_string('static-statictag03')
-        self.assertEqual(output, urljoin(settings.STATIC_URL, 'admin/base.css'))
+        output = self.engine.render_to_string("static-statictag03")
+        self.assertEqual(output, urljoin(settings.STATIC_URL, "admin/base.css"))
 
-    @setup({'static-statictag04': '{% load static %}{% static base_css as foo %}{{ foo }}'})
+    @setup(
+        {"static-statictag04": "{% load static %}{% static base_css as foo %}{{ foo }}"}
+    )
     def test_static_statictag04(self):
-        output = self.engine.render_to_string('static-statictag04', {'base_css': 'admin/base.css'})
-        self.assertEqual(output, urljoin(settings.STATIC_URL, 'admin/base.css'))
+        output = self.engine.render_to_string(
+            "static-statictag04", {"base_css": "admin/base.css"}
+        )
+        self.assertEqual(output, urljoin(settings.STATIC_URL, "admin/base.css"))
 
-    @setup({'static-statictag05': '{% load static %}{% static "special?chars&quoted.html" %}'})
+    @setup(
+        {
+            "static-statictag05": '{% load static %}{% static "special?chars&quoted.html" %}'
+        }
+    )
     def test_static_quotes_urls(self):
-        output = self.engine.render_to_string('static-statictag05')
-        self.assertEqual(output, urljoin(settings.STATIC_URL, '/static/special%3Fchars%26quoted.html'))
+        output = self.engine.render_to_string("static-statictag05")
+        self.assertEqual(
+            output,
+            urljoin(settings.STATIC_URL, "/static/special%3Fchars%26quoted.html"),
+        )
 
-    @setup({'t': '{% load static %}{% static %}'})
+    @setup({"t": "{% load static %}{% static %}"})
     def test_static_statictag_without_path(self):
         msg = "'static' takes at least one argument (path to file)"
         with self.assertRaisesMessage(TemplateSyntaxError, msg):
-            self.engine.render_to_string('t')
+            self.engine.render_to_string("t")
 
 
 class StaticNodeTests(SimpleTestCase):
     def test_repr(self):
-        static_node = StaticNode(varname='named-var', path='named-path')
+        static_node = StaticNode(varname="named-var", path="named-path")
         self.assertEqual(
             repr(static_node),
             "StaticNode(varname='named-var', path='named-path')",
         )
-        static_node = StaticNode(path='named-path')
+        static_node = StaticNode(path="named-path")
         self.assertEqual(
             repr(static_node),
             "StaticNode(varname=None, path='named-path')",
diff --git a/tests/template_tests/syntax_tests/test_template_tag.py b/tests/template_tests/syntax_tests/test_template_tag.py
index e868c9f21a..b53b657921 100644
--- a/tests/template_tests/syntax_tests/test_template_tag.py
+++ b/tests/template_tests/syntax_tests/test_template_tag.py
@@ -5,63 +5,64 @@ from ..utils import setup
 
 
 class TemplateTagTests(SimpleTestCase):
-
-    @setup({'templatetag01': '{% templatetag openblock %}'})
+    @setup({"templatetag01": "{% templatetag openblock %}"})
     def test_templatetag01(self):
-        output = self.engine.render_to_string('templatetag01')
-        self.assertEqual(output, '{%')
+        output = self.engine.render_to_string("templatetag01")
+        self.assertEqual(output, "{%")
 
-    @setup({'templatetag02': '{% templatetag closeblock %}'})
+    @setup({"templatetag02": "{% templatetag closeblock %}"})
     def test_templatetag02(self):
-        output = self.engine.render_to_string('templatetag02')
-        self.assertEqual(output, '%}')
+        output = self.engine.render_to_string("templatetag02")
+        self.assertEqual(output, "%}")
 
-    @setup({'templatetag03': '{% templatetag openvariable %}'})
+    @setup({"templatetag03": "{% templatetag openvariable %}"})
     def test_templatetag03(self):
-        output = self.engine.render_to_string('templatetag03')
-        self.assertEqual(output, '{{')
+        output = self.engine.render_to_string("templatetag03")
+        self.assertEqual(output, "{{")
 
-    @setup({'templatetag04': '{% templatetag closevariable %}'})
+    @setup({"templatetag04": "{% templatetag closevariable %}"})
     def test_templatetag04(self):
-        output = self.engine.render_to_string('templatetag04')
-        self.assertEqual(output, '}}')
+        output = self.engine.render_to_string("templatetag04")
+        self.assertEqual(output, "}}")
 
-    @setup({'templatetag05': '{% templatetag %}'})
+    @setup({"templatetag05": "{% templatetag %}"})
     def test_templatetag05(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('templatetag05')
+            self.engine.get_template("templatetag05")
 
-    @setup({'templatetag06': '{% templatetag foo %}'})
+    @setup({"templatetag06": "{% templatetag foo %}"})
     def test_templatetag06(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('templatetag06')
+            self.engine.get_template("templatetag06")
 
-    @setup({'templatetag07': '{% templatetag openbrace %}'})
+    @setup({"templatetag07": "{% templatetag openbrace %}"})
     def test_templatetag07(self):
-        output = self.engine.render_to_string('templatetag07')
-        self.assertEqual(output, '{')
+        output = self.engine.render_to_string("templatetag07")
+        self.assertEqual(output, "{")
 
-    @setup({'templatetag08': '{% templatetag closebrace %}'})
+    @setup({"templatetag08": "{% templatetag closebrace %}"})
     def test_templatetag08(self):
-        output = self.engine.render_to_string('templatetag08')
-        self.assertEqual(output, '}')
+        output = self.engine.render_to_string("templatetag08")
+        self.assertEqual(output, "}")
 
-    @setup({'templatetag09': '{% templatetag openbrace %}{% templatetag openbrace %}'})
+    @setup({"templatetag09": "{% templatetag openbrace %}{% templatetag openbrace %}"})
     def test_templatetag09(self):
-        output = self.engine.render_to_string('templatetag09')
-        self.assertEqual(output, '{{')
+        output = self.engine.render_to_string("templatetag09")
+        self.assertEqual(output, "{{")
 
-    @setup({'templatetag10': '{% templatetag closebrace %}{% templatetag closebrace %}'})
+    @setup(
+        {"templatetag10": "{% templatetag closebrace %}{% templatetag closebrace %}"}
+    )
     def test_templatetag10(self):
-        output = self.engine.render_to_string('templatetag10')
-        self.assertEqual(output, '}}')
+        output = self.engine.render_to_string("templatetag10")
+        self.assertEqual(output, "}}")
 
-    @setup({'templatetag11': '{% templatetag opencomment %}'})
+    @setup({"templatetag11": "{% templatetag opencomment %}"})
     def test_templatetag11(self):
-        output = self.engine.render_to_string('templatetag11')
-        self.assertEqual(output, '{#')
+        output = self.engine.render_to_string("templatetag11")
+        self.assertEqual(output, "{#")
 
-    @setup({'templatetag12': '{% templatetag closecomment %}'})
+    @setup({"templatetag12": "{% templatetag closecomment %}"})
     def test_templatetag12(self):
-        output = self.engine.render_to_string('templatetag12')
-        self.assertEqual(output, '#}')
+        output = self.engine.render_to_string("templatetag12")
+        self.assertEqual(output, "#}")
diff --git a/tests/template_tests/syntax_tests/test_url.py b/tests/template_tests/syntax_tests/test_url.py
index 831eac5527..3e51b0e3f5 100644
--- a/tests/template_tests/syntax_tests/test_url.py
+++ b/tests/template_tests/syntax_tests/test_url.py
@@ -6,286 +6,300 @@ from django.urls import NoReverseMatch, resolve
 from ..utils import setup
 
 
-@override_settings(ROOT_URLCONF='template_tests.urls')
+@override_settings(ROOT_URLCONF="template_tests.urls")
 class UrlTagTests(SimpleTestCase):
     request_factory = RequestFactory()
 
     # Successes
-    @setup({'url01': '{% url "client" client.id %}'})
+    @setup({"url01": '{% url "client" client.id %}'})
     def test_url01(self):
-        output = self.engine.render_to_string('url01', {'client': {'id': 1}})
-        self.assertEqual(output, '/client/1/')
+        output = self.engine.render_to_string("url01", {"client": {"id": 1}})
+        self.assertEqual(output, "/client/1/")
 
-    @setup({'url02': '{% url "client_action" id=client.id action="update" %}'})
+    @setup({"url02": '{% url "client_action" id=client.id action="update" %}'})
     def test_url02(self):
-        output = self.engine.render_to_string('url02', {'client': {'id': 1}})
-        self.assertEqual(output, '/client/1/update/')
+        output = self.engine.render_to_string("url02", {"client": {"id": 1}})
+        self.assertEqual(output, "/client/1/update/")
 
-    @setup({'url02a': '{% url "client_action" client.id "update" %}'})
+    @setup({"url02a": '{% url "client_action" client.id "update" %}'})
     def test_url02a(self):
-        output = self.engine.render_to_string('url02a', {'client': {'id': 1}})
-        self.assertEqual(output, '/client/1/update/')
+        output = self.engine.render_to_string("url02a", {"client": {"id": 1}})
+        self.assertEqual(output, "/client/1/update/")
 
-    @setup({'url02b': "{% url 'client_action' id=client.id action='update' %}"})
+    @setup({"url02b": "{% url 'client_action' id=client.id action='update' %}"})
     def test_url02b(self):
-        output = self.engine.render_to_string('url02b', {'client': {'id': 1}})
-        self.assertEqual(output, '/client/1/update/')
+        output = self.engine.render_to_string("url02b", {"client": {"id": 1}})
+        self.assertEqual(output, "/client/1/update/")
 
-    @setup({'url02c': "{% url 'client_action' client.id 'update' %}"})
+    @setup({"url02c": "{% url 'client_action' client.id 'update' %}"})
     def test_url02c(self):
-        output = self.engine.render_to_string('url02c', {'client': {'id': 1}})
-        self.assertEqual(output, '/client/1/update/')
+        output = self.engine.render_to_string("url02c", {"client": {"id": 1}})
+        self.assertEqual(output, "/client/1/update/")
 
-    @setup({'url03': '{% url "index" %}'})
+    @setup({"url03": '{% url "index" %}'})
     def test_url03(self):
-        output = self.engine.render_to_string('url03')
-        self.assertEqual(output, '/')
+        output = self.engine.render_to_string("url03")
+        self.assertEqual(output, "/")
 
-    @setup({'url04': '{% url "named.client" client.id %}'})
+    @setup({"url04": '{% url "named.client" client.id %}'})
     def test_url04(self):
-        output = self.engine.render_to_string('url04', {'client': {'id': 1}})
-        self.assertEqual(output, '/named-client/1/')
+        output = self.engine.render_to_string("url04", {"client": {"id": 1}})
+        self.assertEqual(output, "/named-client/1/")
 
-    @setup({'url05': '{% url "метка_оператора" v %}'})
+    @setup({"url05": '{% url "метка_оператора" v %}'})
     def test_url05(self):
-        output = self.engine.render_to_string('url05', {'v': 'Ω'})
-        self.assertEqual(output, '/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/')
+        output = self.engine.render_to_string("url05", {"v": "Ω"})
+        self.assertEqual(output, "/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/")
 
-    @setup({'url06': '{% url "метка_оператора_2" tag=v %}'})
+    @setup({"url06": '{% url "метка_оператора_2" tag=v %}'})
     def test_url06(self):
-        output = self.engine.render_to_string('url06', {'v': 'Ω'})
-        self.assertEqual(output, '/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/')
+        output = self.engine.render_to_string("url06", {"v": "Ω"})
+        self.assertEqual(output, "/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/")
 
-    @setup({'url08': '{% url "метка_оператора" v %}'})
+    @setup({"url08": '{% url "метка_оператора" v %}'})
     def test_url08(self):
-        output = self.engine.render_to_string('url08', {'v': 'Ω'})
-        self.assertEqual(output, '/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/')
+        output = self.engine.render_to_string("url08", {"v": "Ω"})
+        self.assertEqual(output, "/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/")
 
-    @setup({'url09': '{% url "метка_оператора_2" tag=v %}'})
+    @setup({"url09": '{% url "метка_оператора_2" tag=v %}'})
     def test_url09(self):
-        output = self.engine.render_to_string('url09', {'v': 'Ω'})
-        self.assertEqual(output, '/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/')
+        output = self.engine.render_to_string("url09", {"v": "Ω"})
+        self.assertEqual(output, "/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/")
 
-    @setup({'url10': '{% url "client_action" id=client.id action="two words" %}'})
+    @setup({"url10": '{% url "client_action" id=client.id action="two words" %}'})
     def test_url10(self):
-        output = self.engine.render_to_string('url10', {'client': {'id': 1}})
-        self.assertEqual(output, '/client/1/two%20words/')
+        output = self.engine.render_to_string("url10", {"client": {"id": 1}})
+        self.assertEqual(output, "/client/1/two%20words/")
 
-    @setup({'url11': '{% url "client_action" id=client.id action="==" %}'})
+    @setup({"url11": '{% url "client_action" id=client.id action="==" %}'})
     def test_url11(self):
-        output = self.engine.render_to_string('url11', {'client': {'id': 1}})
-        self.assertEqual(output, '/client/1/==/')
+        output = self.engine.render_to_string("url11", {"client": {"id": 1}})
+        self.assertEqual(output, "/client/1/==/")
 
-    @setup({'url12': '{% url "client_action" id=client.id action="!$&\'()*+,;=~:@," %}'})
+    @setup(
+        {"url12": '{% url "client_action" id=client.id action="!$&\'()*+,;=~:@," %}'}
+    )
     def test_url12(self):
-        output = self.engine.render_to_string('url12', {'client': {'id': 1}})
-        self.assertEqual(output, '/client/1/!$&amp;&#x27;()*+,;=~:@,/')
+        output = self.engine.render_to_string("url12", {"client": {"id": 1}})
+        self.assertEqual(output, "/client/1/!$&amp;&#x27;()*+,;=~:@,/")
 
-    @setup({'url13': '{% url "client_action" id=client.id action=arg|join:"-" %}'})
+    @setup({"url13": '{% url "client_action" id=client.id action=arg|join:"-" %}'})
     def test_url13(self):
-        output = self.engine.render_to_string('url13', {'client': {'id': 1}, 'arg': ['a', 'b']})
-        self.assertEqual(output, '/client/1/a-b/')
+        output = self.engine.render_to_string(
+            "url13", {"client": {"id": 1}, "arg": ["a", "b"]}
+        )
+        self.assertEqual(output, "/client/1/a-b/")
 
-    @setup({'url14': '{% url "client_action" client.id arg|join:"-" %}'})
+    @setup({"url14": '{% url "client_action" client.id arg|join:"-" %}'})
     def test_url14(self):
-        output = self.engine.render_to_string('url14', {'client': {'id': 1}, 'arg': ['a', 'b']})
-        self.assertEqual(output, '/client/1/a-b/')
+        output = self.engine.render_to_string(
+            "url14", {"client": {"id": 1}, "arg": ["a", "b"]}
+        )
+        self.assertEqual(output, "/client/1/a-b/")
 
-    @setup({'url15': '{% url "client_action" 12 "test" %}'})
+    @setup({"url15": '{% url "client_action" 12 "test" %}'})
     def test_url15(self):
-        output = self.engine.render_to_string('url15')
-        self.assertEqual(output, '/client/12/test/')
+        output = self.engine.render_to_string("url15")
+        self.assertEqual(output, "/client/12/test/")
 
-    @setup({'url18': '{% url "client" "1,2" %}'})
+    @setup({"url18": '{% url "client" "1,2" %}'})
     def test_url18(self):
-        output = self.engine.render_to_string('url18')
-        self.assertEqual(output, '/client/1,2/')
+        output = self.engine.render_to_string("url18")
+        self.assertEqual(output, "/client/1,2/")
 
-    @setup({'url19': '{% url named_url client.id %}'})
+    @setup({"url19": "{% url named_url client.id %}"})
     def test_url19(self):
         output = self.engine.render_to_string(
-            'url19', {'client': {'id': 1}, 'named_url': 'client'}
+            "url19", {"client": {"id": 1}, "named_url": "client"}
         )
-        self.assertEqual(output, '/client/1/')
+        self.assertEqual(output, "/client/1/")
 
-    @setup({'url20': '{% url url_name_in_var client.id %}'})
+    @setup({"url20": "{% url url_name_in_var client.id %}"})
     def test_url20(self):
-        output = self.engine.render_to_string('url20', {'client': {'id': 1}, 'url_name_in_var': 'named.client'})
-        self.assertEqual(output, '/named-client/1/')
+        output = self.engine.render_to_string(
+            "url20", {"client": {"id": 1}, "url_name_in_var": "named.client"}
+        )
+        self.assertEqual(output, "/named-client/1/")
 
-    @setup({'url21': '{% autoescape off %}'
-                     '{% url "client_action" id=client.id action="!$&\'()*+,;=~:@," %}'
-                     '{% endautoescape %}'})
+    @setup(
+        {
+            "url21": "{% autoescape off %}"
+            '{% url "client_action" id=client.id action="!$&\'()*+,;=~:@," %}'
+            "{% endautoescape %}"
+        }
+    )
     def test_url21(self):
-        output = self.engine.render_to_string('url21', {'client': {'id': 1}})
-        self.assertEqual(output, '/client/1/!$&\'()*+,;=~:@,/')
+        output = self.engine.render_to_string("url21", {"client": {"id": 1}})
+        self.assertEqual(output, "/client/1/!$&'()*+,;=~:@,/")
 
     # Failures
-    @setup({'url-fail01': '{% url %}'})
+    @setup({"url-fail01": "{% url %}"})
     def test_url_fail01(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('url-fail01')
+            self.engine.get_template("url-fail01")
 
-    @setup({'url-fail02': '{% url "no_such_view" %}'})
+    @setup({"url-fail02": '{% url "no_such_view" %}'})
     def test_url_fail02(self):
         with self.assertRaises(NoReverseMatch):
-            self.engine.render_to_string('url-fail02')
+            self.engine.render_to_string("url-fail02")
 
-    @setup({'url-fail03': '{% url "client" %}'})
+    @setup({"url-fail03": '{% url "client" %}'})
     def test_url_fail03(self):
         with self.assertRaises(NoReverseMatch):
-            self.engine.render_to_string('url-fail03')
+            self.engine.render_to_string("url-fail03")
 
-    @setup({'url-fail04': '{% url "view" id, %}'})
+    @setup({"url-fail04": '{% url "view" id, %}'})
     def test_url_fail04(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('url-fail04')
+            self.engine.get_template("url-fail04")
 
-    @setup({'url-fail05': '{% url "view" id= %}'})
+    @setup({"url-fail05": '{% url "view" id= %}'})
     def test_url_fail05(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('url-fail05')
+            self.engine.get_template("url-fail05")
 
-    @setup({'url-fail06': '{% url "view" a.id=id %}'})
+    @setup({"url-fail06": '{% url "view" a.id=id %}'})
     def test_url_fail06(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('url-fail06')
+            self.engine.get_template("url-fail06")
 
-    @setup({'url-fail07': '{% url "view" a.id!id %}'})
+    @setup({"url-fail07": '{% url "view" a.id!id %}'})
     def test_url_fail07(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('url-fail07')
+            self.engine.get_template("url-fail07")
 
-    @setup({'url-fail08': '{% url "view" id="unterminatedstring %}'})
+    @setup({"url-fail08": '{% url "view" id="unterminatedstring %}'})
     def test_url_fail08(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('url-fail08')
+            self.engine.get_template("url-fail08")
 
-    @setup({'url-fail09': '{% url "view" id=", %}'})
+    @setup({"url-fail09": '{% url "view" id=", %}'})
     def test_url_fail09(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('url-fail09')
+            self.engine.get_template("url-fail09")
 
-    @setup({'url-fail11': '{% url named_url %}'})
+    @setup({"url-fail11": "{% url named_url %}"})
     def test_url_fail11(self):
         with self.assertRaises(NoReverseMatch):
-            self.engine.render_to_string('url-fail11')
+            self.engine.render_to_string("url-fail11")
 
-    @setup({'url-fail12': '{% url named_url %}'})
+    @setup({"url-fail12": "{% url named_url %}"})
     def test_url_fail12(self):
         with self.assertRaises(NoReverseMatch):
-            self.engine.render_to_string('url-fail12', {'named_url': 'no_such_view'})
+            self.engine.render_to_string("url-fail12", {"named_url": "no_such_view"})
 
-    @setup({'url-fail13': '{% url named_url %}'})
+    @setup({"url-fail13": "{% url named_url %}"})
     def test_url_fail13(self):
         with self.assertRaises(NoReverseMatch):
-            self.engine.render_to_string('url-fail13', {'named_url': 'template_tests.views.client'})
+            self.engine.render_to_string(
+                "url-fail13", {"named_url": "template_tests.views.client"}
+            )
 
-    @setup({'url-fail14': '{% url named_url id, %}'})
+    @setup({"url-fail14": "{% url named_url id, %}"})
     def test_url_fail14(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.render_to_string('url-fail14', {'named_url': 'view'})
+            self.engine.render_to_string("url-fail14", {"named_url": "view"})
 
-    @setup({'url-fail15': '{% url named_url id= %}'})
+    @setup({"url-fail15": "{% url named_url id= %}"})
     def test_url_fail15(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.render_to_string('url-fail15', {'named_url': 'view'})
+            self.engine.render_to_string("url-fail15", {"named_url": "view"})
 
-    @setup({'url-fail16': '{% url named_url a.id=id %}'})
+    @setup({"url-fail16": "{% url named_url a.id=id %}"})
     def test_url_fail16(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.render_to_string('url-fail16', {'named_url': 'view'})
+            self.engine.render_to_string("url-fail16", {"named_url": "view"})
 
-    @setup({'url-fail17': '{% url named_url a.id!id %}'})
+    @setup({"url-fail17": "{% url named_url a.id!id %}"})
     def test_url_fail17(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.render_to_string('url-fail17', {'named_url': 'view'})
+            self.engine.render_to_string("url-fail17", {"named_url": "view"})
 
-    @setup({'url-fail18': '{% url named_url id="unterminatedstring %}'})
+    @setup({"url-fail18": '{% url named_url id="unterminatedstring %}'})
     def test_url_fail18(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.render_to_string('url-fail18', {'named_url': 'view'})
+            self.engine.render_to_string("url-fail18", {"named_url": "view"})
 
-    @setup({'url-fail19': '{% url named_url id=", %}'})
+    @setup({"url-fail19": '{% url named_url id=", %}'})
     def test_url_fail19(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.render_to_string('url-fail19', {'named_url': 'view'})
+            self.engine.render_to_string("url-fail19", {"named_url": "view"})
 
     # {% url ... as var %}
-    @setup({'url-asvar01': '{% url "index" as url %}'})
+    @setup({"url-asvar01": '{% url "index" as url %}'})
     def test_url_asvar01(self):
-        output = self.engine.render_to_string('url-asvar01')
-        self.assertEqual(output, '')
+        output = self.engine.render_to_string("url-asvar01")
+        self.assertEqual(output, "")
 
-    @setup({'url-asvar02': '{% url "index" as url %}{{ url }}'})
+    @setup({"url-asvar02": '{% url "index" as url %}{{ url }}'})
     def test_url_asvar02(self):
-        output = self.engine.render_to_string('url-asvar02')
-        self.assertEqual(output, '/')
+        output = self.engine.render_to_string("url-asvar02")
+        self.assertEqual(output, "/")
 
-    @setup({'url-asvar03': '{% url "no_such_view" as url %}{{ url }}'})
+    @setup({"url-asvar03": '{% url "no_such_view" as url %}{{ url }}'})
     def test_url_asvar03(self):
-        output = self.engine.render_to_string('url-asvar03')
-        self.assertEqual(output, '')
+        output = self.engine.render_to_string("url-asvar03")
+        self.assertEqual(output, "")
 
-    @setup({'url-namespace01': '{% url "app:named.client" 42 %}'})
+    @setup({"url-namespace01": '{% url "app:named.client" 42 %}'})
     def test_url_namespace01(self):
-        request = self.request_factory.get('/')
-        request.resolver_match = resolve('/ns1/')
-        template = self.engine.get_template('url-namespace01')
+        request = self.request_factory.get("/")
+        request.resolver_match = resolve("/ns1/")
+        template = self.engine.get_template("url-namespace01")
         context = RequestContext(request)
         output = template.render(context)
-        self.assertEqual(output, '/ns1/named-client/42/')
+        self.assertEqual(output, "/ns1/named-client/42/")
 
-    @setup({'url-namespace02': '{% url "app:named.client" 42 %}'})
+    @setup({"url-namespace02": '{% url "app:named.client" 42 %}'})
     def test_url_namespace02(self):
-        request = self.request_factory.get('/')
-        request.resolver_match = resolve('/ns2/')
-        template = self.engine.get_template('url-namespace02')
+        request = self.request_factory.get("/")
+        request.resolver_match = resolve("/ns2/")
+        template = self.engine.get_template("url-namespace02")
         context = RequestContext(request)
         output = template.render(context)
-        self.assertEqual(output, '/ns2/named-client/42/')
+        self.assertEqual(output, "/ns2/named-client/42/")
 
-    @setup({'url-namespace03': '{% url "app:named.client" 42 %}'})
+    @setup({"url-namespace03": '{% url "app:named.client" 42 %}'})
     def test_url_namespace03(self):
-        request = self.request_factory.get('/')
-        template = self.engine.get_template('url-namespace03')
+        request = self.request_factory.get("/")
+        template = self.engine.get_template("url-namespace03")
         context = RequestContext(request)
         output = template.render(context)
-        self.assertEqual(output, '/ns2/named-client/42/')
+        self.assertEqual(output, "/ns2/named-client/42/")
 
-    @setup({'url-namespace-no-current-app': '{% url "app:named.client" 42 %}'})
+    @setup({"url-namespace-no-current-app": '{% url "app:named.client" 42 %}'})
     def test_url_namespace_no_current_app(self):
-        request = self.request_factory.get('/')
-        request.resolver_match = resolve('/ns1/')
+        request = self.request_factory.get("/")
+        request.resolver_match = resolve("/ns1/")
         request.current_app = None
-        template = self.engine.get_template('url-namespace-no-current-app')
+        template = self.engine.get_template("url-namespace-no-current-app")
         context = RequestContext(request)
         output = template.render(context)
-        self.assertEqual(output, '/ns2/named-client/42/')
+        self.assertEqual(output, "/ns2/named-client/42/")
 
-    @setup({'url-namespace-explicit-current-app': '{% url "app:named.client" 42 %}'})
+    @setup({"url-namespace-explicit-current-app": '{% url "app:named.client" 42 %}'})
     def test_url_namespace_explicit_current_app(self):
-        request = self.request_factory.get('/')
-        request.resolver_match = resolve('/ns1/')
-        request.current_app = 'app'
-        template = self.engine.get_template('url-namespace-explicit-current-app')
+        request = self.request_factory.get("/")
+        request.resolver_match = resolve("/ns1/")
+        request.current_app = "app"
+        template = self.engine.get_template("url-namespace-explicit-current-app")
         context = RequestContext(request)
         output = template.render(context)
-        self.assertEqual(output, '/ns2/named-client/42/')
+        self.assertEqual(output, "/ns2/named-client/42/")
 
 
 class URLNodeTest(SimpleTestCase):
     def test_repr(self):
-        url_node = URLNode(view_name='named-view', args=[], kwargs={}, asvar=None)
+        url_node = URLNode(view_name="named-view", args=[], kwargs={}, asvar=None)
         self.assertEqual(
             repr(url_node),
             "<URLNode view_name='named-view' args=[] kwargs={} as=None>",
         )
         url_node = URLNode(
-            view_name='named-view',
+            view_name="named-view",
             args=[1, 2],
-            kwargs={'action': 'update'},
-            asvar='my_url',
+            kwargs={"action": "update"},
+            asvar="my_url",
         )
         self.assertEqual(
             repr(url_node),
diff --git a/tests/template_tests/syntax_tests/test_verbatim.py b/tests/template_tests/syntax_tests/test_verbatim.py
index 7304796b4b..afb08e013a 100644
--- a/tests/template_tests/syntax_tests/test_verbatim.py
+++ b/tests/template_tests/syntax_tests/test_verbatim.py
@@ -5,34 +5,47 @@ from ..utils import setup
 
 
 class VerbatimTagTests(SimpleTestCase):
-
-    @setup({'verbatim-tag01': '{% verbatim %}{{bare   }}{% endverbatim %}'})
+    @setup({"verbatim-tag01": "{% verbatim %}{{bare   }}{% endverbatim %}"})
     def test_verbatim_tag01(self):
-        output = self.engine.render_to_string('verbatim-tag01')
-        self.assertEqual(output, '{{bare   }}')
+        output = self.engine.render_to_string("verbatim-tag01")
+        self.assertEqual(output, "{{bare   }}")
 
-    @setup({'verbatim-tag02': '{% verbatim %}{% endif %}{% endverbatim %}'})
+    @setup({"verbatim-tag02": "{% verbatim %}{% endif %}{% endverbatim %}"})
     def test_verbatim_tag02(self):
-        output = self.engine.render_to_string('verbatim-tag02')
-        self.assertEqual(output, '{% endif %}')
+        output = self.engine.render_to_string("verbatim-tag02")
+        self.assertEqual(output, "{% endif %}")
 
-    @setup({'verbatim-tag03': '{% verbatim %}It\'s the {% verbatim %} tag{% endverbatim %}'})
+    @setup(
+        {"verbatim-tag03": "{% verbatim %}It's the {% verbatim %} tag{% endverbatim %}"}
+    )
     def test_verbatim_tag03(self):
-        output = self.engine.render_to_string('verbatim-tag03')
-        self.assertEqual(output, 'It\'s the {% verbatim %} tag')
+        output = self.engine.render_to_string("verbatim-tag03")
+        self.assertEqual(output, "It's the {% verbatim %} tag")
 
-    @setup({'verbatim-tag04': '{% verbatim %}{% verbatim %}{% endverbatim %}{% endverbatim %}'})
+    @setup(
+        {
+            "verbatim-tag04": "{% verbatim %}{% verbatim %}{% endverbatim %}{% endverbatim %}"
+        }
+    )
     def test_verbatim_tag04(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('verbatim-tag04')
+            self.engine.get_template("verbatim-tag04")
 
-    @setup({'verbatim-tag05': '{% verbatim %}{% endverbatim %}{% verbatim %}{% endverbatim %}'})
+    @setup(
+        {
+            "verbatim-tag05": "{% verbatim %}{% endverbatim %}{% verbatim %}{% endverbatim %}"
+        }
+    )
     def test_verbatim_tag05(self):
-        output = self.engine.render_to_string('verbatim-tag05')
-        self.assertEqual(output, '')
+        output = self.engine.render_to_string("verbatim-tag05")
+        self.assertEqual(output, "")
 
-    @setup({'verbatim-tag06': '{% verbatim special %}'
-                              'Don\'t {% endverbatim %} just yet{% endverbatim special %}'})
+    @setup(
+        {
+            "verbatim-tag06": "{% verbatim special %}"
+            "Don't {% endverbatim %} just yet{% endverbatim special %}"
+        }
+    )
     def test_verbatim_tag06(self):
-        output = self.engine.render_to_string('verbatim-tag06')
-        self.assertEqual(output, 'Don\'t {% endverbatim %} just yet')
+        output = self.engine.render_to_string("verbatim-tag06")
+        self.assertEqual(output, "Don't {% endverbatim %} just yet")
diff --git a/tests/template_tests/syntax_tests/test_width_ratio.py b/tests/template_tests/syntax_tests/test_width_ratio.py
index 7db90a44e1..3f3a072f96 100644
--- a/tests/template_tests/syntax_tests/test_width_ratio.py
+++ b/tests/template_tests/syntax_tests/test_width_ratio.py
@@ -5,150 +5,164 @@ from ..utils import setup
 
 
 class WidthRatioTagTests(SimpleTestCase):
-    libraries = {'custom': 'template_tests.templatetags.custom'}
+    libraries = {"custom": "template_tests.templatetags.custom"}
 
-    @setup({'widthratio01': '{% widthratio a b 0 %}'})
+    @setup({"widthratio01": "{% widthratio a b 0 %}"})
     def test_widthratio01(self):
-        output = self.engine.render_to_string('widthratio01', {'a': 50, 'b': 100})
-        self.assertEqual(output, '0')
+        output = self.engine.render_to_string("widthratio01", {"a": 50, "b": 100})
+        self.assertEqual(output, "0")
 
-    @setup({'widthratio02': '{% widthratio a b 100 %}'})
+    @setup({"widthratio02": "{% widthratio a b 100 %}"})
     def test_widthratio02(self):
-        output = self.engine.render_to_string('widthratio02', {'a': 0, 'b': 0})
-        self.assertEqual(output, '0')
+        output = self.engine.render_to_string("widthratio02", {"a": 0, "b": 0})
+        self.assertEqual(output, "0")
 
-    @setup({'widthratio03': '{% widthratio a b 100 %}'})
+    @setup({"widthratio03": "{% widthratio a b 100 %}"})
     def test_widthratio03(self):
-        output = self.engine.render_to_string('widthratio03', {'a': 0, 'b': 100})
-        self.assertEqual(output, '0')
+        output = self.engine.render_to_string("widthratio03", {"a": 0, "b": 100})
+        self.assertEqual(output, "0")
 
-    @setup({'widthratio04': '{% widthratio a b 100 %}'})
+    @setup({"widthratio04": "{% widthratio a b 100 %}"})
     def test_widthratio04(self):
-        output = self.engine.render_to_string('widthratio04', {'a': 50, 'b': 100})
-        self.assertEqual(output, '50')
+        output = self.engine.render_to_string("widthratio04", {"a": 50, "b": 100})
+        self.assertEqual(output, "50")
 
-    @setup({'widthratio05': '{% widthratio a b 100 %}'})
+    @setup({"widthratio05": "{% widthratio a b 100 %}"})
     def test_widthratio05(self):
-        output = self.engine.render_to_string('widthratio05', {'a': 100, 'b': 100})
-        self.assertEqual(output, '100')
+        output = self.engine.render_to_string("widthratio05", {"a": 100, "b": 100})
+        self.assertEqual(output, "100")
 
-    @setup({'widthratio06': '{% widthratio a b 100 %}'})
+    @setup({"widthratio06": "{% widthratio a b 100 %}"})
     def test_widthratio06(self):
         """
         62.5 should round to 62
         """
-        output = self.engine.render_to_string('widthratio06', {'a': 50, 'b': 80})
-        self.assertEqual(output, '62')
+        output = self.engine.render_to_string("widthratio06", {"a": 50, "b": 80})
+        self.assertEqual(output, "62")
 
-    @setup({'widthratio07': '{% widthratio a b 100 %}'})
+    @setup({"widthratio07": "{% widthratio a b 100 %}"})
     def test_widthratio07(self):
         """
         71.4 should round to 71
         """
-        output = self.engine.render_to_string('widthratio07', {'a': 50, 'b': 70})
-        self.assertEqual(output, '71')
+        output = self.engine.render_to_string("widthratio07", {"a": 50, "b": 70})
+        self.assertEqual(output, "71")
 
     # Raise exception if we don't have 3 args, last one an integer
-    @setup({'widthratio08': '{% widthratio %}'})
+    @setup({"widthratio08": "{% widthratio %}"})
     def test_widthratio08(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('widthratio08')
+            self.engine.get_template("widthratio08")
 
-    @setup({'widthratio09': '{% widthratio a b %}'})
+    @setup({"widthratio09": "{% widthratio a b %}"})
     def test_widthratio09(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.render_to_string('widthratio09', {'a': 50, 'b': 100})
+            self.engine.render_to_string("widthratio09", {"a": 50, "b": 100})
 
-    @setup({'widthratio10': '{% widthratio a b 100.0 %}'})
+    @setup({"widthratio10": "{% widthratio a b 100.0 %}"})
     def test_widthratio10(self):
-        output = self.engine.render_to_string('widthratio10', {'a': 50, 'b': 100})
-        self.assertEqual(output, '50')
+        output = self.engine.render_to_string("widthratio10", {"a": 50, "b": 100})
+        self.assertEqual(output, "50")
 
-    @setup({'widthratio11': '{% widthratio a b c %}'})
+    @setup({"widthratio11": "{% widthratio a b c %}"})
     def test_widthratio11(self):
         """
         #10043: widthratio should allow max_width to be a variable
         """
-        output = self.engine.render_to_string('widthratio11', {'a': 50, 'c': 100, 'b': 100})
-        self.assertEqual(output, '50')
+        output = self.engine.render_to_string(
+            "widthratio11", {"a": 50, "c": 100, "b": 100}
+        )
+        self.assertEqual(output, "50")
 
     # #18739: widthratio should handle None args consistently with
     # non-numerics
-    @setup({'widthratio12a': '{% widthratio a b c %}'})
+    @setup({"widthratio12a": "{% widthratio a b c %}"})
     def test_widthratio12a(self):
-        output = self.engine.render_to_string('widthratio12a', {'a': 'a', 'c': 100, 'b': 100})
-        self.assertEqual(output, '')
+        output = self.engine.render_to_string(
+            "widthratio12a", {"a": "a", "c": 100, "b": 100}
+        )
+        self.assertEqual(output, "")
 
-    @setup({'widthratio12b': '{% widthratio a b c %}'})
+    @setup({"widthratio12b": "{% widthratio a b c %}"})
     def test_widthratio12b(self):
-        output = self.engine.render_to_string('widthratio12b', {'a': None, 'c': 100, 'b': 100})
-        self.assertEqual(output, '')
+        output = self.engine.render_to_string(
+            "widthratio12b", {"a": None, "c": 100, "b": 100}
+        )
+        self.assertEqual(output, "")
 
-    @setup({'widthratio13a': '{% widthratio a b c %}'})
+    @setup({"widthratio13a": "{% widthratio a b c %}"})
     def test_widthratio13a(self):
-        output = self.engine.render_to_string('widthratio13a', {'a': 0, 'c': 100, 'b': 'b'})
-        self.assertEqual(output, '')
+        output = self.engine.render_to_string(
+            "widthratio13a", {"a": 0, "c": 100, "b": "b"}
+        )
+        self.assertEqual(output, "")
 
-    @setup({'widthratio13b': '{% widthratio a b c %}'})
+    @setup({"widthratio13b": "{% widthratio a b c %}"})
     def test_widthratio13b(self):
-        output = self.engine.render_to_string('widthratio13b', {'a': 0, 'c': 100, 'b': None})
-        self.assertEqual(output, '')
+        output = self.engine.render_to_string(
+            "widthratio13b", {"a": 0, "c": 100, "b": None}
+        )
+        self.assertEqual(output, "")
 
-    @setup({'widthratio14a': '{% widthratio a b c %}'})
+    @setup({"widthratio14a": "{% widthratio a b c %}"})
     def test_widthratio14a(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.render_to_string('widthratio14a', {'a': 0, 'c': 'c', 'b': 100})
+            self.engine.render_to_string("widthratio14a", {"a": 0, "c": "c", "b": 100})
 
-    @setup({'widthratio14b': '{% widthratio a b c %}'})
+    @setup({"widthratio14b": "{% widthratio a b c %}"})
     def test_widthratio14b(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.render_to_string('widthratio14b', {'a': 0, 'c': None, 'b': 100})
+            self.engine.render_to_string("widthratio14b", {"a": 0, "c": None, "b": 100})
 
-    @setup({'widthratio15': '{% load custom %}{% widthratio a|noop:"x y" b 0 %}'})
+    @setup({"widthratio15": '{% load custom %}{% widthratio a|noop:"x y" b 0 %}'})
     def test_widthratio15(self):
         """
         Test whitespace in filter argument
         """
-        output = self.engine.render_to_string('widthratio15', {'a': 50, 'b': 100})
-        self.assertEqual(output, '0')
+        output = self.engine.render_to_string("widthratio15", {"a": 50, "b": 100})
+        self.assertEqual(output, "0")
 
     # Widthratio with variable assignment
-    @setup({'widthratio16': '{% widthratio a b 100 as variable %}-{{ variable }}-'})
+    @setup({"widthratio16": "{% widthratio a b 100 as variable %}-{{ variable }}-"})
     def test_widthratio16(self):
-        output = self.engine.render_to_string('widthratio16', {'a': 50, 'b': 100})
-        self.assertEqual(output, '-50-')
+        output = self.engine.render_to_string("widthratio16", {"a": 50, "b": 100})
+        self.assertEqual(output, "-50-")
 
-    @setup({'widthratio17': '{% widthratio a b 100 as variable %}-{{ variable }}-'})
+    @setup({"widthratio17": "{% widthratio a b 100 as variable %}-{{ variable }}-"})
     def test_widthratio17(self):
-        output = self.engine.render_to_string('widthratio17', {'a': 100, 'b': 100})
-        self.assertEqual(output, '-100-')
+        output = self.engine.render_to_string("widthratio17", {"a": 100, "b": 100})
+        self.assertEqual(output, "-100-")
 
-    @setup({'widthratio18': '{% widthratio a b 100 as %}'})
+    @setup({"widthratio18": "{% widthratio a b 100 as %}"})
     def test_widthratio18(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('widthratio18')
+            self.engine.get_template("widthratio18")
 
-    @setup({'widthratio19': '{% widthratio a b 100 not_as variable %}'})
+    @setup({"widthratio19": "{% widthratio a b 100 not_as variable %}"})
     def test_widthratio19(self):
         with self.assertRaises(TemplateSyntaxError):
-            self.engine.get_template('widthratio19')
+            self.engine.get_template("widthratio19")
 
-    @setup({'widthratio20': '{% widthratio a b 100 %}'})
+    @setup({"widthratio20": "{% widthratio a b 100 %}"})
     def test_widthratio20(self):
-        output = self.engine.render_to_string('widthratio20', {'a': float('inf'), 'b': float('inf')})
-        self.assertEqual(output, '')
+        output = self.engine.render_to_string(
+            "widthratio20", {"a": float("inf"), "b": float("inf")}
+        )
+        self.assertEqual(output, "")
 
-    @setup({'widthratio21': '{% widthratio a b 100 %}'})
+    @setup({"widthratio21": "{% widthratio a b 100 %}"})
     def test_widthratio21(self):
-        output = self.engine.render_to_string('widthratio21', {'a': float('inf'), 'b': 2})
-        self.assertEqual(output, '')
+        output = self.engine.render_to_string(
+            "widthratio21", {"a": float("inf"), "b": 2}
+        )
+        self.assertEqual(output, "")
 
-    @setup({'t': '{% widthratio a b 100 as variable %}-{{ variable }}-'})
+    @setup({"t": "{% widthratio a b 100 as variable %}-{{ variable }}-"})
     def test_zerodivisionerror_as_var(self):
-        output = self.engine.render_to_string('t', {'a': 0, 'b': 0})
-        self.assertEqual(output, '-0-')
+        output = self.engine.render_to_string("t", {"a": 0, "b": 0})
+        self.assertEqual(output, "-0-")
 
-    @setup({'t': '{% widthratio a b c as variable %}-{{ variable }}-'})
+    @setup({"t": "{% widthratio a b c as variable %}-{{ variable }}-"})
     def test_typeerror_as_var(self):
-        output = self.engine.render_to_string('t', {'a': 'a', 'c': 100, 'b': 100})
-        self.assertEqual(output, '--')
+        output = self.engine.render_to_string("t", {"a": "a", "c": 100, "b": 100})
+        self.assertEqual(output, "--")
diff --git a/tests/template_tests/syntax_tests/test_with.py b/tests/template_tests/syntax_tests/test_with.py
index d8f24349f5..dde581eab3 100644
--- a/tests/template_tests/syntax_tests/test_with.py
+++ b/tests/template_tests/syntax_tests/test_with.py
@@ -8,53 +8,61 @@ from ..utils import setup
 class WithTagTests(SimpleTestCase):
     at_least_with_one_msg = "'with' expected at least one variable assignment"
 
-    @setup({'with01': '{% with key=dict.key %}{{ key }}{% endwith %}'})
+    @setup({"with01": "{% with key=dict.key %}{{ key }}{% endwith %}"})
     def test_with01(self):
-        output = self.engine.render_to_string('with01', {'dict': {'key': 50}})
-        self.assertEqual(output, '50')
+        output = self.engine.render_to_string("with01", {"dict": {"key": 50}})
+        self.assertEqual(output, "50")
 
-    @setup({'legacywith01': '{% with dict.key as key %}{{ key }}{% endwith %}'})
+    @setup({"legacywith01": "{% with dict.key as key %}{{ key }}{% endwith %}"})
     def test_legacywith01(self):
-        output = self.engine.render_to_string('legacywith01', {'dict': {'key': 50}})
-        self.assertEqual(output, '50')
+        output = self.engine.render_to_string("legacywith01", {"dict": {"key": 50}})
+        self.assertEqual(output, "50")
 
-    @setup({'with02': '{{ key }}{% with key=dict.key %}'
-                      '{{ key }}-{{ dict.key }}-{{ key }}'
-                      '{% endwith %}{{ key }}'})
+    @setup(
+        {
+            "with02": "{{ key }}{% with key=dict.key %}"
+            "{{ key }}-{{ dict.key }}-{{ key }}"
+            "{% endwith %}{{ key }}"
+        }
+    )
     def test_with02(self):
-        output = self.engine.render_to_string('with02', {'dict': {'key': 50}})
+        output = self.engine.render_to_string("with02", {"dict": {"key": 50}})
         if self.engine.string_if_invalid:
-            self.assertEqual(output, 'INVALID50-50-50INVALID')
+            self.assertEqual(output, "INVALID50-50-50INVALID")
         else:
-            self.assertEqual(output, '50-50-50')
+            self.assertEqual(output, "50-50-50")
 
-    @setup({'legacywith02': '{{ key }}{% with dict.key as key %}'
-                            '{{ key }}-{{ dict.key }}-{{ key }}'
-                            '{% endwith %}{{ key }}'})
+    @setup(
+        {
+            "legacywith02": "{{ key }}{% with dict.key as key %}"
+            "{{ key }}-{{ dict.key }}-{{ key }}"
+            "{% endwith %}{{ key }}"
+        }
+    )
     def test_legacywith02(self):
-        output = self.engine.render_to_string('legacywith02', {'dict': {'key': 50}})
+        output = self.engine.render_to_string("legacywith02", {"dict": {"key": 50}})
         if self.engine.string_if_invalid:
-            self.assertEqual(output, 'INVALID50-50-50INVALID')
+            self.assertEqual(output, "INVALID50-50-50INVALID")
         else:
-            self.assertEqual(output, '50-50-50')
+            self.assertEqual(output, "50-50-50")
 
-    @setup({'with03': '{% with a=alpha b=beta %}{{ a }}{{ b }}{% endwith %}'})
+    @setup({"with03": "{% with a=alpha b=beta %}{{ a }}{{ b }}{% endwith %}"})
     def test_with03(self):
-        output = self.engine.render_to_string('with03', {'alpha': 'A', 'beta': 'B'})
-        self.assertEqual(output, 'AB')
+        output = self.engine.render_to_string("with03", {"alpha": "A", "beta": "B"})
+        self.assertEqual(output, "AB")
 
-    @setup({'with-error01': '{% with dict.key xx key %}{{ key }}{% endwith %}'})
+    @setup({"with-error01": "{% with dict.key xx key %}{{ key }}{% endwith %}"})
     def test_with_error01(self):
         with self.assertRaisesMessage(TemplateSyntaxError, self.at_least_with_one_msg):
-            self.engine.render_to_string('with-error01', {'dict': {'key': 50}})
+            self.engine.render_to_string("with-error01", {"dict": {"key": 50}})
 
-    @setup({'with-error02': '{% with dict.key as %}{{ key }}{% endwith %}'})
+    @setup({"with-error02": "{% with dict.key as %}{{ key }}{% endwith %}"})
     def test_with_error02(self):
         with self.assertRaisesMessage(TemplateSyntaxError, self.at_least_with_one_msg):
-            self.engine.render_to_string('with-error02', {'dict': {'key': 50}})
+            self.engine.render_to_string("with-error02", {"dict": {"key": 50}})
 
 
 class WithNodeTests(SimpleTestCase):
     def test_repr(self):
-        node = WithNode(nodelist=[], name='a', var='dict.key')
-        self.assertEqual(repr(node), '<WithNode>')
+        node = WithNode(nodelist=[], name="a", var="dict.key")
+        self.assertEqual(repr(node), "<WithNode>")