[4.0.x] Refs #33476 -- Reformatted code with Black.

Backport of 9c19aff7c7561e3a82978a272ecdaad40dda5c00 from main.

24 files changed, 1401 insertions, 669 deletions

diff --git a/tests/forms_tests/widget_tests/base.py b/tests/forms_tests/widget_tests/base.py
index 339d78bc71..c29099abf2 100644
--- a/tests/forms_tests/widget_tests/base.py
+++ b/tests/forms_tests/widget_tests/base.py
@@ -8,24 +8,32 @@ except ImportError:
 
 
 class WidgetTest(SimpleTestCase):
-    beatles = (('J', 'John'), ('P', 'Paul'), ('G', 'George'), ('R', 'Ringo'))
+    beatles = (("J", "John"), ("P", "Paul"), ("G", "George"), ("R", "Ringo"))
 
     @classmethod
     def setUpClass(cls):
         cls.django_renderer = DjangoTemplates()
         cls.jinja2_renderer = Jinja2() if jinja2 else None
-        cls.renderers = [cls.django_renderer] + ([cls.jinja2_renderer] if cls.jinja2_renderer else [])
+        cls.renderers = [cls.django_renderer] + (
+            [cls.jinja2_renderer] if cls.jinja2_renderer else []
+        )
         super().setUpClass()
 
-    def check_html(self, widget, name, value, html='', attrs=None, strict=False, **kwargs):
+    def check_html(
+        self, widget, name, value, html="", attrs=None, strict=False, **kwargs
+    ):
         assertEqual = self.assertEqual if strict else self.assertHTMLEqual
         if self.jinja2_renderer:
-            output = widget.render(name, value, attrs=attrs, renderer=self.jinja2_renderer, **kwargs)
+            output = widget.render(
+                name, value, attrs=attrs, renderer=self.jinja2_renderer, **kwargs
+            )
             # Django escapes quotes with '"' while Jinja2 uses '"'.
-            output = output.replace('"', '"')
+            output = output.replace(""", """)
             # Django escapes single quotes with ''' while Jinja2 uses '''.
-            output = output.replace(''', ''')
+            output = output.replace("'", "'")
             assertEqual(output, html)
 
-        output = widget.render(name, value, attrs=attrs, renderer=self.django_renderer, **kwargs)
+        output = widget.render(
+            name, value, attrs=attrs, renderer=self.django_renderer, **kwargs
+        )
         assertEqual(output, html)
diff --git a/tests/forms_tests/widget_tests/test_checkboxinput.py b/tests/forms_tests/widget_tests/test_checkboxinput.py
index 8dba2178c9..0f65e876df 100644
--- a/tests/forms_tests/widget_tests/test_checkboxinput.py
+++ b/tests/forms_tests/widget_tests/test_checkboxinput.py
@@ -7,18 +7,26 @@ class CheckboxInputTest(WidgetTest):
     widget = CheckboxInput()
 
     def test_render_empty(self):
-        self.check_html(self.widget, 'is_cool', '', html='<input type="checkbox" name="is_cool">')
+        self.check_html(
+            self.widget, "is_cool", "", html='<input type="checkbox" name="is_cool">'
+        )
 
     def test_render_none(self):
-        self.check_html(self.widget, 'is_cool', None, html='<input type="checkbox" name="is_cool">')
+        self.check_html(
+            self.widget, "is_cool", None, html='<input type="checkbox" name="is_cool">'
+        )
 
     def test_render_false(self):
-        self.check_html(self.widget, 'is_cool', False, html='<input type="checkbox" name="is_cool">')
+        self.check_html(
+            self.widget, "is_cool", False, html='<input type="checkbox" name="is_cool">'
+        )
 
     def test_render_true(self):
         self.check_html(
-            self.widget, 'is_cool', True,
-            html='<input checked type="checkbox" name="is_cool">'
+            self.widget,
+            "is_cool",
+            True,
+            html='<input checked type="checkbox" name="is_cool">',
         )
 
     def test_render_value(self):
@@ -27,7 +35,9 @@ class CheckboxInputTest(WidgetTest):
         checkbox and set the 'value' attribute.
         """
         self.check_html(
-            self.widget, 'is_cool', 'foo',
+            self.widget,
+            "is_cool",
+            "foo",
             html='<input checked type="checkbox" name="is_cool" value="foo">',
         )
 
@@ -36,11 +46,15 @@ class CheckboxInputTest(WidgetTest):
         Integers are handled by value, not as booleans (#17114).
         """
         self.check_html(
-            self.widget, 'is_cool', 0,
+            self.widget,
+            "is_cool",
+            0,
             html='<input checked type="checkbox" name="is_cool" value="0">',
         )
         self.check_html(
-            self.widget, 'is_cool', 1,
+            self.widget,
+            "is_cool",
+            1,
             html='<input checked type="checkbox" name="is_cool" value="1">',
         )
 
@@ -49,30 +63,43 @@ class CheckboxInputTest(WidgetTest):
         You can pass 'check_test' to the constructor. This is a callable that
         takes the value and returns True if the box should be checked.
         """
-        widget = CheckboxInput(check_test=lambda value: value.startswith('hello'))
-        self.check_html(widget, 'greeting', '', html=(
-            '<input type="checkbox" name="greeting">'
-        ))
-        self.check_html(widget, 'greeting', 'hello', html=(
-            '<input checked type="checkbox" name="greeting" value="hello">'
-        ))
-        self.check_html(widget, 'greeting', 'hello there', html=(
-            '<input checked type="checkbox" name="greeting" value="hello there">'
-        ))
-        self.check_html(widget, 'greeting', 'hello & goodbye', html=(
-            '<input checked type="checkbox" name="greeting" value="hello &amp; goodbye">'
-        ))
+        widget = CheckboxInput(check_test=lambda value: value.startswith("hello"))
+        self.check_html(
+            widget, "greeting", "", html=('<input type="checkbox" name="greeting">')
+        )
+        self.check_html(
+            widget,
+            "greeting",
+            "hello",
+            html=('<input checked type="checkbox" name="greeting" value="hello">'),
+        )
+        self.check_html(
+            widget,
+            "greeting",
+            "hello there",
+            html=(
+                '<input checked type="checkbox" name="greeting" value="hello there">'
+            ),
+        )
+        self.check_html(
+            widget,
+            "greeting",
+            "hello & goodbye",
+            html=(
+                '<input checked type="checkbox" name="greeting" value="hello &amp; goodbye">'
+            ),
+        )
 
     def test_render_check_exception(self):
         """
         Calling check_test() shouldn't swallow exceptions (#17888).
         """
         widget = CheckboxInput(
-            check_test=lambda value: value.startswith('hello'),
+            check_test=lambda value: value.startswith("hello"),
         )
 
         with self.assertRaises(AttributeError):
-            widget.render('greeting', True)
+            widget.render("greeting", True)
 
     def test_value_from_datadict(self):
         """
@@ -80,17 +107,19 @@ class CheckboxInputTest(WidgetTest):
         the data dictionary (because HTML form submission doesn't send any
         result for unchecked checkboxes).
         """
-        self.assertFalse(self.widget.value_from_datadict({}, {}, 'testing'))
+        self.assertFalse(self.widget.value_from_datadict({}, {}, "testing"))
 
     def test_value_from_datadict_string_int(self):
-        value = self.widget.value_from_datadict({'testing': '0'}, {}, 'testing')
+        value = self.widget.value_from_datadict({"testing": "0"}, {}, "testing")
         self.assertIs(value, True)
 
     def test_value_omitted_from_data(self):
-        self.assertIs(self.widget.value_omitted_from_data({'field': 'value'}, {}, 'field'), False)
-        self.assertIs(self.widget.value_omitted_from_data({}, {}, 'field'), False)
+        self.assertIs(
+            self.widget.value_omitted_from_data({"field": "value"}, {}, "field"), False
+        )
+        self.assertIs(self.widget.value_omitted_from_data({}, {}, "field"), False)
 
     def test_get_context_does_not_mutate_attrs(self):
-        attrs = {'checked': False}
-        self.widget.get_context('name', True, attrs)
-        self.assertIs(attrs['checked'], False)
+        attrs = {"checked": False}
+        self.widget.get_context("name", True, attrs)
+        self.assertIs(attrs["checked"], False)
diff --git a/tests/forms_tests/widget_tests/test_checkboxselectmultiple.py b/tests/forms_tests/widget_tests/test_checkboxselectmultiple.py
index e831038e02..0e720022b2 100644
--- a/tests/forms_tests/widget_tests/test_checkboxselectmultiple.py
+++ b/tests/forms_tests/widget_tests/test_checkboxselectmultiple.py
@@ -11,31 +11,45 @@ class CheckboxSelectMultipleTest(WidgetTest):
     widget = CheckboxSelectMultiple
 
     def test_render_value(self):
-        self.check_html(self.widget(choices=self.beatles), 'beatles', ['J'], html="""
+        self.check_html(
+            self.widget(choices=self.beatles),
+            "beatles",
+            ["J"],
+            html="""
             <div>
             <div><label><input checked type="checkbox" name="beatles" value="J"> John</label></div>
             <div><label><input type="checkbox" name="beatles" value="P"> Paul</label></div>
             <div><label><input type="checkbox" name="beatles" value="G"> George</label></div>
             <div><label><input type="checkbox" name="beatles" value="R"> Ringo</label></div>
             </div>
-        """)
+        """,
+        )
 
     def test_render_value_multiple(self):
-        self.check_html(self.widget(choices=self.beatles), 'beatles', ['J', 'P'], html="""
+        self.check_html(
+            self.widget(choices=self.beatles),
+            "beatles",
+            ["J", "P"],
+            html="""
             <div>
             <div><label><input checked type="checkbox" name="beatles" value="J"> John</label></div>
             <div><label><input checked type="checkbox" name="beatles" value="P"> Paul</label></div>
             <div><label><input type="checkbox" name="beatles" value="G"> George</label></div>
             <div><label><input type="checkbox" name="beatles" value="R"> Ringo</label></div>
             </div>
-        """)
+        """,
+        )
 
     def test_render_none(self):
         """
         If the value is None, none of the options are selected, even if the
         choices have an empty option.
         """
-        self.check_html(self.widget(choices=(('', 'Unknown'),) + self.beatles), 'beatles', None, html="""
+        self.check_html(
+            self.widget(choices=(("", "Unknown"),) + self.beatles),
+            "beatles",
+            None,
+            html="""
             <div>
             <div><label><input type="checkbox" name="beatles" value=""> Unknown</label></div>
             <div><label><input type="checkbox" name="beatles" value="J"> John</label></div>
@@ -43,13 +57,14 @@ class CheckboxSelectMultipleTest(WidgetTest):
             <div><label><input type="checkbox" name="beatles" value="G"> George</label></div>
             <div><label><input type="checkbox" name="beatles" value="R"> Ringo</label></div>
             </div>
-        """)
+        """,
+        )
 
     def test_nested_choices(self):
         nested_choices = (
-            ('unknown', 'Unknown'),
-            ('Audio', (('vinyl', 'Vinyl'), ('cd', 'CD'))),
-            ('Video', (('vhs', 'VHS'), ('dvd', 'DVD'))),
+            ("unknown", "Unknown"),
+            ("Audio", (("vinyl", "Vinyl"), ("cd", "CD"))),
+            ("Video", (("vhs", "VHS"), ("dvd", "DVD"))),
         )
         html = """
         <div id="media">
@@ -71,15 +86,18 @@ class CheckboxSelectMultipleTest(WidgetTest):
         </div>
         """
         self.check_html(
-            self.widget(choices=nested_choices), 'nestchoice', ('vinyl', 'dvd'),
-            attrs={'id': 'media'}, html=html,
+            self.widget(choices=nested_choices),
+            "nestchoice",
+            ("vinyl", "dvd"),
+            attrs={"id": "media"},
+            html=html,
         )
 
     def test_nested_choices_without_id(self):
         nested_choices = (
-            ('unknown', 'Unknown'),
-            ('Audio', (('vinyl', 'Vinyl'), ('cd', 'CD'))),
-            ('Video', (('vhs', 'VHS'), ('dvd', 'DVD'))),
+            ("unknown", "Unknown"),
+            ("Audio", (("vinyl", "Vinyl"), ("cd", "CD"))),
+            ("Video", (("vhs", "VHS"), ("dvd", "DVD"))),
         )
         html = """
         <div>
@@ -95,13 +113,18 @@ class CheckboxSelectMultipleTest(WidgetTest):
         </div>
         </div>
         """
-        self.check_html(self.widget(choices=nested_choices), 'nestchoice', ('vinyl', 'dvd'), html=html)
+        self.check_html(
+            self.widget(choices=nested_choices),
+            "nestchoice",
+            ("vinyl", "dvd"),
+            html=html,
+        )
 
     def test_separate_ids(self):
         """
         Each input gets a separate ID.
         """
-        choices = [('a', 'A'), ('b', 'B'), ('c', 'C')]
+        choices = [("a", "A"), ("b", "B"), ("c", "C")]
         html = """
         <div id="abc">
         <div>
@@ -113,13 +136,21 @@ class CheckboxSelectMultipleTest(WidgetTest):
         </div>
         </div>
         """
-        self.check_html(self.widget(choices=choices), 'letters', ['a', 'c'], attrs={'id': 'abc'}, html=html)
+        self.check_html(
+            self.widget(choices=choices),
+            "letters",
+            ["a", "c"],
+            attrs={"id": "abc"},
+            html=html,
+        )
 
     def test_separate_ids_constructor(self):
         """
         Each input gets a separate ID when the ID is passed to the constructor.
         """
-        widget = CheckboxSelectMultiple(attrs={'id': 'abc'}, choices=[('a', 'A'), ('b', 'B'), ('c', 'C')])
+        widget = CheckboxSelectMultiple(
+            attrs={"id": "abc"}, choices=[("a", "A"), ("b", "B"), ("c", "C")]
+        )
         html = """
         <div id="abc">
         <div>
@@ -131,14 +162,14 @@ class CheckboxSelectMultipleTest(WidgetTest):
         </div>
         </div>
         """
-        self.check_html(widget, 'letters', ['a', 'c'], html=html)
+        self.check_html(widget, "letters", ["a", "c"], html=html)
 
     @override_settings(USE_THOUSAND_SEPARATOR=True)
     def test_doesnt_localize_input_value(self):
         choices = [
-            (1, 'One'),
-            (1000, 'One thousand'),
-            (1000000, 'One million'),
+            (1, "One"),
+            (1000, "One thousand"),
+            (1000000, "One million"),
         ]
         html = """
         <div>
@@ -147,11 +178,11 @@ class CheckboxSelectMultipleTest(WidgetTest):
         <div><label><input type="checkbox" name="numbers" value="1000000"> One million</label></div>
         </div>
         """
-        self.check_html(self.widget(choices=choices), 'numbers', None, html=html)
+        self.check_html(self.widget(choices=choices), "numbers", None, html=html)
 
         choices = [
-            (datetime.time(0, 0), 'midnight'),
-            (datetime.time(12, 0), 'noon'),
+            (datetime.time(0, 0), "midnight"),
+            (datetime.time(12, 0), "noon"),
         ]
         html = """
         <div>
