Refs #33476 -- Reformatted code with Black.

1 files changed, 143 insertions, 104 deletions

diff --git a/tests/template_tests/syntax_tests/test_cycle.py b/tests/template_tests/syntax_tests/test_cycle.py
index 12bf66e117..d4233fac3e 100644
--- a/tests/template_tests/syntax_tests/test_cycle.py
+++ b/tests/template_tests/syntax_tests/test_cycle.py
@@ -5,175 +5,214 @@ from ..utils import setup
 
 
 class CycleTagTests(SimpleTestCase):
-
-    @setup({'cycle01': '{% cycle a %}'})
+    @setup({"cycle01": "{% cycle a %}"})
     def test_cycle01(self):
         msg = "No named cycles in template. 'a' is not defined"
         with self.assertRaisesMessage(TemplateSyntaxError, msg):
-            self.engine.get_template('cycle01')
+            self.engine.get_template("cycle01")
 
-    @setup({'cycle05': '{% cycle %}'})
+    @setup({"cycle05": "{% cycle %}"})
     def test_cycle05(self):
         msg = "'cycle' tag requires at least two arguments"
         with self.assertRaisesMessage(TemplateSyntaxError, msg):
-            self.engine.get_template('cycle05')
+            self.engine.get_template("cycle05")
 
-    @setup({'cycle07': '{% cycle a,b,c as foo %}{% cycle bar %}'})
+    @setup({"cycle07": "{% cycle a,b,c as foo %}{% cycle bar %}"})
     def test_cycle07(self):
         msg = "Could not parse the remainder: ',b,c' from 'a,b,c'"
         with self.assertRaisesMessage(TemplateSyntaxError, msg):
-            self.engine.get_template('cycle07')
+            self.engine.get_template("cycle07")
 
-    @setup({'cycle10': "{% cycle 'a' 'b' 'c' as abc %}{% cycle abc %}"})
+    @setup({"cycle10": "{% cycle 'a' 'b' 'c' as abc %}{% cycle abc %}"})
     def test_cycle10(self):
-        output = self.engine.render_to_string('cycle10')
-        self.assertEqual(output, 'ab')
+        output = self.engine.render_to_string("cycle10")
+        self.assertEqual(output, "ab")
 
-    @setup({'cycle11': "{% cycle 'a' 'b' 'c' as abc %}{% cycle abc %}{% cycle abc %}"})
+    @setup({"cycle11": "{% cycle 'a' 'b' 'c' as abc %}{% cycle abc %}{% cycle abc %}"})
     def test_cycle11(self):
-        output = self.engine.render_to_string('cycle11')
-        self.assertEqual(output, 'abc')
+        output = self.engine.render_to_string("cycle11")
+        self.assertEqual(output, "abc")
 
-    @setup({'cycle12': "{% cycle 'a' 'b' 'c' as abc %}{% cycle abc %}{% cycle abc %}{% cycle abc %}"})
+    @setup(
+        {
+            "cycle12": "{% cycle 'a' 'b' 'c' as abc %}{% cycle abc %}{% cycle abc %}{% cycle abc %}"
+        }
+    )
     def test_cycle12(self):
-        output = self.engine.render_to_string('cycle12')
-        self.assertEqual(output, 'abca')
+        output = self.engine.render_to_string("cycle12")
+        self.assertEqual(output, "abca")
 
-    @setup({'cycle13': "{% for i in test %}{% cycle 'a' 'b' %}{{ i }},{% endfor %}"})
+    @setup({"cycle13": "{% for i in test %}{% cycle 'a' 'b' %}{{ i }},{% endfor %}"})
     def test_cycle13(self):
-        output = self.engine.render_to_string('cycle13', {'test': list(range(5))})
-        self.assertEqual(output, 'a0,b1,a2,b3,a4,')
+        output = self.engine.render_to_string("cycle13", {"test": list(range(5))})
+        self.assertEqual(output, "a0,b1,a2,b3,a4,")
 
-    @setup({'cycle14': '{% cycle one two as foo %}{% cycle foo %}'})
+    @setup({"cycle14": "{% cycle one two as foo %}{% cycle foo %}"})
     def test_cycle14(self):
