Refs #33476 -- Reformatted code with Black.

11 files changed, 822 insertions, 535 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, "<")