Refs #33476 -- Reformatted code with Black.

1 files changed, 118 insertions, 102 deletions

diff --git a/tests/template_tests/test_context.py b/tests/template_tests/test_context.py
index 1150a14639..4feb9e57d6 100644
--- a/tests/template_tests/test_context.py
+++ b/tests/template_tests/test_context.py
@@ -2,14 +2,18 @@ from unittest import mock
 
 from django.http import HttpRequest
 from django.template import (
-    Context, Engine, RequestContext, Template, Variable, VariableDoesNotExist,
+    Context,
+    Engine,
+    RequestContext,
+    Template,
+    Variable,
+    VariableDoesNotExist,
 )
 from django.template.context import RenderContext
 from django.test import RequestFactory, SimpleTestCase
 
 
 class ContextTests(SimpleTestCase):
-
     def test_context(self):
         c = Context({"a": 1, "b": "xyzzy"})
         self.assertEqual(c["a"], 1)
@@ -25,75 +29,75 @@ class ContextTests(SimpleTestCase):
     def test_push_context_manager(self):
         c = Context({"a": 1})
         with c.push():
-            c['a'] = 2
-            self.assertEqual(c['a'], 2)
-        self.assertEqual(c['a'], 1)
+            c["a"] = 2
+            self.assertEqual(c["a"], 2)
+        self.assertEqual(c["a"], 1)
 
         with c.push(a=3):
-            self.assertEqual(c['a'], 3)
-        self.assertEqual(c['a'], 1)
+            self.assertEqual(c["a"], 3)
+        self.assertEqual(c["a"], 1)
 
     def test_update_context_manager(self):
         c = Context({"a": 1})
         with c.update({}):
-            c['a'] = 2
-            self.assertEqual(c['a'], 2)
-        self.assertEqual(c['a'], 1)
+            c["a"] = 2
+            self.assertEqual(c["a"], 2)
+        self.assertEqual(c["a"], 1)
 
-        with c.update({'a': 3}):
-            self.assertEqual(c['a'], 3)
-        self.assertEqual(c['a'], 1)
+        with c.update({"a": 3}):
+            self.assertEqual(c["a"], 3)
+        self.assertEqual(c["a"], 1)
 
     def test_push_context_manager_with_context_object(self):
-        c = Context({'a': 1})
-        with c.push(Context({'a': 3})):
-            self.assertEqual(c['a'], 3)
-        self.assertEqual(c['a'], 1)
+        c = Context({"a": 1})
+        with c.push(Context({"a": 3})):
+            self.assertEqual(c["a"], 3)
+        self.assertEqual(c["a"], 1)
 
     def test_update_context_manager_with_context_object(self):
-        c = Context({'a': 1})
-        with c.update(Context({'a': 3})):
-            self.assertEqual(c['a'], 3)
-        self.assertEqual(c['a'], 1)
+        c = Context({"a": 1})
+        with c.update(Context({"a": 3})):
+            self.assertEqual(c["a"], 3)
+        self.assertEqual(c["a"], 1)
 
     def test_push_proper_layering(self):
-        c = Context({'a': 1})
-        c.push(Context({'b': 2}))
-        c.push(Context({'c': 3, 'd': {'z': '26'}}))
+        c = Context({"a": 1})
+        c.push(Context({"b": 2}))
+        c.push(Context({"c": 3, "d": {"z": "26"}}))
         self.assertEqual(
             c.dicts,
             [
-                {'False': False, 'None': None, 'True': True},
-                {'a': 1},
-                {'b': 2},
-                {'c': 3, 'd': {'z': '26'}},
-            ]
+                {"False": False, "None": None, "True": True},
+                {"a": 1},
+                {"b": 2},
+                {"c": 3, "d": {"z": "26"}},
+            ],
         )
 
     def test_update_proper_layering(self):
-        c = Context({'a': 1})
-        c.update(Context({'b': 2}))
-        c.update(Context({'c': 3, 'd': {'z': '26'}}))
+        c = Context({"a": 1})
+        c.update(Context({"b": 2}))
+        c.update(Context({"c": 3, "d": {"z": "26"}}))
         self.assertEqual(
             c.dicts,
             [
-                {'False': False, 'None': None, 'True': True},
-                {'a': 1},
-                {'b': 2},
-                {'c': 3, 'd': {'z': '26'}},
-            ]
+                {"False": False, "None": None, "True": True},
+                {"a": 1},
+                {"b": 2},
+                {"c": 3, "d": {"z": "26"}},
+            ],
         )
 
     def test_setdefault(self):
         c = Context()
 