@@ -159,7 +190,7 @@ class CheckboxSelectMultipleTest(WidgetTest):
         <div><label><input type="checkbox" name="times" value="12:00:00"> noon</label></div>
         </div>
         """
-        self.check_html(self.widget(choices=choices), 'times', None, html=html)
+        self.check_html(self.widget(choices=choices), "times", None, html=html)
 
     def test_use_required_attribute(self):
         widget = self.widget(choices=self.beatles)
@@ -167,21 +198,24 @@ class CheckboxSelectMultipleTest(WidgetTest):
         # to be checked instead of at least one.
         self.assertIs(widget.use_required_attribute(None), False)
         self.assertIs(widget.use_required_attribute([]), False)
-        self.assertIs(widget.use_required_attribute(['J', 'P']), False)
+        self.assertIs(widget.use_required_attribute(["J", "P"]), False)
 
     def test_value_omitted_from_data(self):
         widget = self.widget(choices=self.beatles)
-        self.assertIs(widget.value_omitted_from_data({}, {}, 'field'), False)
-        self.assertIs(widget.value_omitted_from_data({'field': 'value'}, {}, 'field'), False)
+        self.assertIs(widget.value_omitted_from_data({}, {}, "field"), False)
+        self.assertIs(
+            widget.value_omitted_from_data({"field": "value"}, {}, "field"), False
+        )
 
     def test_label(self):
         """
         CheckboxSelectMultiple doesn't contain 'for="field_0"' in the <label>
         because clicking that would toggle the first checkbox.
         """
+
         class TestForm(forms.Form):
             f = forms.MultipleChoiceField(widget=CheckboxSelectMultiple)
 
-        bound_field = TestForm()['f']
-        self.assertEqual(bound_field.field.widget.id_for_label('id'), '')
-        self.assertEqual(bound_field.label_tag(), '<label>F:</label>')
+        bound_field = TestForm()["f"]
+        self.assertEqual(bound_field.field.widget.id_for_label("id"), "")
+        self.assertEqual(bound_field.label_tag(), "<label>F:</label>")
diff --git a/tests/forms_tests/widget_tests/test_clearablefileinput.py b/tests/forms_tests/widget_tests/test_clearablefileinput.py
index dee44c4239..03fe34306b 100644
--- a/tests/forms_tests/widget_tests/test_clearablefileinput.py
+++ b/tests/forms_tests/widget_tests/test_clearablefileinput.py
@@ -9,7 +9,8 @@ class FakeFieldFile:
     Quacks like a FieldFile (has a .url and string representation), but
     doesn't require us to care about storages etc.
     """
-    url = 'something'
+
+    url = "something"
 
     def __str__(self):
         return self.url
@@ -23,35 +24,46 @@ class ClearableFileInputTest(WidgetTest):
         A ClearableFileInput with is_required False and rendered with an
         initial value that is a file renders a clear checkbox.
         """
-        self.check_html(self.widget, 'myfile', FakeFieldFile(), html=(
-            """
+        self.check_html(
+            self.widget,
+            "myfile",
+            FakeFieldFile(),
+            html=(
+                """
             Currently: <a href="something">something</a>
             <input type="checkbox" name="myfile-clear" id="myfile-clear_id">
             <label for="myfile-clear_id">Clear</label><br>
             Change: <input type="file" name="myfile">
             """
-        ))
+            ),
+        )
 
     def test_html_escaped(self):
         """
         A ClearableFileInput should escape name, filename, and URL
         when rendering HTML (#15182).
         """
+
         class StrangeFieldFile:
             url = "something?chapter=1&sect=2&copy=3&lang=en"
 
             def __str__(self):
-                return '''something<div onclick="alert('oops')">.jpg'''
+                return """something<div onclick="alert('oops')">.jpg"""
 