-        output = self.engine.render_to_string('cycle14', {'one': '1', 'two': '2'})
-        self.assertEqual(output, '12')
+        output = self.engine.render_to_string("cycle14", {"one": "1", "two": "2"})
+        self.assertEqual(output, "12")
 
-    @setup({'cycle15': '{% for i in test %}{% cycle aye bee %}{{ i }},{% endfor %}'})
+    @setup({"cycle15": "{% for i in test %}{% cycle aye bee %}{{ i }},{% endfor %}"})
     def test_cycle15(self):
-        output = self.engine.render_to_string('cycle15', {'test': list(range(5)), 'aye': 'a', 'bee': 'b'})
-        self.assertEqual(output, 'a0,b1,a2,b3,a4,')
+        output = self.engine.render_to_string(
+            "cycle15", {"test": list(range(5)), "aye": "a", "bee": "b"}
+        )
+        self.assertEqual(output, "a0,b1,a2,b3,a4,")
 
-    @setup({'cycle16': '{% cycle one|lower two as foo %}{% cycle foo %}'})
+    @setup({"cycle16": "{% cycle one|lower two as foo %}{% cycle foo %}"})
     def test_cycle16(self):
-        output = self.engine.render_to_string('cycle16', {'one': 'A', 'two': '2'})
-        self.assertEqual(output, 'a2')
+        output = self.engine.render_to_string("cycle16", {"one": "A", "two": "2"})
+        self.assertEqual(output, "a2")
 
-    @setup({'cycle17': "{% cycle 'a' 'b' 'c' as abc silent %}"
-                       "{% cycle abc %}{% cycle abc %}{% cycle abc %}{% cycle abc %}"})
+    @setup(
+        {
+            "cycle17": "{% cycle 'a' 'b' 'c' as abc silent %}"
+            "{% cycle abc %}{% cycle abc %}{% cycle abc %}{% cycle abc %}"
+        }
+    )
     def test_cycle17(self):
-        output = self.engine.render_to_string('cycle17')
-        self.assertEqual(output, '')
+        output = self.engine.render_to_string("cycle17")
+        self.assertEqual(output, "")
 
-    @setup({'cycle18': "{% cycle 'a' 'b' 'c' as foo invalid_flag %}"})
+    @setup({"cycle18": "{% cycle 'a' 'b' 'c' as foo invalid_flag %}"})
     def test_cycle18(self):
         msg = "Only 'silent' flag is allowed after cycle's name, not 'invalid_flag'."
         with self.assertRaisesMessage(TemplateSyntaxError, msg):
-            self.engine.get_template('cycle18')
+            self.engine.get_template("cycle18")
 
-    @setup({'cycle19': "{% cycle 'a' 'b' as silent %}{% cycle silent %}"})
+    @setup({"cycle19": "{% cycle 'a' 'b' as silent %}{% cycle silent %}"})
     def test_cycle19(self):
-        output = self.engine.render_to_string('cycle19')
-        self.assertEqual(output, 'ab')
+        output = self.engine.render_to_string("cycle19")
+        self.assertEqual(output, "ab")
 
-    @setup({'cycle20': '{% cycle one two as foo %} & {% cycle foo %}'})
+    @setup({"cycle20": "{% cycle one two as foo %} & {% cycle foo %}"})
     def test_cycle20(self):
-        output = self.engine.render_to_string('cycle20', {'two': 'C & D', 'one': 'A & B'})
-        self.assertEqual(output, 'A & B & C & D')
+        output = self.engine.render_to_string(
+            "cycle20", {"two": "C & D", "one": "A & B"}
+        )
+        self.assertEqual(output, "A & B & C & D")
 
-    @setup({'cycle21': '{% filter force_escape %}'
-                       '{% cycle one two as foo %} & {% cycle foo %}{% endfilter %}'})
+    @setup(
+        {
+            "cycle21": "{% filter force_escape %}"
+            "{% cycle one two as foo %} & {% cycle foo %}{% endfilter %}"
+        }
+    )
     def test_cycle21(self):
