Refs #33476 -- Reformatted code with Black.

tests/test_runner/test_shuffler.py

@@ -5,84 +5,83 @@ from django.test.runner import Shuffler
 
 
 class ShufflerTests(SimpleTestCase):
-
     def test_hash_text(self):
-        actual = Shuffler._hash_text('abcd')
-        self.assertEqual(actual, 'e2fc714c4727ee9395f324cd2e7f331f')
+        actual = Shuffler._hash_text("abcd")
+        self.assertEqual(actual, "e2fc714c4727ee9395f324cd2e7f331f")
 
     def test_hash_text_hash_algorithm(self):
         class MyShuffler(Shuffler):
-            hash_algorithm = 'sha1'
+            hash_algorithm = "sha1"
 
-        actual = MyShuffler._hash_text('abcd')
-        self.assertEqual(actual, '81fe8bfe87576c3ecb22426f8e57847382917acf')
+        actual = MyShuffler._hash_text("abcd")
+        self.assertEqual(actual, "81fe8bfe87576c3ecb22426f8e57847382917acf")
 
     def test_init(self):
         shuffler = Shuffler(100)
         self.assertEqual(shuffler.seed, 100)
-        self.assertEqual(shuffler.seed_source, 'given')
+        self.assertEqual(shuffler.seed_source, "given")
 
     def test_init_none_seed(self):
-        with mock.patch('random.randint', return_value=200):
+        with mock.patch("random.randint", return_value=200):
             shuffler = Shuffler(None)
         self.assertEqual(shuffler.seed, 200)
-        self.assertEqual(shuffler.seed_source, 'generated')
+        self.assertEqual(shuffler.seed_source, "generated")
 
     def test_init_no_seed_argument(self):
-        with mock.patch('random.randint', return_value=300):
+        with mock.patch("random.randint", return_value=300):
             shuffler = Shuffler()
         self.assertEqual(shuffler.seed, 300)
-        self.assertEqual(shuffler.seed_source, 'generated')
+        self.assertEqual(shuffler.seed_source, "generated")
 
     def test_seed_display(self):
         shuffler = Shuffler(100)
-        shuffler.seed_source = 'test'
-        self.assertEqual(shuffler.seed_display, '100 (test)')
+        shuffler.seed_source = "test"
+        self.assertEqual(shuffler.seed_display, "100 (test)")
 
     def test_hash_item_seed(self):
         cases = [
-            (1234, '64ad3fb166ddb41a2ca24f1803b8b722'),
+            (1234, "64ad3fb166ddb41a2ca24f1803b8b722"),
             # Passing a string gives the same value.
-            ('1234', '64ad3fb166ddb41a2ca24f1803b8b722'),
-            (5678, '4dde450ad339b6ce45a0a2666e35b975'),
+            ("1234", "64ad3fb166ddb41a2ca24f1803b8b722"),
+            (5678, "4dde450ad339b6ce45a0a2666e35b975"),
         ]
         for seed, expected in cases:
             with self.subTest(seed=seed):
                 shuffler = Shuffler(seed=seed)
-                actual = shuffler._hash_item('abc', lambda x: x)
+                actual = shuffler._hash_item("abc", lambda x: x)
                 self.assertEqual(actual, expected)
 
     def test_hash_item_key(self):
         cases = [
-            (lambda x: x, '64ad3fb166ddb41a2ca24f1803b8b722'),
-            (lambda x: x.upper(), 'ee22e8597bff91742affe4befbf4649a'),
+            (lambda x: x, "64ad3fb166ddb41a2ca24f1803b8b722"),
+            (lambda x: x.upper(), "ee22e8597bff91742affe4befbf4649a"),
         ]
         for key, expected in cases:
             with self.subTest(key=key):
                 shuffler = Shuffler(seed=1234)
-                actual = shuffler._hash_item('abc', key)
+                actual = shuffler._hash_item("abc", key)
                 self.assertEqual(actual, expected)
 
     def test_shuffle_key(self):
         cases = [
-            (lambda x: x, ['a', 'd', 'b', 'c']),
-            (lambda x: x.upper(), ['d', 'c', 'a', 'b']),
+            (lambda x: x, ["a", "d", "b", "c"]),
+            (lambda x: x.upper(), ["d", "c", "a", "b"]),
         ]
         for num, (key, expected) in enumerate(cases, start=1):
             with self.subTest(num=num):
                 shuffler = Shuffler(seed=1234)
-                actual = shuffler.shuffle(['a', 'b', 'c', 'd'], key)
+                actual = shuffler.shuffle(["a", "b", "c", "d"], key)
                 self.assertEqual(actual, expected)
 
     def test_shuffle_consistency(self):
         seq = [str(n) for n in range(5)]
         cases = [
-            (None, ['3', '0', '2', '4', '1']),
-            (0, ['3', '2', '4', '1']),
-            (1, ['3', '0', '2', '4']),
-            (2, ['3', '0', '4', '1']),
-            (3, ['0', '2', '4', '1']),
-            (4, ['3', '0', '2', '1']),
+            (None, ["3", "0", "2", "4", "1"]),
+            (0, ["3", "2", "4", "1"]),
+            (1, ["3", "0", "2", "4"]),
+            (2, ["3", "0", "4", "1"]),
+            (3, ["0", "2", "4", "1"]),
+            (4, ["3", "0", "2", "1"]),
         ]
         shuffler = Shuffler(seed=1234)
         for index, expected in cases:
@@ -99,4 +98,4 @@ class ShufflerTests(SimpleTestCase):
         shuffler = Shuffler(seed=1234)
         msg = "item 'A' has same hash 'a56ce89262959e151ee2266552f1819c' as item 'a'"
         with self.assertRaisesMessage(RuntimeError, msg):
-            shuffler.shuffle(['a', 'b', 'A'], lambda x: x.upper())
+            shuffler.shuffle(["a", "b", "A"], lambda x: x.upper())