-        self.check_html(ClearableFileInput(), 'my<div>file', StrangeFieldFile(), html=(
-            """
+        self.check_html(
+            ClearableFileInput(),
+            "my<div>file",
+            StrangeFieldFile(),
+            html=(
+                """
             Currently: <a href="something?chapter=1&amp;sect=2&amp;copy=3&amp;lang=en">
             something&lt;div onclick=&quot;alert(&#x27;oops&#x27;)&quot;&gt;.jpg</a>
             <input type="checkbox" name="my&lt;div&gt;file-clear" id="my&lt;div&gt;file-clear_id">
             <label for="my&lt;div&gt;file-clear_id">Clear</label><br>
             Change: <input type="file" name="my&lt;div&gt;file">
             """
-        ))
+            ),
+        )
 
     def test_clear_input_renders_only_if_not_required(self):
         """
@@ -60,26 +72,33 @@ class ClearableFileInputTest(WidgetTest):
         """
         widget = ClearableFileInput()
         widget.is_required = True
-        self.check_html(widget, 'myfile', FakeFieldFile(), html=(
-            """
+        self.check_html(
+            widget,
+            "myfile",
+            FakeFieldFile(),
+            html=(
+                """
             Currently: <a href="something">something</a> <br>
             Change: <input type="file" name="myfile">
             """
-        ))
+            ),
+        )
 
     def test_clear_input_renders_only_if_initial(self):
         """
         A ClearableFileInput instantiated with no initial value does not render
         a clear checkbox.
         """
-        self.check_html(self.widget, 'myfile', None, html='<input type="file" name="myfile">')
+        self.check_html(
+            self.widget, "myfile", None, html='<input type="file" name="myfile">'
+        )
 
     def test_render_disabled(self):
         self.check_html(
             self.widget,
-            'myfile',
+            "myfile",
             FakeFieldFile(),
-            attrs={'disabled': True},
+            attrs={"disabled": True},
             html=(
                 'Currently: <a href="something">something</a>'
                 '<input type="checkbox" name="myfile-clear" '
@@ -92,14 +111,19 @@ class ClearableFileInputTest(WidgetTest):
     def test_render_as_subwidget(self):
         """A ClearableFileInput as a subwidget of MultiWidget."""
         widget = MultiWidget(widgets=(self.widget,))
-        self.check_html(widget, 'myfile', [FakeFieldFile()], html=(
-            """
+        self.check_html(
+            widget,
+            "myfile",
+            [FakeFieldFile()],
+            html=(
+                """
             Currently: <a href="something">something</a>
             <input type="checkbox" name="myfile_0-clear" id="myfile_0-clear_id">
             <label for="myfile_0-clear_id">Clear</label><br>
             Change: <input type="file" name="myfile_0">
             """
-        ))
+            ),
+        )
 
     def test_clear_input_checked_returns_false(self):
         """
@@ -107,9 +131,9 @@ class ClearableFileInputTest(WidgetTest):
         checkbox is checked, if not required.
         """
         value = self.widget.value_from_datadict(
-            data={'myfile-clear': True},
+            data={"myfile-clear": True},
             files={},
-            name='myfile',
+            name="myfile",
         )
         self.assertIs(value, False)
 
@@ -120,12 +144,12 @@ class ClearableFileInputTest(WidgetTest):
         """
         widget = ClearableFileInput()
         widget.is_required = True
-        field = SimpleUploadedFile('something.txt', b'content')
+        field = SimpleUploadedFile("something.txt", b"content")
 
         value = widget.value_from_datadict(
-            data={'myfile-clear': True},
-            files={'myfile': field},
-            name='myfile',
+            data={"myfile-clear": True},
+            files={"myfile": field},
+            name="myfile",
         )
         self.assertEqual(value, field)
 
@@ -134,45 +158,50 @@ class ClearableFileInputTest(WidgetTest):
         A ClearableFileInput should not mask exceptions produced while
         checking that it has a value.
         """
+
         class FailingURLFieldFile:
             @property
             def url(self):
-                raise ValueError('Canary')
+                raise ValueError("Canary")
 
             def __str__(self):
-                return 'value'
+                return "value"
 
-        with self.assertRaisesMessage(ValueError, 'Canary'):
-            self.widget.render('myfile', FailingURLFieldFile())
+        with self.assertRaisesMessage(ValueError, "Canary"):
+            self.widget.render("myfile", FailingURLFieldFile())
 
     def test_url_as_property(self):
         class URLFieldFile:
             @property
             def url(self):
-                return 'https://www.python.org/'
+                return "https://www.python.org/"
 
             def __str__(self):
-                return 'value'
+                return "value"
 
-        html = self.widget.render('myfile', URLFieldFile())
+        html = self.widget.render("myfile", URLFieldFile())
         self.assertInHTML('<a href="https://www.python.org/">value</a>', html)
 
     def test_return_false_if_url_does_not_exists(self):
         class NoURLFieldFile:
             def __str__(self):
-                return 'value'
+                return "value"
 
-        html = self.widget.render('myfile', NoURLFieldFile())
+        html = self.widget.render("myfile", NoURLFieldFile())
         self.assertHTMLEqual(html, '<input name="myfile" type="file">')
 
     def test_use_required_attribute(self):
         # False when initial data exists. The file input is left blank by the
         # user to keep the existing, initial value.
         self.assertIs(self.widget.use_required_attribute(None), True)
-        self.assertIs(self.widget.use_required_attribute('resume.txt'), False)
+        self.assertIs(self.widget.use_required_attribute("resume.txt"), False)
 
     def test_value_omitted_from_data(self):
         widget = ClearableFileInput()
-        self.assertIs(widget.value_omitted_from_data({}, {}, 'field'), True)
-        self.assertIs(widget.value_omitted_from_data({}, {'field': 'x'}, 'field'), False)
-        self.assertIs(widget.value_omitted_from_data({'field-clear': 'y'}, {}, 'field'), False)
+        self.assertIs(widget.value_omitted_from_data({}, {}, "field"), True)
+        self.assertIs(
+            widget.value_omitted_from_data({}, {"field": "x"}, "field"), False
+        )
+        self.assertIs(
+            widget.value_omitted_from_data({"field-clear": "y"}, {}, "field"), False
+        )
diff --git a/tests/forms_tests/widget_tests/test_dateinput.py b/tests/forms_tests/widget_tests/test_dateinput.py
index fa08b345c1..07446480f6 100644
--- a/tests/forms_tests/widget_tests/test_dateinput.py
+++ b/tests/forms_tests/widget_tests/test_dateinput.py
@@ -10,36 +10,53 @@ class DateInputTest(WidgetTest):
     widget = DateInput()
 
     def test_render_none(self):
-        self.check_html(self.widget, 'date', None, html='<input type="text" name="date">')
+        self.check_html(
+            self.widget, "date", None, html='<input type="text" name="date">'
+        )
 
     def test_render_value(self):
         d = date(2007, 9, 17)
-        self.assertEqual(str(d), '2007-09-17')
+        self.assertEqual(str(d), "2007-09-17")
 
-        self.check_html(self.widget, 'date', d, html='<input type="text" name="date" value="2007-09-17">')
-        self.check_html(self.widget, 'date', date(2007, 9, 17), html=(
-            '<input type="text" name="date" value="2007-09-17">'
-        ))
+        self.check_html(
+            self.widget,
+            "date",
+            d,
+            html='<input type="text" name="date" value="2007-09-17">',
+        )
+        self.check_html(
+            self.widget,
+            "date",
+            date(2007, 9, 17),
+            html=('<input type="text" name="date" value="2007-09-17">'),
+        )
 
     def test_string(self):
         """
         Should be able to initialize from a string value.
         """
-        self.check_html(self.widget, 'date', '2007-09-17', html=(
-            '<input type="text" name="date" value="2007-09-17">'
-        ))
+        self.check_html(
+            self.widget,
+            "date",
+            "2007-09-17",
+            html=('<input type="text" name="date" value="2007-09-17">'),
+        )
 
     def test_format(self):
         """
         Use 'format' to change the way a value is displayed.
         """
         d = date(2007, 9, 17)
-        widget = DateInput(format='%d/%m/%Y', attrs={'type': 'date'})
-        self.check_html(widget, 'date', d, html='<input type="date" name="date" value="17/09/2007">')
+        widget = DateInput(format="%d/%m/%Y", attrs={"type": "date"})
+        self.check_html(
+            widget, "date", d, html='<input type="date" name="date" value="17/09/2007">'
+        )
 
-    @translation.override('de-at')
+    @translation.override("de-at")
     def test_l10n(self):
         self.check_html(
-            self.widget, 'date', date(2007, 9, 17),
+            self.widget,
+            "date",
+            date(2007, 9, 17),
             html='<input type="text" name="date" value="17.09.2007">',
         )
diff --git a/tests/forms_tests/widget_tests/test_datetimeinput.py b/tests/forms_tests/widget_tests/test_datetimeinput.py
index 0a2571f5b7..5795660f30 100644
--- a/tests/forms_tests/widget_tests/test_datetimeinput.py
+++ b/tests/forms_tests/widget_tests/test_datetimeinput.py
@@ -12,42 +12,60 @@ class DateTimeInputTest(WidgetTest):
     widget = DateTimeInput()
 
     def test_render_none(self):
-        self.check_html(self.widget, 'date', None, '<input type="text" name="date">')
+        self.check_html(self.widget, "date", None, '<input type="text" name="date">')
 
     def test_render_value(self):
         """
         The microseconds are trimmed on display, by default.
         """
         d = datetime(2007, 9, 17, 12, 51, 34, 482548)
-        self.assertEqual(str(d), '2007-09-17 12:51:34.482548')
-        self.check_html(self.widget, 'date', d, html=(
-            '<input type="text" name="date" value="2007-09-17 12:51:34">'
-        ))
-        self.check_html(self.widget, 'date', datetime(2007, 9, 17, 12, 51, 34), html=(
-            '<input type="text" name="date" value="2007-09-17 12:51:34">'
-        ))
-        self.check_html(self.widget, 'date', datetime(2007, 9, 17, 12, 51), html=(
-            '<input type="text" name="date" value="2007-09-17 12:51:00">'
-        ))
+        self.assertEqual(str(d), "2007-09-17 12:51:34.482548")
+        self.check_html(
+            self.widget,
+            "date",
+            d,
+            html=('<input type="text" name="date" value="2007-09-17 12:51:34">'),
+        )
+        self.check_html(
+            self.widget,
+            "date",
+            datetime(2007, 9, 17, 12, 51, 34),
+            html=('<input type="text" name="date" value="2007-09-17 12:51:34">'),
+        )
+        self.check_html(
+            self.widget,
+            "date",
+            datetime(2007, 9, 17, 12, 51),
+            html=('<input type="text" name="date" value="2007-09-17 12:51:00">'),
+        )
 
     def test_render_formatted(self):
         """
         Use 'format' to change the way a value is displayed.
         """
         widget = DateTimeInput(
-            format='%d/%m/%Y %H:%M', attrs={'type': 'datetime'},
+            format="%d/%m/%Y %H:%M",
+            attrs={"type": "datetime"},
         )
         d = datetime(2007, 9, 17, 12, 51, 34, 482548)
-        self.check_html(widget, 'date', d, html='<input type="datetime" name="date" value="17/09/2007 12:51">')
+        self.check_html(
+            widget,
+            "date",
+            d,
+            html='<input type="datetime" name="date" value="17/09/2007 12:51">',
+        )
 
-    @translation.override('de-at')
+    @translation.override("de-at")
     def test_l10n(self):
         d = datetime(2007, 9, 17, 12, 51, 34, 482548)
-        self.check_html(self.widget, 'date', d, html=(
-            '<input type="text" name="date" value="17.09.2007 12:51:34">'
-        ))
+        self.check_html(
+            self.widget,
+            "date",
+            d,
+            html=('<input type="text" name="date" value="17.09.2007 12:51:34">'),
+        )
 
-    @translation.override('de-at')
+    @translation.override("de-at")
     def test_locale_aware(self):
         d = datetime(2007, 9, 17, 12, 51, 34, 482548)
         # RemovedInDjango50Warning: When the deprecation ends, remove
@@ -56,15 +74,23 @@ class DateTimeInputTest(WidgetTest):
         # locale-dictated formats.
         with ignore_warnings(category=RemovedInDjango50Warning):
             with self.settings(USE_L10N=False):
-                with self.settings(DATETIME_INPUT_FORMATS=[
-                    '%Y-%m-%d %H:%M:%S', '%Y-%m-%d %H:%M:%S.%f', '%Y-%m-%d %H:%M',
-                ]):
+                with self.settings(
+                    DATETIME_INPUT_FORMATS=[
+                        "%Y-%m-%d %H:%M:%S",
+                        "%Y-%m-%d %H:%M:%S.%f",
+                        "%Y-%m-%d %H:%M",
+                    ]
+                ):
                     self.check_html(
-                        self.widget, 'date', d,
+                        self.widget,
+                        "date",
+                        d,
                         html='<input type="text" name="date" value="2007-09-17 12:51:34">',
                     )
-        with translation.override('es'):
+        with translation.override("es"):
             self.check_html(
-                self.widget, 'date', d,
+                self.widget,
+                "date",
+                d,
                 html='<input type="text" name="date" value="17/09/2007 12:51:34">',
             )
diff --git a/tests/forms_tests/widget_tests/test_fileinput.py b/tests/forms_tests/widget_tests/test_fileinput.py
index 8eec26253a..ea11c639e4 100644
--- a/tests/forms_tests/widget_tests/test_fileinput.py
+++ b/tests/forms_tests/widget_tests/test_fileinput.py
@@ -11,16 +11,27 @@ class FileInputTest(WidgetTest):
         FileInput widgets never render the value attribute. The old value
         isn't useful if a form is updated or an error occurred.
         """
-        self.check_html(self.widget, 'email', 'test@example.com', html='<input type="file" name="email">')
-        self.check_html(self.widget, 'email', '', html='<input type="file" name="email">')
-        self.check_html(self.widget, 'email', None, html='<input type="file" name="email">')
+        self.check_html(
+            self.widget,
+            "email",
+            "test@example.com",
+            html='<input type="file" name="email">',
+        )
+        self.check_html(
+            self.widget, "email", "", html='<input type="file" name="email">'
+        )
+        self.check_html(
+            self.widget, "email", None, html='<input type="file" name="email">'
+        )
 
     def test_value_omitted_from_data(self):
-        self.assertIs(self.widget.value_omitted_from_data({}, {}, 'field'), True)
-        self.assertIs(self.widget.value_omitted_from_data({}, {'field': 'value'}, 'field'), False)
+        self.assertIs(self.widget.value_omitted_from_data({}, {}, "field"), True)
+        self.assertIs(
+            self.widget.value_omitted_from_data({}, {"field": "value"}, "field"), False
+        )
 
     def test_use_required_attribute(self):
         # False when initial data exists. The file input is left blank by the
         # user to keep the existing, initial value.
         self.assertIs(self.widget.use_required_attribute(None), True)
-        self.assertIs(self.widget.use_required_attribute('resume.txt'), False)
+        self.assertIs(self.widget.use_required_attribute("resume.txt"), False)
diff --git a/tests/forms_tests/widget_tests/test_hiddeninput.py b/tests/forms_tests/widget_tests/test_hiddeninput.py
index a7d036410c..ba5e796501 100644
--- a/tests/forms_tests/widget_tests/test_hiddeninput.py
+++ b/tests/forms_tests/widget_tests/test_hiddeninput.py
@@ -7,11 +7,13 @@ class HiddenInputTest(WidgetTest):
     widget = HiddenInput()
 
     def test_render(self):
-        self.check_html(self.widget, 'email', '', html='<input type="hidden" name="email">')
+        self.check_html(
+            self.widget, "email", "", html='<input type="hidden" name="email">'
+        )
 
     def test_use_required_attribute(self):
         # Always False to avoid browser validation on inputs hidden from the
         # user.
         self.assertIs(self.widget.use_required_attribute(None), False)
-        self.assertIs(self.widget.use_required_attribute(''), False)
-        self.assertIs(self.widget.use_required_attribute('foo'), False)
+        self.assertIs(self.widget.use_required_attribute(""), False)
+        self.assertIs(self.widget.use_required_attribute("foo"), False)
diff --git a/tests/forms_tests/widget_tests/test_input.py b/tests/forms_tests/widget_tests/test_input.py
index 8be971826e..72c2c217c0 100644
--- a/tests/forms_tests/widget_tests/test_input.py
+++ b/tests/forms_tests/widget_tests/test_input.py
@@ -4,12 +4,20 @@ from .base import WidgetTest
 
 
 class InputTests(WidgetTest):
-
     def test_attrs_with_type(self):
-        attrs = {'type': 'date'}
+        attrs = {"type": "date"}
         widget = Input(attrs)
-        self.check_html(widget, 'name', 'value', '<input type="date" name="name" value="value">')
+        self.check_html(
+            widget, "name", "value", '<input type="date" name="name" value="value">'
+        )
         # reuse the same attrs for another widget
-        self.check_html(Input(attrs), 'name', 'value', '<input type="date" name="name" value="value">')
-        attrs['type'] = 'number'  # shouldn't change the widget type
-        self.check_html(widget, 'name', 'value', '<input type="date" name="name" value="value">')
+        self.check_html(
+            Input(attrs),
+            "name",
+            "value",
+            '<input type="date" name="name" value="value">',
+        )
+        attrs["type"] = "number"  # shouldn't change the widget type
+        self.check_html(
+            widget, "name", "value", '<input type="date" name="name" value="value">'
+        )
diff --git a/tests/forms_tests/widget_tests/test_multiplehiddeninput.py b/tests/forms_tests/widget_tests/test_multiplehiddeninput.py
index 37d54174ee..d0ad188929 100644
--- a/tests/forms_tests/widget_tests/test_multiplehiddeninput.py
+++ b/tests/forms_tests/widget_tests/test_multiplehiddeninput.py
@@ -8,13 +8,17 @@ class MultipleHiddenInputTest(WidgetTest):
 
     def test_render_single(self):
         self.check_html(
-            self.widget, 'email', ['test@example.com'],
+            self.widget,
+            "email",
+            ["test@example.com"],
             html='<input type="hidden" name="email" value="test@example.com">',
         )
 
     def test_render_multiple(self):
         self.check_html(
-            self.widget, 'email', ['test@example.com', 'foo@example.com'],
+            self.widget,
+            "email",
+            ["test@example.com", "foo@example.com"],
             html=(
                 '<input type="hidden" name="email" value="test@example.com">\n'
                 '<input type="hidden" name="email" value="foo@example.com">'
@@ -23,13 +27,19 @@ class MultipleHiddenInputTest(WidgetTest):
 
     def test_render_attrs(self):
         self.check_html(
-            self.widget, 'email', ['test@example.com'], attrs={'class': 'fun'},
+            self.widget,
+            "email",
+            ["test@example.com"],
+            attrs={"class": "fun"},
             html='<input type="hidden" name="email" value="test@example.com" class="fun">',
         )
 
     def test_render_attrs_multiple(self):
         self.check_html(
-            self.widget, 'email', ['test@example.com', 'foo@example.com'], attrs={'class': 'fun'},
+            self.widget,
+            "email",
+            ["test@example.com", "foo@example.com"],
+            attrs={"class": "fun"},
             html=(
                 '<input type="hidden" name="email" value="test@example.com" class="fun">\n'
                 '<input type="hidden" name="email" value="foo@example.com" class="fun">'
@@ -37,36 +47,46 @@ class MultipleHiddenInputTest(WidgetTest):
         )
 
     def test_render_attrs_constructor(self):
-        widget = MultipleHiddenInput(attrs={'class': 'fun'})
-        self.check_html(widget, 'email', [], '')
+        widget = MultipleHiddenInput(attrs={"class": "fun"})
+        self.check_html(widget, "email", [], "")
         self.check_html(
-            widget, 'email', ['foo@example.com'],
+            widget,
+            "email",
+            ["foo@example.com"],
             html='<input type="hidden" class="fun" value="foo@example.com" name="email">',
         )
         self.check_html(
-            widget, 'email', ['foo@example.com', 'test@example.com'],
+            widget,
+            "email",
+            ["foo@example.com", "test@example.com"],
             html=(
                 '<input type="hidden" class="fun" value="foo@example.com" name="email">\n'
                 '<input type="hidden" class="fun" value="test@example.com" name="email">'
             ),
         )
         self.check_html(
-            widget, 'email', ['foo@example.com'], attrs={'class': 'special'},
+            widget,
+            "email",
+            ["foo@example.com"],
+            attrs={"class": "special"},
             html='<input type="hidden" class="special" value="foo@example.com" name="email">',
         )
 
     def test_render_empty(self):
-        self.check_html(self.widget, 'email', [], '')
+        self.check_html(self.widget, "email", [], "")
 
     def test_render_none(self):
-        self.check_html(self.widget, 'email', None, '')
+        self.check_html(self.widget, "email", None, "")
 
     def test_render_increment_id(self):
         """
         Each input should get a separate ID.
         """
         self.check_html(
-            self.widget, 'letters', ['a', 'b', 'c'], attrs={'id': 'hideme'},
+            self.widget,
+            "letters",
+            ["a", "b", "c"],
+            attrs={"id": "hideme"},
             html=(
                 '<input type="hidden" name="letters" value="a" id="hideme_0">\n'
                 '<input type="hidden" name="letters" value="b" id="hideme_1">\n'
diff --git a/tests/forms_tests/widget_tests/test_multiwidget.py b/tests/forms_tests/widget_tests/test_multiwidget.py
index cb1e9d31c5..c3f676e3f7 100644
--- a/tests/forms_tests/widget_tests/test_multiwidget.py
+++ b/tests/forms_tests/widget_tests/test_multiwidget.py
@@ -2,8 +2,15 @@ import copy
 from datetime import datetime
 
 from django.forms import (
-    CharField, FileInput, MultipleChoiceField, MultiValueField, MultiWidget,
-    RadioSelect, SelectMultiple, SplitDateTimeField, SplitDateTimeWidget,
+    CharField,
+    FileInput,
+    MultipleChoiceField,
+    MultiValueField,
+    MultiWidget,
+    RadioSelect,
+    SelectMultiple,
+    SplitDateTimeField,
+    SplitDateTimeWidget,
     TextInput,
 )
 
@@ -13,8 +20,8 @@ from .base import WidgetTest
 class MyMultiWidget(MultiWidget):
     def decompress(self, value):
         if value:
-            return value.split('__')
-        return ['', '']
+            return value.split("__")
+        return ["", ""]
 
 
 class ComplexMultiWidget(MultiWidget):
@@ -28,9 +35,11 @@ class ComplexMultiWidget(MultiWidget):
 
     def decompress(self, value):
         if value:
-            data = value.split(',')
+            data = value.split(",")
             return [
-                data[0], list(data[1]), datetime.strptime(data[2], "%Y-%m-%d %H:%M:%S")
+                data[0],
+                list(data[1]),
+                datetime.strptime(data[2], "%Y-%m-%d %H:%M:%S"),
             ]
         return [None, None, None]
 
@@ -46,8 +55,10 @@ class ComplexField(MultiValueField):
 
     def compress(self, data_list):
         if data_list:
-            return '%s,%s,%s' % (
-                data_list[0], ''.join(data_list[1]), data_list[2],
+            return "%s,%s,%s" % (
+                data_list[0],
+                "".join(data_list[1]),
+                data_list[2],
             )
         return None
 
@@ -56,6 +67,7 @@ class DeepCopyWidget(MultiWidget):
     """
     Used to test MultiWidget.__deepcopy__().
     """
+
     def __init__(self, choices=[]):
         widgets = [
             RadioSelect(choices=choices),
@@ -75,6 +87,7 @@ class DeepCopyWidget(MultiWidget):
         The choices for this widget are the Select widget's choices.
         """
         return self.widgets[0].choices
+
     choices = property(_get_choices, _set_choices)
 
 
@@ -82,97 +95,144 @@ class MultiWidgetTest(WidgetTest):
     def test_subwidgets_name(self):
         widget = MultiWidget(
             widgets={
-                '': TextInput(),
-                'big': TextInput(attrs={'class': 'big'}),
-                'small': TextInput(attrs={'class': 'small'}),
+                "": TextInput(),
+                "big": TextInput(attrs={"class": "big"}),
+                "small": TextInput(attrs={"class": "small"}),
             },
         )
-        self.check_html(widget, 'name', ['John', 'George', 'Paul'], html=(
-            '<input type="text" name="name" value="John">'
-            '<input type="text" name="name_big" value="George" class="big">'
-            '<input type="text" name="name_small" value="Paul" class="small">'
-        ))
+        self.check_html(
+            widget,
+            "name",
+            ["John", "George", "Paul"],
+            html=(
+                '<input type="text" name="name" value="John">'
+                '<input type="text" name="name_big" value="George" class="big">'
+                '<input type="text" name="name_small" value="Paul" class="small">'
+            ),
+        )
 
     def test_text_inputs(self):
         widget = MyMultiWidget(
             widgets=(
-                TextInput(attrs={'class': 'big'}),
-                TextInput(attrs={'class': 'small'}),
+                TextInput(attrs={"class": "big"}),
+                TextInput(attrs={"class": "small"}),
             )
         )
-        self.check_html(widget, 'name', ['john', 'lennon'], html=(
-            '<input type="text" class="big" value="john" name="name_0">'
-            '<input type="text" class="small" value="lennon" name="name_1">'
-        ))
-        self.check_html(widget, 'name', 'john__lennon', html=(
-            '<input type="text" class="big" value="john" name="name_0">'
-            '<input type="text" class="small" value="lennon" name="name_1">'
-        ))
-        self.check_html(widget, 'name', 'john__lennon', attrs={'id': 'foo'}, html=(
-            '<input id="foo_0" type="text" class="big" value="john" name="name_0">'
-            '<input id="foo_1" type="text" class="small" value="lennon" name="name_1">'
-        ))
+        self.check_html(
+            widget,
+            "name",
+            ["john", "lennon"],
+            html=(
+                '<input type="text" class="big" value="john" name="name_0">'
+                '<input type="text" class="small" value="lennon" name="name_1">'
+            ),
+        )
+        self.check_html(
+            widget,
+            "name",
+            "john__lennon",
+            html=(
+                '<input type="text" class="big" value="john" name="name_0">'
+                '<input type="text" class="small" value="lennon" name="name_1">'
+            ),
+        )
+        self.check_html(
+            widget,
+            "name",
+            "john__lennon",
+            attrs={"id": "foo"},
+            html=(
+                '<input id="foo_0" type="text" class="big" value="john" name="name_0">'
+                '<input id="foo_1" type="text" class="small" value="lennon" name="name_1">'
+            ),
+        )
 
     def test_constructor_attrs(self):
         widget = MyMultiWidget(
             widgets=(
-                TextInput(attrs={'class': 'big'}),
-                TextInput(attrs={'class': 'small'}),
+                TextInput(attrs={"class": "big"}),
+                TextInput(attrs={"class": "small"}),
+            ),
+            attrs={"id": "bar"},
+        )
+        self.check_html(
+            widget,
+            "name",
+            ["john", "lennon"],
+            html=(
+                '<input id="bar_0" type="text" class="big" value="john" name="name_0">'
+                '<input id="bar_1" type="text" class="small" value="lennon" name="name_1">'
             ),
-            attrs={'id': 'bar'},
         )
-        self.check_html(widget, 'name', ['john', 'lennon'], html=(
-            '<input id="bar_0" type="text" class="big" value="john" name="name_0">'
-            '<input id="bar_1" type="text" class="small" value="lennon" name="name_1">'
-        ))
 
     def test_constructor_attrs_with_type(self):
-        attrs = {'type': 'number'}
+        attrs = {"type": "number"}
         widget = MyMultiWidget(widgets=(TextInput, TextInput()), attrs=attrs)
-        self.check_html(widget, 'code', ['1', '2'], html=(
-            '<input type="number" value="1" name="code_0">'
-            '<input type="number" value="2" name="code_1">'
-        ))
-        widget = MyMultiWidget(widgets=(TextInput(attrs), TextInput(attrs)), attrs={'class': 'bar'})
-        self.check_html(widget, 'code', ['1', '2'], html=(
-            '<input type="number" value="1" name="code_0" class="bar">'
-            '<input type="number" value="2" name="code_1" class="bar">'
-        ))
+        self.check_html(
+            widget,
+            "code",
+            ["1", "2"],
+            html=(
+                '<input type="number" value="1" name="code_0">'
+                '<input type="number" value="2" name="code_1">'
+            ),
+        )
+        widget = MyMultiWidget(
+            widgets=(TextInput(attrs), TextInput(attrs)), attrs={"class": "bar"}
+        )
+        self.check_html(
+            widget,
+            "code",
+            ["1", "2"],
+            html=(
+                '<input type="number" value="1" name="code_0" class="bar">'
+                '<input type="number" value="2" name="code_1" class="bar">'
+            ),
+        )
 
     def test_value_omitted_from_data(self):
         widget = MyMultiWidget(widgets=(TextInput(), TextInput()))
-        self.assertIs(widget.value_omitted_from_data({}, {}, 'field'), True)
-        self.assertIs(widget.value_omitted_from_data({'field_0': 'x'}, {}, 'field'), False)
-        self.assertIs(widget.value_omitted_from_data({'field_1': 'y'}, {}, 'field'), False)
-        self.assertIs(widget.value_omitted_from_data({'field_0': 'x', 'field_1': 'y'}, {}, 'field'), False)
+        self.assertIs(widget.value_omitted_from_data({}, {}, "field"), True)
+        self.assertIs(
+            widget.value_omitted_from_data({"field_0": "x"}, {}, "field"), False
+        )
+        self.assertIs(
+            widget.value_omitted_from_data({"field_1": "y"}, {}, "field"), False
+        )
+        self.assertIs(
+            widget.value_omitted_from_data(
+                {"field_0": "x", "field_1": "y"}, {}, "field"
+            ),
+            False,
+        )
 
     def test_value_from_datadict_subwidgets_name(self):
-        widget = MultiWidget(widgets={'x': TextInput(), '': TextInput()})
+        widget = MultiWidget(widgets={"x": TextInput(), "": TextInput()})
         tests = [
             ({}, [None, None]),
-            ({'field': 'x'}, [None, 'x']),
-            ({'field_x': 'y'}, ['y', None]),
-            ({'field': 'x', 'field_x': 'y'}, ['y', 'x']),
+            ({"field": "x"}, [None, "x"]),
+            ({"field_x": "y"}, ["y", None]),
+            ({"field": "x", "field_x": "y"}, ["y", "x"]),
         ]
         for data, expected in tests:
             with self.subTest(data):
                 self.assertEqual(
-                    widget.value_from_datadict(data, {}, 'field'),
+                    widget.value_from_datadict(data, {}, "field"),
                     expected,
                 )
 
     def test_value_omitted_from_data_subwidgets_name(self):
-        widget = MultiWidget(widgets={'x': TextInput(), '': TextInput()})
+        widget = MultiWidget(widgets={"x": TextInput(), "": TextInput()})
         tests = [
             ({}, True),
-            ({'field': 'x'}, False),
-            ({'field_x': 'y'}, False),
-            ({'field': 'x', 'field_x': 'y'}, False),
+            ({"field": "x"}, False),
+            ({"field_x": "y"}, False),
+            ({"field": "x", "field_x": "y"}, False),
         ]
         for data, expected in tests:
             with self.subTest(data):
                 self.assertIs(
-                    widget.value_omitted_from_data(data, {}, 'field'),
+                    widget.value_omitted_from_data(data, {}, "field"),
                     expected,
                 )
 
@@ -195,8 +255,12 @@ class MultiWidgetTest(WidgetTest):
         MultiWidgets can be composed of other MultiWidgets.
         """
         widget = ComplexMultiWidget()
-        self.check_html(widget, 'name', 'some text,JP,2007-04-25 06:24:00', html=(
-            """
+        self.check_html(
+            widget,
+            "name",
+            "some text,JP,2007-04-25 06:24:00",
+            html=(
+                """
             <input type="text" name="name_0" value="some text">
             <select multiple name="name_1">
                 <option value="J" selected>John</option>
@@ -207,13 +271,18 @@ class MultiWidgetTest(WidgetTest):
             <input type="text" name="name_2_0" value="2007-04-25">
             <input type="text" name="name_2_1" value="06:24:00">
             """
-        ))
+            ),
+        )
 
     def test_no_whitespace_between_widgets(self):
         widget = MyMultiWidget(widgets=(TextInput, TextInput()))
-        self.check_html(widget, 'code', None, html=(
-            '<input type="text" name="code_0"><input type="text" name="code_1">'
-        ), strict=True)
+        self.check_html(
+            widget,
+            "code",
+            None,
+            html=('<input type="text" name="code_0"><input type="text" name="code_1">'),
+            strict=True,
+        )
 
     def test_deepcopy(self):
         """
diff --git a/tests/forms_tests/widget_tests/test_nullbooleanselect.py b/tests/forms_tests/widget_tests/test_nullbooleanselect.py
index 4e34020cdd..927abdba01 100644
--- a/tests/forms_tests/widget_tests/test_nullbooleanselect.py
+++ b/tests/forms_tests/widget_tests/test_nullbooleanselect.py
@@ -8,85 +8,130 @@ class NullBooleanSelectTest(WidgetTest):
     widget = NullBooleanSelect()
 
     def test_render_true(self):
-        self.check_html(self.widget, 'is_cool', True, html=(
-            """<select name="is_cool">
+        self.check_html(
+            self.widget,
+            "is_cool",
+            True,
+            html=(
+                """<select name="is_cool">
             <option value="unknown">Unknown</option>
             <option value="true" selected>Yes</option>
             <option value="false">No</option>
             </select>"""
-        ))
+            ),
+        )
 
     def test_render_false(self):
-        self.check_html(self.widget, 'is_cool', False, html=(
-            """<select name="is_cool">
+        self.check_html(
+            self.widget,
+            "is_cool",
+            False,
+            html=(
+                """<select name="is_cool">
             <option value="unknown">Unknown</option>
             <option value="true">Yes</option>
             <option value="false" selected>No</option>
             </select>"""
-        ))
+            ),
+        )
 
     def test_render_none(self):
-        self.check_html(self.widget, 'is_cool', None, html=(
-            """<select name="is_cool">
+        self.check_html(
+            self.widget,
+            "is_cool",
+            None,
+            html=(
+                """<select name="is_cool">
             <option value="unknown" selected>Unknown</option>
             <option value="true">Yes</option>
             <option value="false">No</option>
             </select>"""
-        ))
+            ),
+        )
 
     def test_render_value_unknown(self):
-        self.check_html(self.widget, 'is_cool', 'unknown', html=(
-            """<select name="is_cool">
+        self.check_html(
+            self.widget,
+            "is_cool",
+            "unknown",
+            html=(
+                """<select name="is_cool">
             <option value="unknown" selected>Unknown</option>
             <option value="true">Yes</option>
             <option value="false">No</option>
             </select>"""
-        ))
+            ),
+        )
 
     def test_render_value_true(self):
-        self.check_html(self.widget, 'is_cool', 'true', html=(
-            """<select name="is_cool">
+        self.check_html(
+            self.widget,
+            "is_cool",
+            "true",
+            html=(
+                """<select name="is_cool">
             <option value="unknown">Unknown</option>
             <option value="true" selected>Yes</option>
             <option value="false">No</option>
             </select>"""
-        ))
+            ),
+        )
 
     def test_render_value_false(self):
-        self.check_html(self.widget, 'is_cool', 'false', html=(
-            """<select name="is_cool">
+        self.check_html(
+            self.widget,
+            "is_cool",
+            "false",
+            html=(
+                """<select name="is_cool">
             <option value="unknown">Unknown</option>
             <option value="true">Yes</option>
             <option value="false" selected>No</option>
             </select>"""
-        ))
+            ),
+        )
 
     def test_render_value_1(self):
-        self.check_html(self.widget, 'is_cool', '1', html=(
-            """<select name="is_cool">
+        self.check_html(
+            self.widget,
+            "is_cool",
+            "1",
+            html=(
+                """<select name="is_cool">
             <option value="unknown" selected>Unknown</option>
             <option value="true">Yes</option>
             <option value="false">No</option>
             </select>"""
-        ))
+            ),
+        )
 
     def test_render_value_2(self):
-        self.check_html(self.widget, 'is_cool', '2', html=(
-            """<select name="is_cool">
+        self.check_html(
+            self.widget,
+            "is_cool",
+            "2",
+            html=(
+                """<select name="is_cool">
             <option value="unknown">Unknown</option>
             <option value="true" selected>Yes</option>
             <option value="false">No</option>
             </select>"""
-        ))
+            ),
+        )
 
     def test_render_value_3(self):
-        self.check_html(self.widget, 'is_cool', '3', html=(
-            """<select name="is_cool">
+        self.check_html(
+            self.widget,
+            "is_cool",
+            "3",
+            html=(
+                """<select name="is_cool">
             <option value="unknown">Unknown</option>
             <option value="true">Yes</option>
             <option value="false" selected>No</option>
             </select>"""
-        ))
+            ),
+        )
 
     def test_l10n(self):
         """
@@ -94,13 +139,18 @@ class NullBooleanSelectTest(WidgetTest):
         """
         widget = NullBooleanSelect()
 
-        with translation.override('de-at'):
-            self.check_html(widget, 'id_bool', True, html=(
-                """
+        with translation.override("de-at"):
+            self.check_html(
+                widget,
+                "id_bool",
+                True,
+                html=(
+                    """
                 <select name="id_bool">
                     <option value="unknown">Unbekannt</option>
                     <option value="true" selected>Ja</option>
                     <option value="false">Nein</option>
                 </select>
                 """
-            ))
+                ),
+            )
diff --git a/tests/forms_tests/widget_tests/test_numberinput.py b/tests/forms_tests/widget_tests/test_numberinput.py
index 9fda30e156..a6427e6e37 100644
--- a/tests/forms_tests/widget_tests/test_numberinput.py
+++ b/tests/forms_tests/widget_tests/test_numberinput.py
@@ -5,11 +5,12 @@ from .base import WidgetTest
 
 
 class NumberInputTests(WidgetTest):
-
     @override_settings(USE_THOUSAND_SEPARATOR=True)
     def test_attrs_not_localized(self):
-        widget = NumberInput(attrs={'max': 12345, 'min': 1234, 'step': 9999})
+        widget = NumberInput(attrs={"max": 12345, "min": 1234, "step": 9999})
         self.check_html(
-            widget, 'name', 'value',
-            '<input type="number" name="name" value="value" max="12345" min="1234" step="9999">'
+            widget,
+            "name",
+            "value",
+            '<input type="number" name="name" value="value" max="12345" min="1234" step="9999">',
         )
diff --git a/tests/forms_tests/widget_tests/test_passwordinput.py b/tests/forms_tests/widget_tests/test_passwordinput.py
index ecbe274d69..1adf0cc3cb 100644
--- a/tests/forms_tests/widget_tests/test_passwordinput.py
+++ b/tests/forms_tests/widget_tests/test_passwordinput.py
@@ -7,10 +7,17 @@ class PasswordInputTest(WidgetTest):
     widget = PasswordInput()
 
     def test_render(self):
-        self.check_html(self.widget, 'password', '', html='<input type="password" name="password">')
+        self.check_html(
+            self.widget, "password", "", html='<input type="password" name="password">'
+        )
 
     def test_render_ignore_value(self):
-        self.check_html(self.widget, 'password', 'secret', html='<input type="password" name="password">')
+        self.check_html(
+            self.widget,
+            "password",
+            "secret",
+            html='<input type="password" name="password">',
+        )
 
     def test_render_value_true(self):
         """
@@ -18,9 +25,15 @@ class PasswordInputTest(WidgetTest):
         render its value. For security reasons, this is off by default.
         """
         widget = PasswordInput(render_value=True)
-        self.check_html(widget, 'password', '', html='<input type="password" name="password">')
-        self.check_html(widget, 'password', None, html='<input type="password" name="password">')
         self.check_html(
-            widget, 'password', 'test@example.com',
+            widget, "password", "", html='<input type="password" name="password">'
+        )
+        self.check_html(
+            widget, "password", None, html='<input type="password" name="password">'
+        )
+        self.check_html(
+            widget,
+            "password",
+            "test@example.com",
             html='<input type="password" name="password" value="test@example.com">',
         )
diff --git a/tests/forms_tests/widget_tests/test_radioselect.py b/tests/forms_tests/widget_tests/test_radioselect.py
index 9622517144..89e4022f1c 100644
--- a/tests/forms_tests/widget_tests/test_radioselect.py
+++ b/tests/forms_tests/widget_tests/test_radioselect.py
@@ -10,8 +10,12 @@ class RadioSelectTest(WidgetTest):
     widget = RadioSelect
 
     def test_render(self):
-        choices = (('', '------'),) + self.beatles
-        self.check_html(self.widget(choices=choices), 'beatle', 'J', html="""
+        choices = (("", "------"),) + self.beatles
+        self.check_html(
+            self.widget(choices=choices),
+            "beatle",
+            "J",
+            html="""
             <div>
             <div><label><input type="radio" name="beatle" value=""> ------</label></div>
             <div><label><input checked type="radio" name="beatle" value="J"> John</label></div>
@@ -19,13 +23,14 @@ class RadioSelectTest(WidgetTest):
             <div><label><input type="radio" name="beatle" value="G"> George</label></div>
             <div><label><input type="radio" name="beatle" value="R"> Ringo</label></div>
             </div>
-        """)
+        """,
+        )
 
     def test_nested_choices(self):
         nested_choices = (
-            ('unknown', 'Unknown'),
-            ('Audio', (('vinyl', 'Vinyl'), ('cd', 'CD'))),
-            ('Video', (('vhs', 'VHS'), ('dvd', 'DVD'))),
+            ("unknown", "Unknown"),
+            ("Audio", (("vinyl", "Vinyl"), ("cd", "CD"))),
+            ("Video", (("vhs", "VHS"), ("dvd", "DVD"))),
         )
         html = """
         <div id="media">
@@ -47,8 +52,11 @@ class RadioSelectTest(WidgetTest):
         </div>
         """
         self.check_html(
-            self.widget(choices=nested_choices), 'nestchoice', 'dvd',
-            attrs={'id': 'media'}, html=html,
+            self.widget(choices=nested_choices),
+            "nestchoice",
+            "dvd",
+            attrs={"id": "media"},
+            html=html,
         )
 
     def test_constructor_attrs(self):
@@ -56,7 +64,7 @@ class RadioSelectTest(WidgetTest):
         Attributes provided at instantiation are passed to the constituent
         inputs.
         """
-        widget = RadioSelect(attrs={'id': 'foo'}, choices=self.beatles)
+        widget = RadioSelect(attrs={"id": "foo"}, choices=self.beatles)
         html = """
         <div id="foo">
         <div>
@@ -67,7 +75,7 @@ class RadioSelectTest(WidgetTest):
         <div><label for="foo_3"><input type="radio" id="foo_3" value="R" name="beatle"> Ringo</label></div>
         </div>
         """
-        self.check_html(widget, 'beatle', 'J', html=html)
+        self.check_html(widget, "beatle", "J", html=html)
 
     def test_render_attrs(self):
         """
@@ -84,7 +92,13 @@ class RadioSelectTest(WidgetTest):
         <div><label for="bar_3"><input type="radio" id="bar_3" value="R" name="beatle"> Ringo</label></div>
         </div>
         """
-        self.check_html(self.widget(choices=self.beatles), 'beatle', 'J', attrs={'id': 'bar'}, html=html)
+        self.check_html(
+            self.widget(choices=self.beatles),
+            "beatle",
+            "J",
+            attrs={"id": "bar"},
+            html=html,
+        )
 
     def test_class_attrs(self):
         """
@@ -99,14 +113,20 @@ class RadioSelectTest(WidgetTest):
         <div><label><input type="radio" class="bar" value="R" name="beatle"> Ringo</label></div>
         </div>
         """
-        self.check_html(self.widget(choices=self.beatles), 'beatle', 'J', attrs={'class': 'bar'}, html=html)
+        self.check_html(
+            self.widget(choices=self.beatles),
+            "beatle",
+            "J",
+            attrs={"class": "bar"},
+            html=html,
+        )
 
     @override_settings(USE_THOUSAND_SEPARATOR=True)
     def test_doesnt_localize_input_value(self):
         choices = [
-            (1, 'One'),
-            (1000, 'One thousand'),
-            (1000000, 'One million'),
+            (1, "One"),
+            (1000, "One thousand"),
+            (1000000, "One million"),
         ]
         html = """
         <div>
@@ -115,11 +135,11 @@ class RadioSelectTest(WidgetTest):
         <div><label><input type="radio" name="number" value="1000000"> One million</label></div>
         </div>
         """
-        self.check_html(self.widget(choices=choices), 'number', None, html=html)
+        self.check_html(self.widget(choices=choices), "number", None, html=html)
 
         choices = [
-            (datetime.time(0, 0), 'midnight'),
-            (datetime.time(12, 0), 'noon'),
+            (datetime.time(0, 0), "midnight"),
+            (datetime.time(12, 0), "noon"),
         ]
         html = """
         <div>
@@ -127,12 +147,16 @@ class RadioSelectTest(WidgetTest):
         <div><label><input type="radio" name="time" value="12:00:00"> noon</label></div>
         </div>
         """
-        self.check_html(self.widget(choices=choices), 'time', None, html=html)
+        self.check_html(self.widget(choices=choices), "time", None, html=html)
 
     def test_render_as_subwidget(self):
         """A RadioSelect as a subwidget of MultiWidget."""
-        choices = (('', '------'),) + self.beatles
-        self.check_html(MultiWidget([self.widget(choices=choices)]), 'beatle', ['J'], html="""
+        choices = (("", "------"),) + self.beatles
+        self.check_html(
+            MultiWidget([self.widget(choices=choices)]),
+            "beatle",
+            ["J"],
+            html="""
             <div>
             <div><label><input type="radio" name="beatle_0" value=""> ------</label></div>
             <div><label><input checked type="radio" name="beatle_0" value="J"> John</label></div>
@@ -140,4 +164,5 @@ class RadioSelectTest(WidgetTest):
             <div><label><input type="radio" name="beatle_0" value="G"> George</label></div>
             <div><label><input type="radio" name="beatle_0" value="R"> Ringo</label></div>
             </div>
-        """)
+        """,
+        )
diff --git a/tests/forms_tests/widget_tests/test_select.py b/tests/forms_tests/widget_tests/test_select.py
index dc2030e3ae..e78feeb110 100644
--- a/tests/forms_tests/widget_tests/test_select.py
+++ b/tests/forms_tests/widget_tests/test_select.py
@@ -10,87 +10,115 @@ from .base import WidgetTest
 
 class SelectTest(WidgetTest):
     widget = Select
-    nested_widget = Select(choices=(
-        ('outer1', 'Outer 1'),
-        ('Group "1"', (('inner1', 'Inner 1'), ('inner2', 'Inner 2'))),
-    ))
+    nested_widget = Select(
+        choices=(
+            ("outer1", "Outer 1"),
+            ('Group "1"', (("inner1", "Inner 1"), ("inner2", "Inner 2"))),
+        )
+    )
 
     def test_render(self):
-        self.check_html(self.widget(choices=self.beatles), 'beatle', 'J', html=(
-            """<select name="beatle">
+        self.check_html(
+            self.widget(choices=self.beatles),
+            "beatle",
+            "J",
+            html=(
+                """<select name="beatle">
             <option value="J" selected>John</option>
             <option value="P">Paul</option>
             <option value="G">George</option>
             <option value="R">Ringo</option>
             </select>"""
-        ))
+            ),
+        )
 
     def test_render_none(self):
         """
         If the value is None, none of the options are selected.
         """
-        self.check_html(self.widget(choices=self.beatles), 'beatle', None, html=(
-            """<select name="beatle">
+        self.check_html(
+            self.widget(choices=self.beatles),
+            "beatle",
+            None,
+            html=(
+                """<select name="beatle">
             <option value="J">John</option>
             <option value="P">Paul</option>
             <option value="G">George</option>
             <option value="R">Ringo</option>
             </select>"""
-        ))
+            ),
+        )
 
     def test_render_label_value(self):
         """
         If the value corresponds to a label (but not to an option value), none
         of the options are selected.
         """
-        self.check_html(self.widget(choices=self.beatles), 'beatle', 'John', html=(
-            """<select name="beatle">
+        self.check_html(
+            self.widget(choices=self.beatles),
+            "beatle",
+            "John",
+            html=(
+                """<select name="beatle">
             <option value="J">John</option>
             <option value="P">Paul</option>
             <option value="G">George</option>
             <option value="R">Ringo</option>
             </select>"""
-        ))
+            ),
+        )
 
     def test_render_selected(self):
         """
         Only one option can be selected (#8103).
         """
-        choices = [('0', '0'), ('1', '1'), ('2', '2'), ('3', '3'), ('0', 'extra')]
+        choices = [("0", "0"), ("1", "1"), ("2", "2"), ("3", "3"), ("0", "extra")]
 
-        self.check_html(self.widget(choices=choices), 'choices', '0', html=(
-            """<select name="choices">
+        self.check_html(
+            self.widget(choices=choices),
+            "choices",
+            "0",
+            html=(
+                """<select name="choices">
             <option value="0" selected>0</option>
             <option value="1">1</option>
             <option value="2">2</option>
             <option value="3">3</option>
             <option value="0">extra</option>
             </select>"""
-        ))
+            ),
+        )
 
     def test_constructor_attrs(self):
         """
         Select options shouldn't inherit the parent widget attrs.
         """
         widget = Select(
-            attrs={'class': 'super', 'id': 'super'},
+            attrs={"class": "super", "id": "super"},
             choices=[(1, 1), (2, 2), (3, 3)],
         )
-        self.check_html(widget, 'num', 2, html=(
-            """<select name="num" class="super" id="super">
+        self.check_html(
+            widget,
+            "num",
+            2,
+            html=(
+                """<select name="num" class="super" id="super">
               <option value="1">1</option>
               <option value="2" selected>2</option>
               <option value="3">3</option>
             </select>"""
-        ))
+            ),
+        )
 
     def test_compare_to_str(self):
         """
         The value is compared to its str().
         """
         self.check_html(
-            self.widget(choices=[('1', '1'), ('2', '2'), ('3', '3')]),
-            'num', 2,
+            self.widget(choices=[("1", "1"), ("2", "2"), ("3", "3")]),
+            "num",
+            2,
             html=(
                 """<select name="num">
                 <option value="1">1</option>
@@ -101,7 +129,8 @@ class SelectTest(WidgetTest):
         )
         self.check_html(
             self.widget(choices=[(1, 1), (2, 2), (3, 3)]),
-            'num', '2',
+            "num",
+            "2",
             html=(
                 """<select name="num">
                 <option value="1">1</option>
@@ -112,7 +141,8 @@ class SelectTest(WidgetTest):
         )
         self.check_html(
             self.widget(choices=[(1, 1), (2, 2), (3, 3)]),
-            'num', 2,
+            "num",
+            2,
             html=(
                 """<select name="num">
                 <option value="1">1</option>
@@ -124,56 +154,78 @@ class SelectTest(WidgetTest):
 
     def test_choices_constructor(self):
         widget = Select(choices=[(1, 1), (2, 2), (3, 3)])
-        self.check_html(widget, 'num', 2, html=(
-            """<select name="num">
+        self.check_html(
+            widget,
+            "num",
+            2,
+            html=(
+                """<select name="num">
             <option value="1">1</option>
             <option value="2" selected>2</option>
             <option value="3">3</option>
             </select>"""
-        ))
+            ),
+        )
 
     def test_choices_constructor_generator(self):
         """
         If choices is passed to the constructor and is a generator, it can be
         iterated over multiple times without getting consumed.
         """
+
         def get_choices():
             for i in range(5):
                 yield (i, i)
 
         widget = Select(choices=get_choices())
-        self.check_html(widget, 'num', 2, html=(
-            """<select name="num">
+        self.check_html(
+            widget,
+            "num",
+            2,
+            html=(
+                """<select name="num">
             <option value="0">0</option>
             <option value="1">1</option>
             <option value="2" selected>2</option>
             <option value="3">3</option>
             <option value="4">4</option>
             </select>"""
-        ))
-        self.check_html(widget, 'num', 3, html=(
-            """<select name="num">
+            ),
+        )
+        self.check_html(
+            widget,
+            "num",
+            3,
+            html=(
+                """<select name="num">
             <option value="0">0</option>
             <option value="1">1</option>
             <option value="2">2</option>
             <option value="3" selected>3</option>
             <option value="4">4</option>
             </select>"""
-        ))
+            ),
+        )
 
     def test_choices_escaping(self):
-        choices = (('bad', 'you & me'), ('good', mark_safe('you &gt; me')))
-        self.check_html(self.widget(choices=choices), 'escape', None, html=(
-            """<select name="escape">
+        choices = (("bad", "you & me"), ("good", mark_safe("you &gt; me")))
+        self.check_html(
+            self.widget(choices=choices),
+            "escape",
+            None,
+            html=(
+                """<select name="escape">
             <option value="bad">you &amp; me</option>
             <option value="good">you &gt; me</option>
             </select>"""
-        ))
+            ),
+        )
 
     def test_choices_unicode(self):
         self.check_html(
-            self.widget(choices=[('ŠĐĆŽćžšđ', 'ŠĐabcĆŽćžšđ'), ('ćžšđ', 'abcćžšđ')]),
-            'email', 'ŠĐĆŽćžšđ',
+            self.widget(choices=[("ŠĐĆŽćžšđ", "ŠĐabcĆŽćžšđ"), ("ćžšđ", "abcćžšđ")]),
+            "email",
+            "ŠĐĆŽćžšđ",
             html=(
                 """<select name="email">
                 <option value="\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111" selected>
@@ -188,44 +240,59 @@ class SelectTest(WidgetTest):
         """
         Choices can be nested one level in order to create HTML optgroups.
         """
-        self.check_html(self.nested_widget, 'nestchoice', None, html=(
-            """<select name="nestchoice">
+        self.check_html(
+            self.nested_widget,
+            "nestchoice",
+            None,
+            html=(
+                """<select name="nestchoice">
             <option value="outer1">Outer 1</option>
             <optgroup label="Group &quot;1&quot;">
             <option value="inner1">Inner 1</option>
             <option value="inner2">Inner 2</option>
             </optgroup>
             </select>"""
-        ))
+            ),
+        )
 
     def test_choices_select_outer(self):
-        self.check_html(self.nested_widget, 'nestchoice', 'outer1', html=(
-            """<select name="nestchoice">
+        self.check_html(
+            self.nested_widget,
+            "nestchoice",
+            "outer1",
+            html=(
+                """<select name="nestchoice">
             <option value="outer1" selected>Outer 1</option>
             <optgroup label="Group &quot;1&quot;">
             <option value="inner1">Inner 1</option>
             <option value="inner2">Inner 2</option>
             </optgroup>
             </select>"""
-        ))
+            ),
+        )
 
     def test_choices_select_inner(self):
-        self.check_html(self.nested_widget, 'nestchoice', 'inner1', html=(
-            """<select name="nestchoice">
+        self.check_html(
+            self.nested_widget,
+            "nestchoice",
+            "inner1",
+            html=(
+                """<select name="nestchoice">
             <option value="outer1">Outer 1</option>
             <optgroup label="Group &quot;1&quot;">
             <option value="inner1" selected>Inner 1</option>
             <option value="inner2">Inner 2</option>
             </optgroup>
             </select>"""
-        ))
+            ),
+        )
 
     @override_settings(USE_THOUSAND_SEPARATOR=True)
     def test_doesnt_localize_option_value(self):
         choices = [
-            (1, 'One'),
-            (1000, 'One thousand'),
-            (1000000, 'One million'),
+            (1, "One"),
+            (1000, "One thousand"),
+            (1000000, "One million"),
         ]
         html = """
         <select name="number">
@@ -234,11 +301,11 @@ class SelectTest(WidgetTest):
         <option value="1000000">One million</option>
         </select>
         """
-        self.check_html(self.widget(choices=choices), 'number', None, html=html)
+        self.check_html(self.widget(choices=choices), "number", None, html=html)
 
         choices = [
-            (datetime.time(0, 0), 'midnight'),
-            (datetime.time(12, 0), 'noon'),
+            (datetime.time(0, 0), "midnight"),
+            (datetime.time(12, 0), "noon"),
         ]
         html = """
         <select name="time">
@@ -246,118 +313,142 @@ class SelectTest(WidgetTest):
         <option value="12:00:00">noon</option>
         </select>
         """
-        self.check_html(self.widget(choices=choices), 'time', None, html=html)
+        self.check_html(self.widget(choices=choices), "time", None, html=html)
 
     def test_options(self):
-        options = list(self.widget(choices=self.beatles).options(
-            'name', ['J'], attrs={'class': 'super'},
-        ))
+        options = list(
+            self.widget(choices=self.beatles).options(
+                "name",
+                ["J"],
+                attrs={"class": "super"},
+            )
+        )
         self.assertEqual(len(options), 4)
-        self.assertEqual(options[0]['name'], 'name')
-        self.assertEqual(options[0]['value'], 'J')
-        self.assertEqual(options[0]['label'], 'John')
-        self.assertEqual(options[0]['index'], '0')
-        self.assertIs(options[0]['selected'], True)
+        self.assertEqual(options[0]["name"], "name")
+        self.assertEqual(options[0]["value"], "J")
+        self.assertEqual(options[0]["label"], "John")
+        self.assertEqual(options[0]["index"], "0")
+        self.assertIs(options[0]["selected"], True)
         # Template-related attributes
-        self.assertEqual(options[1]['name'], 'name')
-        self.assertEqual(options[1]['value'], 'P')
-        self.assertEqual(options[1]['label'], 'Paul')
-        self.assertEqual(options[1]['index'], '1')
-        self.assertIs(options[1]['selected'], False)
+        self.assertEqual(options[1]["name"], "name")
+        self.assertEqual(options[1]["value"], "P")
+        self.assertEqual(options[1]["label"], "Paul")
+        self.assertEqual(options[1]["index"], "1")
+        self.assertIs(options[1]["selected"], False)
 
     def test_optgroups(self):
         choices = [
-            ('Audio', [
-                ('vinyl', 'Vinyl'),
-                ('cd', 'CD'),
-            ]),
-            ('Video', [
-                ('vhs', 'VHS Tape'),
-                ('dvd', 'DVD'),
-            ]),
-            ('unknown', 'Unknown'),
+            (
+                "Audio",
+                [
+                    ("vinyl", "Vinyl"),
+                    ("cd", "CD"),
+                ],
+            ),
+            (
+                "Video",
+                [
+                    ("vhs", "VHS Tape"),
+                    ("dvd", "DVD"),
+                ],
+            ),
+            ("unknown", "Unknown"),
         ]
-        groups = list(self.widget(choices=choices).optgroups(
-            'name', ['vhs'], attrs={'class': 'super'},
-        ))
+        groups = list(
+            self.widget(choices=choices).optgroups(
+                "name",
+                ["vhs"],
+                attrs={"class": "super"},
+            )
+        )
         audio, video, unknown = groups
         label, options, index = audio
-        self.assertEqual(label, 'Audio')
+        self.assertEqual(label, "Audio")
         self.assertEqual(
             options,
-            [{
-                'value': 'vinyl',
-                'type': 'select',
-                'attrs': {},
-                'index': '0_0',
-                'label': 'Vinyl',
-                'template_name': 'django/forms/widgets/select_option.html',
-                'name': 'name',
-                'selected': False,
-                'wrap_label': True,
-            }, {
-                'value': 'cd',
-                'type': 'select',
-                'attrs': {},
-                'index': '0_1',
-                'label': 'CD',
-                'template_name': 'django/forms/widgets/select_option.html',
-                'name': 'name',
-                'selected': False,
-                'wrap_label': True,
-            }]
+            [
+                {
+                    "value": "vinyl",
+                    "type": "select",
+                    "attrs": {},
+                    "index": "0_0",
+                    "label": "Vinyl",
+                    "template_name": "django/forms/widgets/select_option.html",
+                    "name": "name",
+                    "selected": False,
+                    "wrap_label": True,
+                },
+                {
+                    "value": "cd",
+                    "type": "select",
+                    "attrs": {},
+                    "index": "0_1",
+                    "label": "CD",
+                    "template_name": "django/forms/widgets/select_option.html",
+                    "name": "name",
+                    "selected": False,
+                    "wrap_label": True,
+                },
+            ],
         )
         self.assertEqual(index, 0)
         label, options, index = video
-        self.assertEqual(label, 'Video')
+        self.assertEqual(label, "Video")
         self.assertEqual(
             options,
-            [{
-                'value': 'vhs',
-                'template_name': 'django/forms/widgets/select_option.html',
-                'label': 'VHS Tape',
-                'attrs': {'selected': True},
-                'index': '1_0',
-                'name': 'name',
-                'selected': True,
-                'type': 'select',
-                'wrap_label': True,
-            }, {
-                'value': 'dvd',
-                'template_name': 'django/forms/widgets/select_option.html',
-                'label': 'DVD',
-                'attrs': {},
-                'index': '1_1',
-                'name': 'name',
-                'selected': False,
-                'type': 'select',
-                'wrap_label': True,
-            }]
+            [
+                {
+                    "value": "vhs",
+                    "template_name": "django/forms/widgets/select_option.html",
+                    "label": "VHS Tape",
+                    "attrs": {"selected": True},
+                    "index": "1_0",
+                    "name": "name",
+                    "selected": True,
+                    "type": "select",
+                    "wrap_label": True,
+                },
+                {
+                    "value": "dvd",
+                    "template_name": "django/forms/widgets/select_option.html",
+                    "label": "DVD",
+                    "attrs": {},
+                    "index": "1_1",
+                    "name": "name",
+                    "selected": False,
+                    "type": "select",
+                    "wrap_label": True,
+                },
+            ],
         )
         self.assertEqual(index, 1)
         label, options, index = unknown
         self.assertIsNone(label)
         self.assertEqual(
             options,
-            [{
-                'value': 'unknown',
-                'selected': False,
-                'template_name': 'django/forms/widgets/select_option.html',
-                'label': 'Unknown',
-                'attrs': {},
-                'index': '2',
-                'name': 'name',
-                'type': 'select',
-                'wrap_label': True,
-            }]
+            [
+                {
+                    "value": "unknown",
+                    "selected": False,
+                    "template_name": "django/forms/widgets/select_option.html",
+                    "label": "Unknown",
+                    "attrs": {},
+                    "index": "2",
+                    "name": "name",
+                    "type": "select",
+                    "wrap_label": True,
+                }
+            ],
         )
         self.assertEqual(index, 2)
 
     def test_optgroups_integer_choices(self):
         """The option 'value' is the same type as what's in `choices`."""
-        groups = list(self.widget(choices=[[0, 'choice text']]).optgroups('name', ['vhs']))
+        groups = list(
+            self.widget(choices=[[0, "choice text"]]).optgroups("name", ["vhs"])
+        )
         label, options, index = groups[0]
-        self.assertEqual(options[0]['value'], 0)
+        self.assertEqual(options[0]["value"], 0)
 
     def test_deepcopy(self):
         """
@@ -372,19 +463,19 @@ class SelectTest(WidgetTest):
         self.assertIsNot(widget.attrs, obj.attrs)
 
     def test_doesnt_render_required_when_impossible_to_select_empty_field(self):
-        widget = self.widget(choices=[('J', 'John'), ('P', 'Paul')])
+        widget = self.widget(choices=[("J", "John"), ("P", "Paul")])
         self.assertIs(widget.use_required_attribute(initial=None), False)
 
     def test_renders_required_when_possible_to_select_empty_field_str(self):
-        widget = self.widget(choices=[('', 'select please'), ('P', 'Paul')])
+        widget = self.widget(choices=[("", "select please"), ("P", "Paul")])
         self.assertIs(widget.use_required_attribute(initial=None), True)
 
     def test_renders_required_when_possible_to_select_empty_field_list(self):
-        widget = self.widget(choices=[['', 'select please'], ['P', 'Paul']])
+        widget = self.widget(choices=[["", "select please"], ["P", "Paul"]])
         self.assertIs(widget.use_required_attribute(initial=None), True)
 
     def test_renders_required_when_possible_to_select_empty_field_none(self):
-        widget = self.widget(choices=[(None, 'select please'), ('P', 'Paul')])
+        widget = self.widget(choices=[(None, "select please"), ("P", "Paul")])
         self.assertIs(widget.use_required_attribute(initial=None), True)
 
     def test_doesnt_render_required_when_no_choices_are_available(self):
diff --git a/tests/forms_tests/widget_tests/test_selectdatewidget.py b/tests/forms_tests/widget_tests/test_selectdatewidget.py
index 6a922e4e71..de0c35cd5b 100644
--- a/tests/forms_tests/widget_tests/test_selectdatewidget.py
+++ b/tests/forms_tests/widget_tests/test_selectdatewidget.py
@@ -12,12 +12,27 @@ from .base import WidgetTest
 class SelectDateWidgetTest(WidgetTest):
     maxDiff = None
     widget = SelectDateWidget(
-        years=('2007', '2008', '2009', '2010', '2011', '2012', '2013', '2014', '2015', '2016'),
+        years=(
+            "2007",
+            "2008",
+            "2009",
+            "2010",
+            "2011",
+            "2012",
+            "2013",
+            "2014",
+            "2015",
+            "2016",
+        ),
     )
 
     def test_render_empty(self):
-        self.check_html(self.widget, 'mydate', '', html=(
-            """
+        self.check_html(
+            self.widget,
+            "mydate",
+            "",
+            html=(
+                """
             <select name="mydate_month" id="id_mydate_month">
                 <option selected value="">---</option>
                 <option value="1">January</option>
@@ -83,20 +98,25 @@ class SelectDateWidgetTest(WidgetTest):
                 <option value="2016">2016</option>
             </select>
             """
-        ))
+            ),
+        )
 
     def test_render_none(self):
         """
         Rendering the None or '' values should yield the same output.
         """
         self.assertHTMLEqual(
-            self.widget.render('mydate', None),
-            self.widget.render('mydate', ''),
+            self.widget.render("mydate", None),
+            self.widget.render("mydate", ""),
         )
 
     def test_render_string(self):
-        self.check_html(self.widget, 'mydate', '2010-04-15', html=(
-            """
+        self.check_html(
+            self.widget,
+            "mydate",
+            "2010-04-15",
+            html=(
+                """
             <select name="mydate_month" id="id_mydate_month">
                 <option value="">---</option>
                 <option value="1">January</option>
@@ -162,20 +182,25 @@ class SelectDateWidgetTest(WidgetTest):
                 <option value="2016">2016</option>
             </select>
             """
-        ))
+            ),
+        )
 
     def test_render_datetime(self):
         self.assertHTMLEqual(
-            self.widget.render('mydate', date(2010, 4, 15)),
-            self.widget.render('mydate', '2010-04-15'),
+            self.widget.render("mydate", date(2010, 4, 15)),
+            self.widget.render("mydate", "2010-04-15"),
         )
 
     def test_render_invalid_date(self):
         """
         Invalid dates should still render the failed date.
         """
-        self.check_html(self.widget, 'mydate', '2010-02-31', html=(
-            """
+        self.check_html(
+            self.widget,
+            "mydate",
+            "2010-02-31",
+            html=(
+                """
             <select name="mydate_month" id="id_mydate_month">
                 <option value="">---</option>
                 <option value="1">January</option>
@@ -241,12 +266,17 @@ class SelectDateWidgetTest(WidgetTest):
                 <option value="2016">2016</option>
             </select>
             """
-        ))
+            ),
+        )
 
     def test_custom_months(self):
-        widget = SelectDateWidget(months=MONTHS_AP, years=('2013',))
-        self.check_html(widget, 'mydate', '', html=(
-            """
+        widget = SelectDateWidget(months=MONTHS_AP, years=("2013",))
+        self.check_html(
+            widget,
+            "mydate",
+            "",
+            html=(
+                """
             <select name="mydate_month" id="id_mydate_month">
                 <option selected value="">---</option>
                 <option value="1">Jan.</option>
@@ -303,7 +333,8 @@ class SelectDateWidgetTest(WidgetTest):
                 <option value="2013">2013</option>
             </select>
             """
-        ))
+            ),
+        )
 
     def test_selectdate_required(self):
         class GetNotRequiredDate(Form):
@@ -312,20 +343,26 @@ class SelectDateWidgetTest(WidgetTest):
         class GetRequiredDate(Form):
             mydate = DateField(widget=SelectDateWidget, required=True)
 
-        self.assertFalse(GetNotRequiredDate().fields['mydate'].widget.is_required)
-        self.assertTrue(GetRequiredDate().fields['mydate'].widget.is_required)
+        self.assertFalse(GetNotRequiredDate().fields["mydate"].widget.is_required)
+        self.assertTrue(GetRequiredDate().fields["mydate"].widget.is_required)
 
     def test_selectdate_empty_label(self):
-        w = SelectDateWidget(years=('2014',), empty_label='empty_label')
+        w = SelectDateWidget(years=("2014",), empty_label="empty_label")
 
         # Rendering the default state with empty_label set as string.
-        self.assertInHTML('<option selected value="">empty_label</option>', w.render('mydate', ''), count=3)
+        self.assertInHTML(
+            '<option selected value="">empty_label</option>',
+            w.render("mydate", ""),
+            count=3,
+        )
 
-        w = SelectDateWidget(years=('2014',), empty_label=('empty_year', 'empty_month', 'empty_day'))
+        w = SelectDateWidget(
+            years=("2014",), empty_label=("empty_year", "empty_month", "empty_day")
+        )
 
         # Rendering the default state with empty_label tuple.
         self.assertHTMLEqual(
-            w.render('mydate', ''),
+            w.render("mydate", ""),
             """
             <select name="mydate_month" id="id_mydate_month">
                 <option selected value="">empty_month</option>
@@ -385,21 +422,36 @@ class SelectDateWidgetTest(WidgetTest):
             """,
         )
 
-        with self.assertRaisesMessage(ValueError, 'empty_label list/tuple must have 3 elements.'):
-            SelectDateWidget(years=('2014',), empty_label=('not enough', 'values'))
+        with self.assertRaisesMessage(
+            ValueError, "empty_label list/tuple must have 3 elements."
+        ):
+            SelectDateWidget(years=("2014",), empty_label=("not enough", "values"))
 
-    @translation.override('nl')
+    @translation.override("nl")
     def test_l10n(self):
         w = SelectDateWidget(
-            years=('2007', '2008', '2009', '2010', '2011', '2012', '2013', '2014', '2015', '2016')
+            years=(
+                "2007",
+                "2008",
+                "2009",
+                "2010",
+                "2011",
+                "2012",
+                "2013",
+                "2014",
+                "2015",
+                "2016",
+            )
         )
         self.assertEqual(
-            w.value_from_datadict({'date_year': '2010', 'date_month': '8', 'date_day': '13'}, {}, 'date'),
-            '13-08-2010',
+            w.value_from_datadict(
+                {"date_year": "2010", "date_month": "8", "date_day": "13"}, {}, "date"
+            ),
+            "13-08-2010",
         )
 
         self.assertHTMLEqual(
-            w.render('date', '13-08-2010'),
+            w.render("date", "13-08-2010"),
             """
             <select name="date_day" id="id_date_day">
                 <option value="">---</option>
@@ -469,20 +521,24 @@ class SelectDateWidgetTest(WidgetTest):
         )
 
         # Even with an invalid date, the widget should reflect the entered value (#17401).
-        self.assertEqual(w.render('mydate', '2010-02-30').count('selected'), 3)
+        self.assertEqual(w.render("mydate", "2010-02-30").count("selected"), 3)
 
         # Years before 1900 should work.
-        w = SelectDateWidget(years=('1899',))
+        w = SelectDateWidget(years=("1899",))
         self.assertEqual(
-            w.value_from_datadict({'date_year': '1899', 'date_month': '8', 'date_day': '13'}, {}, 'date'),
-            '13-08-1899',
+            w.value_from_datadict(
+                {"date_year": "1899", "date_month": "8", "date_day": "13"}, {}, "date"
+            ),
+            "13-08-1899",
         )
         # And years before 1000 (demonstrating the need for
         # sanitize_strftime_format).
-        w = SelectDateWidget(years=('0001',))
+        w = SelectDateWidget(years=("0001",))
         self.assertEqual(
-            w.value_from_datadict({'date_year': '0001', 'date_month': '8', 'date_day': '13'}, {}, 'date'),
-            '13-08-0001',
+            w.value_from_datadict(
+                {"date_year": "0001", "date_month": "8", "date_day": "13"}, {}, "date"
+            ),
+            "13-08-0001",
         )
 
     # RemovedInDjango50Warning: When the deprecation ends, remove
@@ -490,77 +546,110 @@ class SelectDateWidgetTest(WidgetTest):
     # format-related settings will take precedence over locale-dictated
     # formats.
     @ignore_warnings(category=RemovedInDjango50Warning)
-    @override_settings(USE_L10N=False, DATE_INPUT_FORMATS=['%d.%m.%Y'])
+    @override_settings(USE_L10N=False, DATE_INPUT_FORMATS=["%d.%m.%Y"])
     def test_custom_input_format(self):
-        w = SelectDateWidget(years=('0001', '1899', '2009', '2010'))
+        w = SelectDateWidget(years=("0001", "1899", "2009", "2010"))
         for values, expected_value in (
-            (('0001', '8', '13'), '13.08.0001'),
-            (('1899', '7', '11'), '11.07.1899'),
-            (('2009', '3', '7'), '07.03.2009'),
+            (("0001", "8", "13"), "13.08.0001"),
+            (("1899", "7", "11"), "11.07.1899"),
+            (("2009", "3", "7"), "07.03.2009"),
         ):
             with self.subTest(values=values):
                 data = {
-                    'field_%s' % field: value
-                    for field, value in zip(('year', 'month', 'day'), values)
+                    "field_%s" % field: value
+                    for field, value in zip(("year", "month", "day"), values)
                 }
-                self.assertEqual(w.value_from_datadict(data, {}, 'field'), expected_value)
+                self.assertEqual(
+                    w.value_from_datadict(data, {}, "field"), expected_value
+                )
                 expected_dict = {
                     field: int(value)
-                    for field, value in zip(('year', 'month', 'day'), values)
+                    for field, value in zip(("year", "month", "day"), values)
                 }
                 self.assertEqual(w.format_value(expected_value), expected_dict)
 
     def test_format_value(self):
         valid_formats = [
-            '2000-1-1', '2000-10-15', '2000-01-01',
-            '2000-01-0', '2000-0-01', '2000-0-0',
-            '0-01-01', '0-01-0', '0-0-01', '0-0-0',
+            "2000-1-1",
+            "2000-10-15",
+            "2000-01-01",
+            "2000-01-0",
+            "2000-0-01",
+            "2000-0-0",
+            "0-01-01",
+            "0-01-0",
+            "0-0-01",
+            "0-0-0",
         ]
         for value in valid_formats:
-            year, month, day = (int(x) or '' for x in value.split('-'))
+            year, month, day = (int(x) or "" for x in value.split("-"))
             with self.subTest(value=value):
-                self.assertEqual(self.widget.format_value(value), {'day': day, 'month': month, 'year': year})
+                self.assertEqual(
+                    self.widget.format_value(value),
+                    {"day": day, "month": month, "year": year},
+                )
 
         invalid_formats = [
-            '2000-01-001', '2000-001-01', '2-01-01', '20-01-01', '200-01-01',
-            '20000-01-01',
+            "2000-01-001",
+            "2000-001-01",
+            "2-01-01",
+            "20-01-01",
+            "200-01-01",
+            "20000-01-01",
         ]
         for value in invalid_formats:
             with self.subTest(value=value):
-                self.assertEqual(self.widget.format_value(value), {'day': None, 'month': None, 'year': None})
+                self.assertEqual(
+                    self.widget.format_value(value),
+                    {"day": None, "month": None, "year": None},
+                )
 
     def test_value_from_datadict(self):
         tests = [
-            (('2000', '12', '1'), '2000-12-01'),
-            (('', '12', '1'), '0-12-1'),
-            (('2000', '', '1'), '2000-0-1'),
-            (('2000', '12', ''), '2000-12-0'),
-            (('', '', '', ''), None),
-            ((None, '12', '1'), None),
-            (('2000', None, '1'), None),
-            (('2000', '12', None), None),
+            (("2000", "12", "1"), "2000-12-01"),
+            (("", "12", "1"), "0-12-1"),
+            (("2000", "", "1"), "2000-0-1"),
+            (("2000", "12", ""), "2000-12-0"),
+            (("", "", "", ""), None),
+            ((None, "12", "1"), None),
+            (("2000", None, "1"), None),
+            (("2000", "12", None), None),
         ]
         for values, expected in tests:
             with self.subTest(values=values):
                 data = {}
-                for field_name, value in zip(('year', 'month', 'day'), values):
+                for field_name, value in zip(("year", "month", "day"), values):
                     if value is not None:
-                        data['field_%s' % field_name] = value
-                self.assertEqual(self.widget.value_from_datadict(data, {}, 'field'), expected)
+                        data["field_%s" % field_name] = value
+                self.assertEqual(
+                    self.widget.value_from_datadict(data, {}, "field"), expected
+                )
 
     def test_value_omitted_from_data(self):
-        self.assertIs(self.widget.value_omitted_from_data({}, {}, 'field'), True)
-        self.assertIs(self.widget.value_omitted_from_data({'field_month': '12'}, {}, 'field'), False)
-        self.assertIs(self.widget.value_omitted_from_data({'field_year': '2000'}, {}, 'field'), False)
-        self.assertIs(self.widget.value_omitted_from_data({'field_day': '1'}, {}, 'field'), False)
-        data = {'field_day': '1', 'field_month': '12', 'field_year': '2000'}
-        self.assertIs(self.widget.value_omitted_from_data(data, {}, 'field'), False)
+        self.assertIs(self.widget.value_omitted_from_data({}, {}, "field"), True)
+        self.assertIs(
+            self.widget.value_omitted_from_data({"field_month": "12"}, {}, "field"),
+            False,
+        )
+        self.assertIs(
+            self.widget.value_omitted_from_data({"field_year": "2000"}, {}, "field"),
+            False,
+        )
+        self.assertIs(
+            self.widget.value_omitted_from_data({"field_day": "1"}, {}, "field"), False
+        )
+        data = {"field_day": "1", "field_month": "12", "field_year": "2000"}
+        self.assertIs(self.widget.value_omitted_from_data(data, {}, "field"), False)
 
     @override_settings(USE_THOUSAND_SEPARATOR=True)
     def test_years_rendered_without_separator(self):
         widget = SelectDateWidget(years=(2007,))
-        self.check_html(widget, 'mydate', '', html=(
-            """
+        self.check_html(
+            widget,
+            "mydate",
+            "",
+            html=(
+                """
             <select name="mydate_month" id="id_mydate_month">
                 <option selected value="">---</option>
                 <option value="1">January</option>
@@ -615,4 +704,5 @@ class SelectDateWidgetTest(WidgetTest):
                 <option value="2007">2007</option>
             </select>
             """
-        ))
+            ),
+        )
diff --git a/tests/forms_tests/widget_tests/test_selectmultiple.py b/tests/forms_tests/widget_tests/test_selectmultiple.py
index eb144ba4b3..99b53521e7 100644
--- a/tests/forms_tests/widget_tests/test_selectmultiple.py
+++ b/tests/forms_tests/widget_tests/test_selectmultiple.py
@@ -5,134 +5,188 @@ from .base import WidgetTest
 
 class SelectMultipleTest(WidgetTest):
     widget = SelectMultiple
-    numeric_choices = (('0', '0'), ('1', '1'), ('2', '2'), ('3', '3'), ('0', 'extra'))
+    numeric_choices = (("0", "0"), ("1", "1"), ("2", "2"), ("3", "3"), ("0", "extra"))
 
     def test_format_value(self):
         widget = self.widget(choices=self.numeric_choices)
         self.assertEqual(widget.format_value(None), [])
-        self.assertEqual(widget.format_value(''), [''])
-        self.assertEqual(widget.format_value([3, 0, 1]), ['3', '0', '1'])
+        self.assertEqual(widget.format_value(""), [""])
+        self.assertEqual(widget.format_value([3, 0, 1]), ["3", "0", "1"])
 
     def test_render_selected(self):
-        self.check_html(self.widget(choices=self.beatles), 'beatles', ['J'], html=(
-            """<select multiple name="beatles">
+        self.check_html(
+            self.widget(choices=self.beatles),
+            "beatles",
+            ["J"],
+            html=(
+                """<select multiple name="beatles">
             <option value="J" selected>John</option>
             <option value="P">Paul</option>
             <option value="G">George</option>
             <option value="R">Ringo</option>
             </select>"""
-        ))
+            ),
+        )
 
     def test_render_multiple_selected(self):
-        self.check_html(self.widget(choices=self.beatles), 'beatles', ['J', 'P'], html=(
-            """<select multiple name="beatles">
+        self.check_html(
+            self.widget(choices=self.beatles),
+            "beatles",
+            ["J", "P"],
+            html=(
+                """<select multiple name="beatles">
             <option value="J" selected>John</option>
             <option value="P" selected>Paul</option>
             <option value="G">George</option>
             <option value="R">Ringo</option>
             </select>"""
-        ))
+            ),
+        )
 
     def test_render_none(self):
         """
         If the value is None, none of the options are selected, even if the
         choices have an empty option.
         """
-        self.check_html(self.widget(choices=(('', 'Unknown'),) + self.beatles), 'beatles', None, html=(
-            """<select multiple name="beatles">
+        self.check_html(
+            self.widget(choices=(("", "Unknown"),) + self.beatles),
+            "beatles",
+            None,
+            html=(
+                """<select multiple name="beatles">
             <option value="">Unknown</option>
             <option value="J">John</option>
             <option value="P">Paul</option>
             <option value="G">George</option>
             <option value="R">Ringo</option>
             </select>"""
-        ))
+            ),
+        )
 
     def test_render_value_label(self):
         """
         If the value corresponds to a label (but not to an option value), none
         of the options are selected.
         """
-        self.check_html(self.widget(choices=self.beatles), 'beatles', ['John'], html=(
-            """<select multiple name="beatles">
+        self.check_html(
+            self.widget(choices=self.beatles),
+            "beatles",
+            ["John"],
+            html=(
+                """<select multiple name="beatles">
             <option value="J">John</option>
             <option value="P">Paul</option>
             <option value="G">George</option>
             <option value="R">Ringo</option>
             </select>"""
-        ))
+            ),
+        )
 
     def test_multiple_options_same_value(self):
         """
         Multiple options with the same value can be selected (#8103).
         """
-        self.check_html(self.widget(choices=self.numeric_choices), 'choices', ['0'], html=(
-            """<select multiple name="choices">
+        self.check_html(
+            self.widget(choices=self.numeric_choices),
+            "choices",
+            ["0"],
+            html=(
+                """<select multiple name="choices">
             <option value="0" selected>0</option>
             <option value="1">1</option>
             <option value="2">2</option>
             <option value="3">3</option>
             <option value="0" selected>extra</option>
             </select>"""
-        ))
+            ),
+        )
 
     def test_multiple_values_invalid(self):
         """
         If multiple values are given, but some of them are not valid, the valid
         ones are selected.
         """
-        self.check_html(self.widget(choices=self.beatles), 'beatles', ['J', 'G', 'foo'], html=(
-            """<select multiple name="beatles">
+        self.check_html(
+            self.widget(choices=self.beatles),
+            "beatles",
+            ["J", "G", "foo"],
+            html=(
+                """<select multiple name="beatles">
             <option value="J" selected>John</option>
             <option value="P">Paul</option>
             <option value="G" selected>George</option>
             <option value="R">Ringo</option>
             </select>"""
-        ))
+            ),
+        )
 
     def test_compare_string(self):
-        choices = [('1', '1'), ('2', '2'), ('3', '3')]
+        choices = [("1", "1"), ("2", "2"), ("3", "3")]
 
-        self.check_html(self.widget(choices=choices), 'nums', [2], html=(
-            """<select multiple name="nums">
+        self.check_html(
+            self.widget(choices=choices),
+            "nums",
+            [2],
+            html=(
+                """<select multiple name="nums">
             <option value="1">1</option>
             <option value="2" selected>2</option>
             <option value="3">3</option>
             </select>"""
-        ))
+            ),
+        )
 
-        self.check_html(self.widget(choices=choices), 'nums', ['2'], html=(
-            """<select multiple name="nums">
+        self.check_html(
+            self.widget(choices=choices),
+            "nums",
+            ["2"],
+            html=(
+                """<select multiple name="nums">
             <option value="1">1</option>
             <option value="2" selected>2</option>
             <option value="3">3</option>
             </select>"""
-        ))
+            ),
+        )
 
-        self.check_html(self.widget(choices=choices), 'nums', [2], html=(
-            """<select multiple name="nums">
+        self.check_html(
+            self.widget(choices=choices),
+            "nums",
+            [2],
+            html=(
+                """<select multiple name="nums">
             <option value="1">1</option>
             <option value="2" selected>2</option>
             <option value="3">3</option>
             </select>"""
-        ))
+            ),
+        )
 
     def test_optgroup_select_multiple(self):
-        widget = SelectMultiple(choices=(
-            ('outer1', 'Outer 1'),
-            ('Group "1"', (('inner1', 'Inner 1'), ('inner2', 'Inner 2'))),
-        ))
-        self.check_html(widget, 'nestchoice', ['outer1', 'inner2'], html=(
-            """<select multiple name="nestchoice">
+        widget = SelectMultiple(
+            choices=(
+                ("outer1", "Outer 1"),
+                ('Group "1"', (("inner1", "Inner 1"), ("inner2", "Inner 2"))),
+            )
+        )
+        self.check_html(
+            widget,
+            "nestchoice",
+            ["outer1", "inner2"],
+            html=(
+                """<select multiple name="nestchoice">
             <option value="outer1" selected>Outer 1</option>
             <optgroup label="Group &quot;1&quot;">
             <option value="inner1">Inner 1</option>
             <option value="inner2" selected>Inner 2</option>
             </optgroup>
             </select>"""
-        ))
+            ),
+        )
 
     def test_value_omitted_from_data(self):
         widget = self.widget(choices=self.beatles)
-        self.assertIs(widget.value_omitted_from_data({}, {}, 'field'), False)
-        self.assertIs(widget.value_omitted_from_data({'field': 'value'}, {}, 'field'), False)
+        self.assertIs(widget.value_omitted_from_data({}, {}, "field"), False)
+        self.assertIs(
+            widget.value_omitted_from_data({"field": "value"}, {}, "field"), False
+        )
diff --git a/tests/forms_tests/widget_tests/test_splitdatetimewidget.py b/tests/forms_tests/widget_tests/test_splitdatetimewidget.py
index ebb30da148..ca48505b85 100644
--- a/tests/forms_tests/widget_tests/test_splitdatetimewidget.py
+++ b/tests/forms_tests/widget_tests/test_splitdatetimewidget.py
@@ -9,45 +9,72 @@ class SplitDateTimeWidgetTest(WidgetTest):
     widget = SplitDateTimeWidget()
 
     def test_render_empty(self):
-        self.check_html(self.widget, 'date', '', html=(
-            '<input type="text" name="date_0"><input type="text" name="date_1">'
-        ))
+        self.check_html(
+            self.widget,
+            "date",
+            "",
+            html=('<input type="text" name="date_0"><input type="text" name="date_1">'),
+        )
 
     def test_render_none(self):
-        self.check_html(self.widget, 'date', None, html=(
-            '<input type="text" name="date_0"><input type="text" name="date_1">'
-        ))
+        self.check_html(
+            self.widget,
+            "date",
+            None,
+            html=('<input type="text" name="date_0"><input type="text" name="date_1">'),
+        )
 
     def test_render_datetime(self):
-        self.check_html(self.widget, 'date', datetime(2006, 1, 10, 7, 30), html=(
-            '<input type="text" name="date_0" value="2006-01-10">'
-            '<input type="text" name="date_1" value="07:30:00">'
-        ))
+        self.check_html(
+            self.widget,
+            "date",
+            datetime(2006, 1, 10, 7, 30),
+            html=(
+                '<input type="text" name="date_0" value="2006-01-10">'
+                '<input type="text" name="date_1" value="07:30:00">'
+            ),
+        )
 
     def test_render_date_and_time(self):
-        self.check_html(self.widget, 'date', [date(2006, 1, 10), time(7, 30)], html=(
-            '<input type="text" name="date_0" value="2006-01-10">'
-            '<input type="text" name="date_1" value="07:30:00">'
-        ))
+        self.check_html(
+            self.widget,
+            "date",
+            [date(2006, 1, 10), time(7, 30)],
+            html=(
+                '<input type="text" name="date_0" value="2006-01-10">'
+                '<input type="text" name="date_1" value="07:30:00">'
+            ),
+        )
 
     def test_constructor_attrs(self):
-        widget = SplitDateTimeWidget(attrs={'class': 'pretty'})
-        self.check_html(widget, 'date', datetime(2006, 1, 10, 7, 30), html=(
-            '<input type="text" class="pretty" value="2006-01-10" name="date_0">'
-            '<input type="text" class="pretty" value="07:30:00" name="date_1">'
-        ))
+        widget = SplitDateTimeWidget(attrs={"class": "pretty"})
+        self.check_html(
+            widget,
+            "date",
+            datetime(2006, 1, 10, 7, 30),
+            html=(
+                '<input type="text" class="pretty" value="2006-01-10" name="date_0">'
+                '<input type="text" class="pretty" value="07:30:00" name="date_1">'
+            ),
+        )
 
     def test_constructor_different_attrs(self):
         html = (
             '<input type="text" class="foo" value="2006-01-10" name="date_0">'
             '<input type="text" class="bar" value="07:30:00" name="date_1">'
         )
-        widget = SplitDateTimeWidget(date_attrs={'class': 'foo'}, time_attrs={'class': 'bar'})
-        self.check_html(widget, 'date', datetime(2006, 1, 10, 7, 30), html=html)
-        widget = SplitDateTimeWidget(date_attrs={'class': 'foo'}, attrs={'class': 'bar'})
-        self.check_html(widget, 'date', datetime(2006, 1, 10, 7, 30), html=html)
-        widget = SplitDateTimeWidget(time_attrs={'class': 'bar'}, attrs={'class': 'foo'})
-        self.check_html(widget, 'date', datetime(2006, 1, 10, 7, 30), html=html)
+        widget = SplitDateTimeWidget(
+            date_attrs={"class": "foo"}, time_attrs={"class": "bar"}
+        )
+        self.check_html(widget, "date", datetime(2006, 1, 10, 7, 30), html=html)
+        widget = SplitDateTimeWidget(
+            date_attrs={"class": "foo"}, attrs={"class": "bar"}
+        )
+        self.check_html(widget, "date", datetime(2006, 1, 10, 7, 30), html=html)
+        widget = SplitDateTimeWidget(
+            time_attrs={"class": "bar"}, attrs={"class": "foo"}
+        )
+        self.check_html(widget, "date", datetime(2006, 1, 10, 7, 30), html=html)
 
     def test_formatting(self):
         """
@@ -55,9 +82,15 @@ class SplitDateTimeWidgetTest(WidgetTest):
         displayed.
         """
         widget = SplitDateTimeWidget(
-            date_format='%d/%m/%Y', time_format='%H:%M',
+            date_format="%d/%m/%Y",
+            time_format="%H:%M",
+        )
+        self.check_html(
+            widget,
+            "date",
+            datetime(2006, 1, 10, 7, 30),
+            html=(
+                '<input type="text" name="date_0" value="10/01/2006">'
+                '<input type="text" name="date_1" value="07:30">'
+            ),
         )
-        self.check_html(widget, 'date', datetime(2006, 1, 10, 7, 30), html=(
-            '<input type="text" name="date_0" value="10/01/2006">'
-            '<input type="text" name="date_1" value="07:30">'
-        ))
diff --git a/tests/forms_tests/widget_tests/test_splithiddendatetimewidget.py b/tests/forms_tests/widget_tests/test_splithiddendatetimewidget.py
index c574eb6f7b..549f8c7754 100644
--- a/tests/forms_tests/widget_tests/test_splithiddendatetimewidget.py
+++ b/tests/forms_tests/widget_tests/test_splithiddendatetimewidget.py
@@ -10,43 +10,74 @@ class SplitHiddenDateTimeWidgetTest(WidgetTest):
     widget = SplitHiddenDateTimeWidget()
 
     def test_render_empty(self):
-        self.check_html(self.widget, 'date', '', html=(
-            '<input type="hidden" name="date_0"><input type="hidden" name="date_1">'
-        ))
+        self.check_html(
+            self.widget,
+            "date",
+            "",
+            html=(
+                '<input type="hidden" name="date_0"><input type="hidden" name="date_1">'
+            ),
+        )
 
     def test_render_value(self):
         d = datetime(2007, 9, 17, 12, 51, 34, 482548)
-        self.check_html(self.widget, 'date', d, html=(
-            '<input type="hidden" name="date_0" value="2007-09-17">'
-            '<input type="hidden" name="date_1" value="12:51:34">'
-        ))
-        self.check_html(self.widget, 'date', datetime(2007, 9, 17, 12, 51, 34), html=(
-            '<input type="hidden" name="date_0" value="2007-09-17">'
-            '<input type="hidden" name="date_1" value="12:51:34">'
-        ))
-        self.check_html(self.widget, 'date', datetime(2007, 9, 17, 12, 51), html=(
-            '<input type="hidden" name="date_0" value="2007-09-17">'
-            '<input type="hidden" name="date_1" value="12:51:00">'
-        ))
+        self.check_html(
+            self.widget,
+            "date",
+            d,
+            html=(
+                '<input type="hidden" name="date_0" value="2007-09-17">'
+                '<input type="hidden" name="date_1" value="12:51:34">'
+            ),
+        )
+        self.check_html(
+            self.widget,
+            "date",
+            datetime(2007, 9, 17, 12, 51, 34),
+            html=(
+                '<input type="hidden" name="date_0" value="2007-09-17">'
+                '<input type="hidden" name="date_1" value="12:51:34">'
+            ),
+        )
+        self.check_html(
+            self.widget,
+            "date",
+            datetime(2007, 9, 17, 12, 51),
+            html=(
+                '<input type="hidden" name="date_0" value="2007-09-17">'
+                '<input type="hidden" name="date_1" value="12:51:00">'
+            ),
+        )
 
-    @translation.override('de-at')
+    @translation.override("de-at")
     def test_l10n(self):
         d = datetime(2007, 9, 17, 12, 51)
-        self.check_html(self.widget, 'date', d, html=(
-            """
+        self.check_html(
+            self.widget,
+            "date",
+            d,
+            html=(
+                """
             <input type="hidden" name="date_0" value="17.09.2007">
             <input type="hidden" name="date_1" value="12:51:00">
             """
-        ))
+            ),
+        )
 
     def test_constructor_different_attrs(self):
         html = (
             '<input type="hidden" class="foo" value="2006-01-10" name="date_0">'
             '<input type="hidden" class="bar" value="07:30:00" name="date_1">'
         )
-        widget = SplitHiddenDateTimeWidget(date_attrs={'class': 'foo'}, time_attrs={'class': 'bar'})
-        self.check_html(widget, 'date', datetime(2006, 1, 10, 7, 30), html=html)
-        widget = SplitHiddenDateTimeWidget(date_attrs={'class': 'foo'}, attrs={'class': 'bar'})
-        self.check_html(widget, 'date', datetime(2006, 1, 10, 7, 30), html=html)
-        widget = SplitHiddenDateTimeWidget(time_attrs={'class': 'bar'}, attrs={'class': 'foo'})
-        self.check_html(widget, 'date', datetime(2006, 1, 10, 7, 30), html=html)
+        widget = SplitHiddenDateTimeWidget(
+            date_attrs={"class": "foo"}, time_attrs={"class": "bar"}
+        )
+        self.check_html(widget, "date", datetime(2006, 1, 10, 7, 30), html=html)
+        widget = SplitHiddenDateTimeWidget(
+            date_attrs={"class": "foo"}, attrs={"class": "bar"}
+        )
+        self.check_html(widget, "date", datetime(2006, 1, 10, 7, 30), html=html)
+        widget = SplitHiddenDateTimeWidget(
+            time_attrs={"class": "bar"}, attrs={"class": "foo"}
+        )
+        self.check_html(widget, "date", datetime(2006, 1, 10, 7, 30), html=html)
diff --git a/tests/forms_tests/widget_tests/test_textarea.py b/tests/forms_tests/widget_tests/test_textarea.py
index 490848fab3..e92dfc51f4 100644
--- a/tests/forms_tests/widget_tests/test_textarea.py
+++ b/tests/forms_tests/widget_tests/test_textarea.py
@@ -8,27 +8,55 @@ class TextareaTest(WidgetTest):
     widget = Textarea()
 
     def test_render(self):
-        self.check_html(self.widget, 'msg', 'value', html=(
-            '<textarea rows="10" cols="40" name="msg">value</textarea>'
-        ))
+        self.check_html(
+            self.widget,
+            "msg",
+            "value",
+            html=('<textarea rows="10" cols="40" name="msg">value</textarea>'),
+        )
 
     def test_render_required(self):
         widget = Textarea()
         widget.is_required = True
-        self.check_html(widget, 'msg', 'value', html='<textarea rows="10" cols="40" name="msg">value</textarea>')
+        self.check_html(
+            widget,
+            "msg",
+            "value",
+            html='<textarea rows="10" cols="40" name="msg">value</textarea>',
+        )
 
     def test_render_empty(self):
-        self.check_html(self.widget, 'msg', '', html='<textarea rows="10" cols="40" name="msg"></textarea>')
+        self.check_html(
+            self.widget,
+            "msg",
+            "",
+            html='<textarea rows="10" cols="40" name="msg"></textarea>',
+        )
 
     def test_render_none(self):
-        self.check_html(self.widget, 'msg', None, html='<textarea rows="10" cols="40" name="msg"></textarea>')
+        self.check_html(
+            self.widget,
+            "msg",
+            None,
+            html='<textarea rows="10" cols="40" name="msg"></textarea>',
+        )
 
     def test_escaping(self):
-        self.check_html(self.widget, 'msg', 'some "quoted" & ampersanded value', html=(
-            '<textarea rows="10" cols="40" name="msg">some &quot;quoted&quot; &amp; ampersanded value</textarea>'
-        ))
+        self.check_html(
+            self.widget,
+            "msg",
+            'some "quoted" & ampersanded value',
+            html=(
+                '<textarea rows="10" cols="40" name="msg">some &quot;quoted&quot; &amp; ampersanded value</textarea>'
+            ),
+        )
 
     def test_mark_safe(self):
-        self.check_html(self.widget, 'msg', mark_safe('pre &quot;quoted&quot; value'), html=(
-            '<textarea rows="10" cols="40" name="msg">pre &quot;quoted&quot; value</textarea>'
-        ))
+        self.check_html(
+            self.widget,
+            "msg",
+            mark_safe("pre &quot;quoted&quot; value"),
+            html=(
+                '<textarea rows="10" cols="40" name="msg">pre &quot;quoted&quot; value</textarea>'
+            ),
+        )
diff --git a/tests/forms_tests/widget_tests/test_textinput.py b/tests/forms_tests/widget_tests/test_textinput.py
index 260e86f740..52ffabec65 100644
--- a/tests/forms_tests/widget_tests/test_textinput.py
+++ b/tests/forms_tests/widget_tests/test_textinput.py
@@ -8,43 +8,64 @@ class TextInputTest(WidgetTest):
     widget = TextInput()
 
     def test_render(self):
-        self.check_html(self.widget, 'email', '', html='<input type="text" name="email">')
+        self.check_html(
+            self.widget, "email", "", html='<input type="text" name="email">'
+        )
 
     def test_render_none(self):
-        self.check_html(self.widget, 'email', None, html='<input type="text" name="email">')
+        self.check_html(
+            self.widget, "email", None, html='<input type="text" name="email">'
+        )
 
     def test_render_value(self):
-        self.check_html(self.widget, 'email', 'test@example.com', html=(
-            '<input type="text" name="email" value="test@example.com">'
-        ))
+        self.check_html(
+            self.widget,
+            "email",
+            "test@example.com",
+            html=('<input type="text" name="email" value="test@example.com">'),
+        )
 
     def test_render_boolean(self):
         """
         Boolean values are rendered to their string forms ("True" and
         "False").
         """
-        self.check_html(self.widget, 'get_spam', False, html=(
-            '<input type="text" name="get_spam" value="False">'
-        ))
-        self.check_html(self.widget, 'get_spam', True, html=(
-            '<input type="text" name="get_spam" value="True">'
-        ))
+        self.check_html(
+            self.widget,
+            "get_spam",
+            False,
+            html=('<input type="text" name="get_spam" value="False">'),
+        )
+        self.check_html(
+            self.widget,
+            "get_spam",
+            True,
+            html=('<input type="text" name="get_spam" value="True">'),
+        )
 
     def test_render_quoted(self):
         self.check_html(
-            self.widget, 'email', 'some "quoted" & ampersanded value',
+            self.widget,
+            "email",
+            'some "quoted" & ampersanded value',
             html='<input type="text" name="email" value="some &quot;quoted&quot; &amp; ampersanded value">',
         )
 
     def test_render_custom_attrs(self):
         self.check_html(
-            self.widget, 'email', 'test@example.com', attrs={'class': 'fun'},
+            self.widget,
+            "email",
+            "test@example.com",
+            attrs={"class": "fun"},
             html='<input type="text" name="email" value="test@example.com" class="fun">',
         )
 
     def test_render_unicode(self):
         self.check_html(
-            self.widget, 'email', 'ŠĐĆŽćžšđ', attrs={'class': 'fun'},
+            self.widget,
+            "email",
+            "ŠĐĆŽćžšđ",
+            attrs={"class": "fun"},
             html=(
                 '<input type="text" name="email" '
                 'value="\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111" class="fun">'
@@ -52,10 +73,14 @@ class TextInputTest(WidgetTest):
         )
 
     def test_constructor_attrs(self):
-        widget = TextInput(attrs={'class': 'fun', 'type': 'email'})
-        self.check_html(widget, 'email', '', html='<input type="email" class="fun" name="email">')
+        widget = TextInput(attrs={"class": "fun", "type": "email"})
         self.check_html(
-            widget, 'email', 'foo@example.com',
+            widget, "email", "", html='<input type="email" class="fun" name="email">'
+        )
+        self.check_html(
+            widget,
+            "email",
+            "foo@example.com",
             html='<input type="email" class="fun" value="foo@example.com" name="email">',
         )
 
@@ -64,18 +89,26 @@ class TextInputTest(WidgetTest):
         `attrs` passed to render() get precedence over those passed to the
         constructor
         """
-        widget = TextInput(attrs={'class': 'pretty'})
+        widget = TextInput(attrs={"class": "pretty"})
         self.check_html(
-            widget, 'email', '', attrs={'class': 'special'},
+            widget,
+            "email",
+            "",
+            attrs={"class": "special"},
             html='<input type="text" class="special" name="email">',
         )
 
     def test_attrs_safestring(self):
-        widget = TextInput(attrs={'onBlur': mark_safe("function('foo')")})
-        self.check_html(widget, 'email', '', html='<input onBlur="function(\'foo\')" type="text" name="email">')
+        widget = TextInput(attrs={"onBlur": mark_safe("function('foo')")})
+        self.check_html(
+            widget,
+            "email",
+            "",
+            html='<input onBlur="function(\'foo\')" type="text" name="email">',
+        )
 
     def test_use_required_attribute(self):
         # Text inputs can safely trigger the browser validation.
         self.assertIs(self.widget.use_required_attribute(None), True)
-        self.assertIs(self.widget.use_required_attribute(''), True)
-        self.assertIs(self.widget.use_required_attribute('resume.txt'), True)
+        self.assertIs(self.widget.use_required_attribute(""), True)
+        self.assertIs(self.widget.use_required_attribute("resume.txt"), True)
diff --git a/tests/forms_tests/widget_tests/test_timeinput.py b/tests/forms_tests/widget_tests/test_timeinput.py
index 6060168eb3..6f56a07f5e 100644
--- a/tests/forms_tests/widget_tests/test_timeinput.py
+++ b/tests/forms_tests/widget_tests/test_timeinput.py
@@ -10,37 +10,60 @@ class TimeInputTest(WidgetTest):
     widget = TimeInput()
 
     def test_render_none(self):
-        self.check_html(self.widget, 'time', None, html='<input type="text" name="time">')
+        self.check_html(
+            self.widget, "time", None, html='<input type="text" name="time">'
+        )
 
     def test_render_value(self):
         """
         The microseconds are trimmed on display, by default.
         """
         t = time(12, 51, 34, 482548)
-        self.assertEqual(str(t), '12:51:34.482548')
-        self.check_html(self.widget, 'time', t, html='<input type="text" name="time" value="12:51:34">')
-        self.check_html(self.widget, 'time', time(12, 51, 34), html=(
-            '<input type="text" name="time" value="12:51:34">'
-        ))
-        self.check_html(self.widget, 'time', time(12, 51), html=(
-            '<input type="text" name="time" value="12:51:00">'
-        ))
+        self.assertEqual(str(t), "12:51:34.482548")
+        self.check_html(
+            self.widget,
+            "time",
+            t,
+            html='<input type="text" name="time" value="12:51:34">',
+        )
+        self.check_html(
+            self.widget,
+            "time",
+            time(12, 51, 34),
+            html=('<input type="text" name="time" value="12:51:34">'),
+        )
+        self.check_html(
+            self.widget,
+            "time",
+            time(12, 51),
+            html=('<input type="text" name="time" value="12:51:00">'),
+        )
 
     def test_string(self):
         """Initializing from a string value."""
-        self.check_html(self.widget, 'time', '13:12:11', html=(
-            '<input type="text" name="time" value="13:12:11">'
-        ))
+        self.check_html(
+            self.widget,
+            "time",
+            "13:12:11",
+            html=('<input type="text" name="time" value="13:12:11">'),
+        )
 
     def test_format(self):
         """
         Use 'format' to change the way a value is displayed.
         """
         t = time(12, 51, 34, 482548)
-        widget = TimeInput(format='%H:%M', attrs={'type': 'time'})
-        self.check_html(widget, 'time', t, html='<input type="time" name="time" value="12:51">')
+        widget = TimeInput(format="%H:%M", attrs={"type": "time"})
+        self.check_html(
+            widget, "time", t, html='<input type="time" name="time" value="12:51">'
+        )
 
-    @translation.override('de-at')
+    @translation.override("de-at")
     def test_l10n(self):
         t = time(12, 51, 34, 482548)
-        self.check_html(self.widget, 'time', t, html='<input type="text" name="time" value="12:51:34">')
+        self.check_html(
+            self.widget,
+            "time",
+            t,
+            html='<input type="text" name="time" value="12:51:34">',
+        )
diff --git a/tests/forms_tests/widget_tests/test_widget.py b/tests/forms_tests/widget_tests/test_widget.py
index 8cde388b8f..9e243570d7 100644
--- a/tests/forms_tests/widget_tests/test_widget.py
+++ b/tests/forms_tests/widget_tests/test_widget.py
@@ -5,22 +5,29 @@ from .base import WidgetTest
 
 
 class WidgetTests(WidgetTest):
-
     def test_format_value(self):
         widget = Widget()
         self.assertIsNone(widget.format_value(None))
-        self.assertIsNone(widget.format_value(''))
-        self.assertEqual(widget.format_value('español'), 'español')
-        self.assertEqual(widget.format_value(42.5), '42.5')
+        self.assertIsNone(widget.format_value(""))
+        self.assertEqual(widget.format_value("español"), "español")
+        self.assertEqual(widget.format_value(42.5), "42.5")
 
     def test_value_omitted_from_data(self):
         widget = Widget()
-        self.assertIs(widget.value_omitted_from_data({}, {}, 'field'), True)
-        self.assertIs(widget.value_omitted_from_data({'field': 'value'}, {}, 'field'), False)
+        self.assertIs(widget.value_omitted_from_data({}, {}, "field"), True)
+        self.assertIs(
+            widget.value_omitted_from_data({"field": "value"}, {}, "field"), False
+        )
 
     def test_no_trailing_newline_in_attrs(self):
-        self.check_html(Input(), 'name', 'value', strict=True, html='<input type="None" name="name" value="value">')
+        self.check_html(
+            Input(),
+            "name",
+            "value",
+            strict=True,
+            html='<input type="None" name="name" value="value">',
+        )
 
     def test_attr_false_not_rendered(self):
         html = '<input type="None" name="name" value="value">'
-        self.check_html(Input(), 'name', 'value', html=html, attrs={'readonly': False})
+        self.check_html(Input(), "name", "value", html=html, attrs={"readonly": False})