-        x = c.setdefault('x', 42)
+        x = c.setdefault("x", 42)
         self.assertEqual(x, 42)
-        self.assertEqual(c['x'], 42)
+        self.assertEqual(c["x"], 42)
 
-        x = c.setdefault('x', 100)
+        x = c.setdefault("x", 100)
         self.assertEqual(x, 42)
-        self.assertEqual(c['x'], 42)
+        self.assertEqual(c["x"], 42)
 
     def test_resolve_on_context_method(self):
         """
@@ -102,61 +106,64 @@ class ContextTests(SimpleTestCase):
         empty_context = Context()
 
         with self.assertRaises(VariableDoesNotExist):
-            Variable('no_such_variable').resolve(empty_context)
+            Variable("no_such_variable").resolve(empty_context)
 
         with self.assertRaises(VariableDoesNotExist):
-            Variable('new').resolve(empty_context)
+            Variable("new").resolve(empty_context)
 
         self.assertEqual(
-            Variable('new').resolve(Context({'new': 'foo'})),
-            'foo',
+            Variable("new").resolve(Context({"new": "foo"})),
+            "foo",
         )
 
     def test_render_context(self):
-        test_context = RenderContext({'fruit': 'papaya'})
+        test_context = RenderContext({"fruit": "papaya"})
 
         # push() limits access to the topmost dict
         test_context.push()
 
-        test_context['vegetable'] = 'artichoke'
-        self.assertEqual(list(test_context), ['vegetable'])
+        test_context["vegetable"] = "artichoke"
+        self.assertEqual(list(test_context), ["vegetable"])
 
-        self.assertNotIn('fruit', test_context)
+        self.assertNotIn("fruit", test_context)
         with self.assertRaises(KeyError):
-            test_context['fruit']
-        self.assertIsNone(test_context.get('fruit'))
+            test_context["fruit"]
+        self.assertIsNone(test_context.get("fruit"))
 
     def test_flatten_context(self):
         a = Context()
-        a.update({'a': 2})
-        a.update({'b': 4})
-        a.update({'c': 8})
+        a.update({"a": 2})
+        a.update({"b": 4})
+        a.update({"c": 8})
 
-        self.assertEqual(a.flatten(), {
-            'False': False, 'None': None, 'True': True,
-            'a': 2, 'b': 4, 'c': 8
-        })
+        self.assertEqual(
+            a.flatten(),
+            {"False": False, "None": None, "True": True, "a": 2, "b": 4, "c": 8},
+        )
 
     def test_flatten_context_with_context(self):
         """
         Context.push() with a Context argument should work.
         """
-        a = Context({'a': 2})
-        a.push(Context({'z': '8'}))
-        self.assertEqual(a.flatten(), {
-            'False': False,
-            'None': None,
-            'True': True,
-            'a': 2,
-            'z': '8',
-        })
+        a = Context({"a": 2})
+        a.push(Context({"z": "8"}))
+        self.assertEqual(
+            a.flatten(),
+            {
+                "False": False,
+                "None": None,
+                "True": True,
+                "a": 2,
+                "z": "8",
+            },
+        )
 
     def test_context_comparable(self):
         """
         #21765 -- equality comparison should work
         """
 
-        test_data = {'x': 'y', 'v': 'z', 'd': {'o': object, 'a': 'b'}}
+        test_data = {"x": "y", "v": "z", "d": {"o": object, "a": "b"}}
 
         self.assertEqual(Context(test_data), Context(test_data))
 
@@ -165,16 +172,16 @@ class ContextTests(SimpleTestCase):
         self.assertEqual(a, b)
 
         # update only a
-        a.update({'a': 1})
+        a.update({"a": 1})
         self.assertNotEqual(a, b)
 
         # update both to check regression
-        a.update({'c': 3})
-        b.update({'c': 3})
+        a.update({"c": 3})
+        b.update({"c": 3})
         self.assertNotEqual(a, b)
 
         # make contexts equals again
-        b.update({'a': 1})
+        b.update({"a": 1})
         self.assertEqual(a, b)
 
     def test_copy_request_context_twice(self):
@@ -184,35 +191,35 @@ class ContextTests(SimpleTestCase):
         RequestContext(HttpRequest()).new().new()
 
     def test_set_upward(self):
-        c = Context({'a': 1})
-        c.set_upward('a', 2)
-        self.assertEqual(c.get('a'), 2)
+        c = Context({"a": 1})
+        c.set_upward("a", 2)
+        self.assertEqual(c.get("a"), 2)
 
     def test_set_upward_empty_context(self):
         empty_context = Context()
-        empty_context.set_upward('a', 1)
-        self.assertEqual(empty_context.get('a'), 1)
+        empty_context.set_upward("a", 1)
+        self.assertEqual(empty_context.get("a"), 1)
 
     def test_set_upward_with_push(self):
         """
         The highest context which has the given key is used.
         """
-        c = Context({'a': 1})
-        c.push({'a': 2})
-        c.set_upward('a', 3)
-        self.assertEqual(c.get('a'), 3)
+        c = Context({"a": 1})
+        c.push({"a": 2})
+        c.set_upward("a", 3)
+        self.assertEqual(c.get("a"), 3)
         c.pop()
-        self.assertEqual(c.get('a'), 1)
+        self.assertEqual(c.get("a"), 1)
 
     def test_set_upward_with_push_no_match(self):
         """
         The highest context is used if the given key isn't found.
         """
-        c = Context({'b': 1})
-        c.push({'b': 2})
-        c.set_upward('a', 2)
+        c = Context({"b": 1})
+        c.push({"b": 2})
+        c.set_upward("a", 2)
         self.assertEqual(len(c.dicts), 3)
-        self.assertEqual(c.dicts[-1]['a'], 2)
+        self.assertEqual(c.dicts[-1]["a"], 2)
 
 
 class RequestContextTests(SimpleTestCase):
@@ -223,19 +230,28 @@ class RequestContextTests(SimpleTestCase):
         #15721 -- ``{% include %}`` and ``RequestContext`` should work
         together.
         """