-        output = self.engine.render_to_string('cycle21', {'two': 'C & D', 'one': 'A & B'})
-        self.assertEqual(output, 'A & B & C & D')
+        output = self.engine.render_to_string(
+            "cycle21", {"two": "C & D", "one": "A & B"}
+        )
+        self.assertEqual(output, "A & B & C & D")
 
-    @setup({'cycle22': "{% for x in values %}{% cycle 'a' 'b' 'c' as abc silent %}{{ x }}{% endfor %}"})
+    @setup(
+        {
+            "cycle22": "{% for x in values %}{% cycle 'a' 'b' 'c' as abc silent %}{{ x }}{% endfor %}"
+        }
+    )
     def test_cycle22(self):
-        output = self.engine.render_to_string('cycle22', {'values': [1, 2, 3, 4]})
-        self.assertEqual(output, '1234')
+        output = self.engine.render_to_string("cycle22", {"values": [1, 2, 3, 4]})
+        self.assertEqual(output, "1234")
 
-    @setup({'cycle23': "{% for x in values %}"
-                       "{% cycle 'a' 'b' 'c' as abc silent %}{{ abc }}{{ x }}{% endfor %}"})
+    @setup(
+        {
+            "cycle23": "{% for x in values %}"
+            "{% cycle 'a' 'b' 'c' as abc silent %}{{ abc }}{{ x }}{% endfor %}"
+        }
+    )
     def test_cycle23(self):
-        output = self.engine.render_to_string('cycle23', {'values': [1, 2, 3, 4]})
-        self.assertEqual(output, 'a1b2c3a4')
+        output = self.engine.render_to_string("cycle23", {"values": [1, 2, 3, 4]})
+        self.assertEqual(output, "a1b2c3a4")
 
-    @setup({
-        'cycle24': "{% for x in values %}"
-                   "{% cycle 'a' 'b' 'c' as abc silent %}{% include 'included-cycle' %}{% endfor %}",
-        'included-cycle': '{{ abc }}',
-    })
+    @setup(
+        {
+            "cycle24": "{% for x in values %}"
+            "{% cycle 'a' 'b' 'c' as abc silent %}{% include 'included-cycle' %}{% endfor %}",
+            "included-cycle": "{{ abc }}",
+        }
+    )
     def test_cycle24(self):
-        output = self.engine.render_to_string('cycle24', {'values': [1, 2, 3, 4]})
-        self.assertEqual(output, 'abca')
+        output = self.engine.render_to_string("cycle24", {"values": [1, 2, 3, 4]})
+        self.assertEqual(output, "abca")
 
-    @setup({'cycle25': '{% cycle a as abc %}'})
+    @setup({"cycle25": "{% cycle a as abc %}"})
     def test_cycle25(self):
-        output = self.engine.render_to_string('cycle25', {'a': '<'})
-        self.assertEqual(output, '&lt;')
+        output = self.engine.render_to_string("cycle25", {"a": "<"})
+        self.assertEqual(output, "&lt;")
 
-    @setup({'cycle26': '{% cycle a b as ab %}{% cycle ab %}'})
+    @setup({"cycle26": "{% cycle a b as ab %}{% cycle ab %}"})
     def test_cycle26(self):
-        output = self.engine.render_to_string('cycle26', {'a': '<', 'b': '>'})
-        self.assertEqual(output, '&lt;&gt;')
+        output = self.engine.render_to_string("cycle26", {"a": "<", "b": ">"})
+        self.assertEqual(output, "&lt;&gt;")
 
-    @setup({'cycle27': '{% autoescape off %}{% cycle a b as ab %}{% cycle ab %}{% endautoescape %}'})
+    @setup(
+        {
+            "cycle27": "{% autoescape off %}{% cycle a b as ab %}{% cycle ab %}{% endautoescape %}"
+        }
+    )
     def test_cycle27(self):
-        output = self.engine.render_to_string('cycle27', {'a': '<', 'b': '>'})
-        self.assertEqual(output, '<>')
+        output = self.engine.render_to_string("cycle27", {"a": "<", "b": ">"})
+        self.assertEqual(output, "<>")
 