-        engine = Engine(loaders=[
-            ('django.template.loaders.locmem.Loader', {
-                'child': '{{ var|default:"none" }}',
-            }),
-        ])
-        request = self.request_factory.get('/')
-        ctx = RequestContext(request, {'var': 'parent'})
-        self.assertEqual(engine.from_string('{% include "child" %}').render(ctx), 'parent')
-        self.assertEqual(engine.from_string('{% include "child" only %}').render(ctx), 'none')
+        engine = Engine(
+            loaders=[
+                (
+                    "django.template.loaders.locmem.Loader",
+                    {
+                        "child": '{{ var|default:"none" }}',
+                    },
+                ),
+            ]
+        )
+        request = self.request_factory.get("/")
+        ctx = RequestContext(request, {"var": "parent"})
+        self.assertEqual(
+            engine.from_string('{% include "child" %}').render(ctx), "parent"
+        )
+        self.assertEqual(
+            engine.from_string('{% include "child" only %}').render(ctx), "none"
+        )
 
     def test_stack_size(self):
         """Optimized RequestContext construction (#7116)."""
-        request = self.request_factory.get('/')
+        request = self.request_factory.get("/")
         ctx = RequestContext(request, {})
         # The stack contains 4 items:
         # [builtins, supplied context, context processor, empty dict]
@@ -243,11 +259,11 @@ class RequestContextTests(SimpleTestCase):
 
     def test_context_comparable(self):
         # Create an engine without any context processors.
-        test_data = {'x': 'y', 'v': 'z', 'd': {'o': object, 'a': 'b'}}
+        test_data = {"x": "y", "v": "z", "d": {"o": object, "a": "b"}}
 
         # test comparing RequestContext to prevent problems if somebody
         # adds __eq__ in the future
-        request = self.request_factory.get('/')
+        request = self.request_factory.get("/")
 
         self.assertEqual(
             RequestContext(request, dict_=test_data),
@@ -255,8 +271,8 @@ class RequestContextTests(SimpleTestCase):
         )
 
     def test_modify_context_and_render(self):
-        template = Template('{{ foo }}')
-        request = self.request_factory.get('/')
+        template = Template("{{ foo }}")
+        request = self.request_factory.get("/")
         context = RequestContext(request, {})
-        context['foo'] = 'foo'
-        self.assertEqual(template.render(context), 'foo')
+        context["foo"] = "foo"
+        self.assertEqual(template.render(context), "foo")