-    @setup({'cycle28': '{% cycle a|safe b as ab %}{% cycle ab %}'})
+    @setup({"cycle28": "{% cycle a|safe b as ab %}{% cycle ab %}"})
     def test_cycle28(self):
-        output = self.engine.render_to_string('cycle28', {'a': '<', 'b': '>'})
-        self.assertEqual(output, '<&gt;')
+        output = self.engine.render_to_string("cycle28", {"a": "<", "b": ">"})
+        self.assertEqual(output, "<&gt;")
 
-    @setup({
-        'cycle29': "{% cycle 'a' 'b' 'c' as cycler silent %}"
-                   "{% for x in values %}"
-                   "{% ifchanged x %}"
-                   "{% cycle cycler %}{{ cycler }}"
-                   "{% else %}"
-                   "{{ cycler }}"
-                   "{% endifchanged %}"
-                   "{% endfor %}"
-    })
+    @setup(
+        {
+            "cycle29": "{% cycle 'a' 'b' 'c' as cycler silent %}"
+            "{% for x in values %}"
+            "{% ifchanged x %}"
+            "{% cycle cycler %}{{ cycler }}"
+            "{% else %}"
+            "{{ cycler }}"
+            "{% endifchanged %}"
+            "{% endfor %}"
+        }
+    )
     def test_cycle29(self):
         """
         A named {% cycle %} tag works inside an {% ifchanged %} block and a
         {% for %} loop.
         """
-        output = self.engine.render_to_string('cycle29', {'values': [1, 2, 3, 4, 5, 6, 7, 8, 8, 8, 9, 9]})
-        self.assertEqual(output, 'bcabcabcccaa')
+        output = self.engine.render_to_string(
+            "cycle29", {"values": [1, 2, 3, 4, 5, 6, 7, 8, 8, 8, 9, 9]}
+        )
+        self.assertEqual(output, "bcabcabcccaa")
 
-    @setup({
-        'cycle30': "{% cycle 'a' 'b' 'c' as cycler silent %}"
-                   "{% for x in values %}"
-                   "{% with doesnothing=irrelevant %}"
-                   "{% ifchanged x %}"
-                   "{% cycle cycler %}{{ cycler }}"
-                   "{% else %}"
-                   "{{ cycler }}"
-                   "{% endifchanged %}"
-                   "{% endwith %}"
-                   "{% endfor %}"})
+    @setup(
+        {
+            "cycle30": "{% cycle 'a' 'b' 'c' as cycler silent %}"
+            "{% for x in values %}"
+            "{% with doesnothing=irrelevant %}"
+            "{% ifchanged x %}"
+            "{% cycle cycler %}{{ cycler }}"
+            "{% else %}"
+            "{{ cycler }}"
+            "{% endifchanged %}"
+            "{% endwith %}"
+            "{% endfor %}"
+        }
+    )
     def test_cycle30(self):
         """
         A {% with %} tag shouldn't reset the {% cycle %} variable.
         """
         output = self.engine.render_to_string(
-            'cycle30', {
-                'irrelevant': 1,
-                'values': [1, 2, 3, 4, 5, 6, 7, 8, 8, 8, 9, 9]
-            })
-        self.assertEqual(output, 'bcabcabcccaa')
+            "cycle30", {"irrelevant": 1, "values": [1, 2, 3, 4, 5, 6, 7, 8, 8, 8, 9, 9]}
+        )
+        self.assertEqual(output, "bcabcabcccaa")
 
-    @setup({
-        'undefined_cycle':
-            "{% cycle 'a' 'b' 'c' as cycler silent %}"
+    @setup(
+        {
+            "undefined_cycle": "{% cycle 'a' 'b' 'c' as cycler silent %}"
             "{% for x in values %}"
             "{% cycle undefined %}{{ cycler }}"
             "{% endfor %}"
-    })
+        }
+    )
     def test_cycle_undefined(self):
-        with self.assertRaisesMessage(TemplateSyntaxError, "Named cycle 'undefined' does not exist"):
-            self.engine.render_to_string('undefined_cycle')
+        with self.assertRaisesMessage(
+            TemplateSyntaxError, "Named cycle 'undefined' does not exist"
+        ):
+            self.engine.render_to_string("undefined_cycle")