Refs #33476 -- Reformatted code with Black.

29 files changed, 1320 insertions, 1005 deletions

diff --git a/tests/forms_tests/field_tests/__init__.py b/tests/forms_tests/field_tests/__init__.py
index 4aae30282b..94b2a91242 100644
--- a/tests/forms_tests/field_tests/__init__.py
+++ b/tests/forms_tests/field_tests/__init__.py
@@ -2,8 +2,8 @@ from django import forms
 
 
 class FormFieldAssertionsMixin:
-
     def assertWidgetRendersTo(self, field, to):
         class Form(forms.Form):
             f = field
-        self.assertHTMLEqual(str(Form()['f']), to)
+
+        self.assertHTMLEqual(str(Form()["f"]), to)
diff --git a/tests/forms_tests/field_tests/test_base.py b/tests/forms_tests/field_tests/test_base.py
index 4ddbea3414..201e05e47e 100644
--- a/tests/forms_tests/field_tests/test_base.py
+++ b/tests/forms_tests/field_tests/test_base.py
@@ -3,7 +3,6 @@ from django.test import SimpleTestCase
 
 
 class BasicFieldsTests(SimpleTestCase):
-
     def test_field_sets_widget_is_required(self):
         self.assertTrue(Field(required=True).widget.is_required)
         self.assertFalse(Field(required=False).widget.is_required)
@@ -23,20 +22,20 @@ class BasicFieldsTests(SimpleTestCase):
 
     def test_field_deepcopies_widget_instance(self):
         class CustomChoiceField(ChoiceField):
-            widget = Select(attrs={'class': 'my-custom-class'})
+            widget = Select(attrs={"class": "my-custom-class"})
 
         class TestForm(Form):
             field1 = CustomChoiceField(choices=[])
             field2 = CustomChoiceField(choices=[])
 
         f = TestForm()
-        f.fields['field1'].choices = [('1', '1')]
-        f.fields['field2'].choices = [('2', '2')]
-        self.assertEqual(f.fields['field1'].widget.choices, [('1', '1')])
-        self.assertEqual(f.fields['field2'].widget.choices, [('2', '2')])
+        f.fields["field1"].choices = [("1", "1")]
+        f.fields["field2"].choices = [("2", "2")]
+        self.assertEqual(f.fields["field1"].widget.choices, [("1", "1")])
+        self.assertEqual(f.fields["field2"].widget.choices, [("2", "2")])
 
 
 class DisabledFieldTests(SimpleTestCase):
     def test_disabled_field_has_changed_always_false(self):
         disabled_field = Field(disabled=True)
-        self.assertFalse(disabled_field.has_changed('x', 'y'))
+        self.assertFalse(disabled_field.has_changed("x", "y"))
diff --git a/tests/forms_tests/field_tests/test_booleanfield.py b/tests/forms_tests/field_tests/test_booleanfield.py
index b0153e9e0b..560a0f473b 100644
--- a/tests/forms_tests/field_tests/test_booleanfield.py
+++ b/tests/forms_tests/field_tests/test_booleanfield.py
@@ -6,11 +6,10 @@ from django.test import SimpleTestCase
 
 
 class BooleanFieldTest(SimpleTestCase):
-
     def test_booleanfield_clean_1(self):
         f = BooleanField()
         with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
-            f.clean('')
+            f.clean("")
         with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
             f.clean(None)
         self.assertTrue(f.clean(True))
@@ -19,25 +18,25 @@ class BooleanFieldTest(SimpleTestCase):
         self.assertTrue(f.clean(1))
         with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
             f.clean(0)
-        self.assertTrue(f.clean('Django rocks'))
-        self.assertTrue(f.clean('True'))
+        self.assertTrue(f.clean("Django rocks"))
+        self.assertTrue(f.clean("True"))
         with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
-            f.clean('False')
+            f.clean("False")
 
     def test_booleanfield_clean_2(self):
         f = BooleanField(required=False)
-        self.assertIs(f.clean(''), False)
+        self.assertIs(f.clean(""), False)
         self.assertIs(f.clean(None), False)
         self.assertIs(f.clean(True), True)
         self.assertIs(f.clean(False), False)
         self.assertIs(f.clean(1), True)
         self.assertIs(f.clean(0), False)
-        self.assertIs(f.clean('1'), True)
-        self.assertIs(f.clean('0'), False)
-        self.assertIs(f.clean('Django rocks'), True)
-        self.assertIs(f.clean('False'), False)
-        self.assertIs(f.clean('false'), False)
-        self.assertIs(f.clean('FaLsE'), False)
+        self.assertIs(f.clean("1"), True)
+        self.assertIs(f.clean("0"), False)
+        self.assertIs(f.clean("Django rocks"), True)
+        self.assertIs(f.clean("False"), False)
+        self.assertIs(f.clean("false"), False)
+        self.assertIs(f.clean("FaLsE"), False)
 
     def test_boolean_picklable(self):
         self.assertIsInstance(pickle.loads(pickle.dumps(BooleanField())), BooleanField)
@@ -45,20 +44,20 @@ class BooleanFieldTest(SimpleTestCase):
     def test_booleanfield_changed(self):
         f = BooleanField()
         self.assertFalse(f.has_changed(None, None))
-        self.assertFalse(f.has_changed(None, ''))
-        self.assertFalse(f.has_changed('', None))
-        self.assertFalse(f.has_changed('', ''))
-        self.assertTrue(f.has_changed(False, 'on'))
-        self.assertFalse(f.has_changed(True, 'on'))
-        self.assertTrue(f.has_changed(True, ''))
+        self.assertFalse(f.has_changed(None, ""))
+        self.assertFalse(f.has_changed("", None))
+        self.assertFalse(f.has_changed("", ""))
+        self.assertTrue(f.has_changed(False, "on"))
+        self.assertFalse(f.has_changed(True, "on"))
+        self.assertTrue(f.has_changed(True, ""))
         # Initial value may have mutated to a string due to show_hidden_initial (#19537)
-        self.assertTrue(f.has_changed('False', 'on'))
+        self.assertTrue(f.has_changed("False", "on"))
         # HiddenInput widget sends string values for boolean but doesn't clean them in value_from_datadict
-        self.assertFalse(f.has_changed(False, 'False'))
-        self.assertFalse(f.has_changed(True, 'True'))
-        self.assertTrue(f.has_changed(False, 'True'))
-        self.assertTrue(f.has_changed(True, 'False'))
+        self.assertFalse(f.has_changed(False, "False"))
+        self.assertFalse(f.has_changed(True, "True"))
+        self.assertTrue(f.has_changed(False, "True"))
+        self.assertTrue(f.has_changed(True, "False"))
 
     def test_disabled_has_changed(self):
         f = BooleanField(disabled=True)
-        self.assertIs(f.has_changed('True', 'False'), False)
+        self.assertIs(f.has_changed("True", "False"), False)
diff --git a/tests/forms_tests/field_tests/test_charfield.py b/tests/forms_tests/field_tests/test_charfield.py
index 352761deec..2c3f9b7ebe 100644
--- a/tests/forms_tests/field_tests/test_charfield.py
+++ b/tests/forms_tests/field_tests/test_charfield.py
@@ -1,66 +1,63 @@
 from django.core.exceptions import ValidationError
-from django.forms import (
-    CharField, HiddenInput, PasswordInput, Textarea, TextInput,
-)
+from django.forms import CharField, HiddenInput, PasswordInput, Textarea, TextInput
 from django.test import SimpleTestCase
 
 from . import FormFieldAssertionsMixin
 
 
 class CharFieldTest(FormFieldAssertionsMixin, SimpleTestCase):
-
     def test_charfield_1(self):
         f = CharField()
-        self.assertEqual('1', f.clean(1))
-        self.assertEqual('hello', f.clean('hello'))
+        self.assertEqual("1", f.clean(1))
+        self.assertEqual("hello", f.clean("hello"))
         with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
             f.clean(None)
         with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
-            f.clean('')
-        self.assertEqual('[1, 2, 3]', f.clean([1, 2, 3]))
+            f.clean("")
+        self.assertEqual("[1, 2, 3]", f.clean([1, 2, 3]))
         self.assertIsNone(f.max_length)
         self.assertIsNone(f.min_length)
 
     def test_charfield_2(self):
         f = CharField(required=False)
-        self.assertEqual('1', f.clean(1))
-        self.assertEqual('hello', f.clean('hello'))
-        self.assertEqual('', f.clean(None))
-        self.assertEqual('', f.clean(''))
-        self.assertEqual('[1, 2, 3]', f.clean([1, 2, 3]))
+        self.assertEqual("1", f.clean(1))
+        self.assertEqual("hello", f.clean("hello"))
+        self.assertEqual("", f.clean(None))
+        self.assertEqual("", f.clean(""))
+        self.assertEqual("[1, 2, 3]", f.clean([1, 2, 3]))
         self.assertIsNone(f.max_length)
         self.assertIsNone(f.min_length)
 
     def test_charfield_3(self):
         f = CharField(max_length=10, required=False)
-        self.assertEqual('12345', f.clean('12345'))
-        self.assertEqual('1234567890', f.clean('1234567890'))
+        self.assertEqual("12345", f.clean("12345"))
+        self.assertEqual("1234567890", f.clean("1234567890"))
         msg = "'Ensure this value has at most 10 characters (it has 11).'"
         with self.assertRaisesMessage(ValidationError, msg):
-            f.clean('1234567890a')
+            f.clean("1234567890a")
         self.assertEqual(f.max_length, 10)
         self.assertIsNone(f.min_length)
 
     def test_charfield_4(self):
         f = CharField(min_length=10, required=False)
-        self.assertEqual('', f.clean(''))
+        self.assertEqual("", f.clean(""))
         msg = "'Ensure this value has at least 10 characters (it has 5).'"
         with self.assertRaisesMessage(ValidationError, msg):
-            f.clean('12345')
-        self.assertEqual('1234567890', f.clean('1234567890'))
-        self.assertEqual('1234567890a', f.clean('1234567890a'))
+            f.clean("12345")
+        self.assertEqual("1234567890", f.clean("1234567890"))
+        self.assertEqual("1234567890a", f.clean("1234567890a"))
         self.assertIsNone(f.max_length)
         self.assertEqual(f.min_length, 10)
 
     def test_charfield_5(self):
         f = CharField(min_length=10, required=True)
         with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
-            f.clean('')
+            f.clean("")
         msg = "'Ensure this value has at least 10 characters (it has 5).'"
         with self.assertRaisesMessage(ValidationError, msg):
-            f.clean('12345')
-        self.assertEqual('1234567890', f.clean('1234567890'))
-        self.assertEqual('1234567890a', f.clean('1234567890a'))
+            f.clean("12345")
+        self.assertEqual("1234567890", f.clean("1234567890"))
+        self.assertEqual("1234567890a", f.clean("1234567890a"))
         self.assertIsNone(f.max_length)
         self.assertEqual(f.min_length, 10)
 
@@ -70,12 +67,12 @@ class CharFieldTest(FormFieldAssertionsMixin, SimpleTestCase):
         raises an exception.
         """
         with self.assertRaises(ValueError):
-            CharField(min_length='a')
+            CharField(min_length="a")
         with self.assertRaises(ValueError):
-            CharField(max_length='a')
-        msg = '__init__() takes 1 positional argument but 2 were given'
+            CharField(max_length="a")
+        msg = "__init__() takes 1 positional argument but 2 were given"
         with self.assertRaisesMessage(TypeError, msg):
-            CharField('a')
+            CharField("a")
 
     def test_charfield_widget_attrs(self):
         """
@@ -90,22 +87,28 @@ class CharFieldTest(FormFieldAssertionsMixin, SimpleTestCase):
 
         # Return a maxlength attribute equal to max_length.
         f = CharField(max_length=10)
-        self.assertEqual(f.widget_attrs(TextInput()), {'maxlength': '10'})
-        self.assertEqual(f.widget_attrs(PasswordInput()), {'maxlength': '10'})
-        self.assertEqual(f.widget_attrs(Textarea()), {'maxlength': '10'})
+        self.assertEqual(f.widget_attrs(TextInput()), {"maxlength": "10"})
+        self.assertEqual(f.widget_attrs(PasswordInput()), {"maxlength": "10"})
+        self.assertEqual(f.widget_attrs(Textarea()), {"maxlength": "10"})
 
         # Return a minlength attribute equal to min_length.
         f = CharField(min_length=5)
-        self.assertEqual(f.widget_attrs(TextInput()), {'minlength': '5'})
-        self.assertEqual(f.widget_attrs(PasswordInput()), {'minlength': '5'})
-        self.assertEqual(f.widget_attrs(Textarea()), {'minlength': '5'})
+        self.assertEqual(f.widget_attrs(TextInput()), {"minlength": "5"})
+        self.assertEqual(f.widget_attrs(PasswordInput()), {"minlength": "5"})
+        self.assertEqual(f.widget_attrs(Textarea()), {"minlength": "5"})
 
         # Return both maxlength and minlength when both max_length and
         # min_length are set.
         f = CharField(max_length=10, min_length=5)
-        self.assertEqual(f.widget_attrs(TextInput()), {'maxlength': '10', 'minlength': '5'})
-        self.assertEqual(f.widget_attrs(PasswordInput()), {'maxlength': '10', 'minlength': '5'})
-        self.assertEqual(f.widget_attrs(Textarea()), {'maxlength': '10', 'minlength': '5'})
+        self.assertEqual(
+            f.widget_attrs(TextInput()), {"maxlength": "10", "minlength": "5"}
+        )
+        self.assertEqual(
+            f.widget_attrs(PasswordInput()), {"maxlength": "10", "minlength": "5"}
+        )
+        self.assertEqual(
+            f.widget_attrs(Textarea()), {"maxlength": "10", "minlength": "5"}
+        )
         self.assertEqual(f.widget_attrs(HiddenInput()), {})
 
     def test_charfield_strip(self):
@@ -113,12 +116,12 @@ class CharFieldTest(FormFieldAssertionsMixin, SimpleTestCase):
         Values have whitespace stripped but not if strip=False.
         """
         f = CharField()
-        self.assertEqual(f.clean(' 1'), '1')
-        self.assertEqual(f.clean('1 '), '1')
+        self.assertEqual(f.clean(" 1"), "1")
+        self.assertEqual(f.clean("1 "), "1")
 
         f = CharField(strip=False)
-        self.assertEqual(f.clean(' 1'), ' 1')
-        self.assertEqual(f.clean('1 '), '1 ')
+        self.assertEqual(f.clean(" 1"), " 1")
+        self.assertEqual(f.clean("1 "), "1 ")
 
     def test_strip_before_checking_empty(self):
         """
@@ -126,10 +129,11 @@ class CharFieldTest(FormFieldAssertionsMixin, SimpleTestCase):
         converted to the empty value, None.
         """
         f = CharField(required=False, empty_value=None)
-        self.assertIsNone(f.clean(' '))
+        self.assertIsNone(f.clean(" "))
 
     def test_clean_non_string(self):
         """CharField.clean() calls str(value) before stripping it."""
+
         class StringWrapper:
             def __init__(self, v):
                 self.v = v
@@ -137,18 +141,20 @@ class CharFieldTest(FormFieldAssertionsMixin, SimpleTestCase):
             def __str__(self):
                 return self.v
 
-        value = StringWrapper(' ')
+        value = StringWrapper(" ")
         f1 = CharField(required=False, empty_value=None)
         self.assertIsNone(f1.clean(value))
         f2 = CharField(strip=False)
-        self.assertEqual(f2.clean(value), ' ')
+        self.assertEqual(f2.clean(value), " ")
 
     def test_charfield_disabled(self):
         f = CharField(disabled=True)
-        self.assertWidgetRendersTo(f, '<input type="text" name="f" id="id_f" disabled required>')
+        self.assertWidgetRendersTo(
+            f, '<input type="text" name="f" id="id_f" disabled required>'
+        )
 
     def test_null_characters_prohibited(self):
         f = CharField()
-        msg = 'Null characters are not allowed.'
+        msg = "Null characters are not allowed."
         with self.assertRaisesMessage(ValidationError, msg):
-            f.clean('\x00something')
+            f.clean("\x00something")
diff --git a/tests/forms_tests/field_tests/test_choicefield.py b/tests/forms_tests/field_tests/test_choicefield.py
index f25e2cedfd..bc580bbf02 100644
--- a/tests/forms_tests/field_tests/test_choicefield.py
+++ b/tests/forms_tests/field_tests/test_choicefield.py
@@ -7,52 +7,52 @@ from . import FormFieldAssertionsMixin
 
 
 class ChoiceFieldTest(FormFieldAssertionsMixin, SimpleTestCase):
-
     def test_choicefield_1(self):
-        f = ChoiceField(choices=[('1', 'One'), ('2', 'Two')])
+        f = ChoiceField(choices=[("1", "One"), ("2", "Two")])
         with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
-            f.clean('')
+            f.clean("")
         with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
             f.clean(None)
-        self.assertEqual('1', f.clean(1))
-        self.assertEqual('1', f.clean('1'))
+        self.assertEqual("1", f.clean(1))
+        self.assertEqual("1", f.clean("1"))
         msg = "'Select a valid choice. 3 is not one of the available choices.'"
         with self.assertRaisesMessage(ValidationError, msg):
-            f.clean('3')
+            f.clean("3")
 
     def test_choicefield_2(self):
-        f = ChoiceField(choices=[('1', 'One'), ('2', 'Two')], required=False)
-        self.assertEqual('', f.clean(''))
-        self.assertEqual('', f.clean(None))
-        self.assertEqual('1', f.clean(1))
-        self.assertEqual('1', f.clean('1'))
+        f = ChoiceField(choices=[("1", "One"), ("2", "Two")], required=False)
+        self.assertEqual("", f.clean(""))
+        self.assertEqual("", f.clean(None))
+        self.assertEqual("1", f.clean(1))
+        self.assertEqual("1", f.clean("1"))
         msg = "'Select a valid choice. 3 is not one of the available choices.'"
         with self.assertRaisesMessage(ValidationError, msg):
-            f.clean('3')
+            f.clean("3")
 
     def test_choicefield_3(self):
-        f = ChoiceField(choices=[('J', 'John'), ('P', 'Paul')])
-        self.assertEqual('J', f.clean('J'))
+        f = ChoiceField(choices=[("J", "John"), ("P", "Paul")])
+        self.assertEqual("J", f.clean("J"))
         msg = "'Select a valid choice. John is not one of the available choices.'"
         with self.assertRaisesMessage(ValidationError, msg):
-            f.clean('John')
+            f.clean("John")
 
     def test_choicefield_4(self):
         f = ChoiceField(
             choices=[
-                ('Numbers', (('1', 'One'), ('2', 'Two'))),
-                ('Letters', (('3', 'A'), ('4', 'B'))), ('5', 'Other'),
+                ("Numbers", (("1", "One"), ("2", "Two"))),
+                ("Letters", (("3", "A"), ("4", "B"))),
+                ("5", "Other"),
             ]
         )
-        self.assertEqual('1', f.clean(1))
-        self.assertEqual('1', f.clean('1'))
-        self.assertEqual('3', f.clean(3))
-        self.assertEqual('3', f.clean('3'))
-        self.assertEqual('5', f.clean(5))
-        self.assertEqual('5', f.clean('5'))
+        self.assertEqual("1", f.clean(1))
+        self.assertEqual("1", f.clean("1"))
+        self.assertEqual("3", f.clean(3))
+        self.assertEqual("3", f.clean("3"))
+        self.assertEqual("5", f.clean(5))
+        self.assertEqual("5", f.clean("5"))
         msg = "'Select a valid choice. 6 is not one of the available choices.'"
         with self.assertRaisesMessage(ValidationError, msg):
-            f.clean('6')
+            f.clean("6")
 
     def test_choicefield_choices_default(self):
         f = ChoiceField()
@@ -60,9 +60,10 @@ class ChoiceFieldTest(FormFieldAssertionsMixin, SimpleTestCase):
 
     def test_choicefield_callable(self):
         def choices():
-            return [('J', 'John'), ('P', 'Paul')]
+            return [("J", "John"), ("P", "Paul")]
+
         f = ChoiceField(choices=choices)
-        self.assertEqual('J', f.clean('J'))
+        self.assertEqual("J", f.clean("J"))
 
     def test_choicefield_callable_may_evaluate_to_different_values(self):
         choices = []
@@ -73,29 +74,29 @@ class ChoiceFieldTest(FormFieldAssertionsMixin, SimpleTestCase):
         class ChoiceFieldForm(Form):
             choicefield = ChoiceField(choices=choices_as_callable)
 
-        choices = [('J', 'John')]
+        choices = [("J", "John")]
         form = ChoiceFieldForm()
-        self.assertEqual([('J', 'John')], list(form.fields['choicefield'].choices))
+        self.assertEqual([("J", "John")], list(form.fields["choicefield"].choices))
 
-        choices = [('P', 'Paul')]
+        choices = [("P", "Paul")]
         form = ChoiceFieldForm()
-        self.assertEqual([('P', 'Paul')], list(form.fields['choicefield'].choices))
+        self.assertEqual([("P", "Paul")], list(form.fields["choicefield"].choices))
 
     def test_choicefield_disabled(self):
-        f = ChoiceField(choices=[('J', 'John'), ('P', 'Paul')], disabled=True)
+        f = ChoiceField(choices=[("J", "John"), ("P", "Paul")], disabled=True)
         self.assertWidgetRendersTo(
             f,
             '<select id="id_f" name="f" disabled><option value="J">John</option>'
-            '<option value="P">Paul</option></select>'
+            '<option value="P">Paul</option></select>',
         )
 
     def test_choicefield_enumeration(self):
         class FirstNames(models.TextChoices):
-            JOHN = 'J', 'John'
-            PAUL = 'P', 'Paul'
+            JOHN = "J", "John"
+            PAUL = "P", "Paul"
 
         f = ChoiceField(choices=FirstNames.choices)
-        self.assertEqual(f.clean('J'), 'J')
+        self.assertEqual(f.clean("J"), "J")
         msg = "'Select a valid choice. 3 is not one of the available choices.'"
         with self.assertRaisesMessage(ValidationError, msg):
-            f.clean('3')
+            f.clean("3")
diff --git a/tests/forms_tests/field_tests/test_combofield.py b/tests/forms_tests/field_tests/test_combofield.py
index 481783fe2e..d433fdf2b3 100644
--- a/tests/forms_tests/field_tests/test_combofield.py
+++ b/tests/forms_tests/field_tests/test_combofield.py
@@ -4,25 +4,34 @@ from django.test import SimpleTestCase
 
 
 class ComboFieldTest(SimpleTestCase):
-
     def test_combofield_1(self):
         f = ComboField(fields=[CharField(max_length=20), EmailField()])
-        self.assertEqual('test@example.com', f.clean('test@example.com'))
-        with self.assertRaisesMessage(ValidationError, "'Ensure this value has at most 20 characters (it has 28).'"):
-            f.clean('longemailaddress@example.com')
-        with self.assertRaisesMessage(ValidationError, "'Enter a valid email address.'"):
-            f.clean('not an email')
+        self.assertEqual("test@example.com", f.clean("test@example.com"))
+        with self.assertRaisesMessage(
+            ValidationError,
+            "'Ensure this value has at most 20 characters (it has 28).'",
+        ):
+            f.clean("longemailaddress@example.com")
+        with self.assertRaisesMessage(
+            ValidationError, "'Enter a valid email address.'"
+        ):
+            f.clean("not an email")
         with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
-            f.clean('')
+            f.clean("")
         with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
             f.clean(None)
 
     def test_combofield_2(self):
         f = ComboField(fields=[CharField(max_length=20), EmailField()], required=False)
-        self.assertEqual('test@example.com', f.clean('test@example.com'))
-        with self.assertRaisesMessage(ValidationError, "'Ensure this value has at most 20 characters (it has 28).'"):
-            f.clean('longemailaddress@example.com')
-        with self.assertRaisesMessage(ValidationError, "'Enter a valid email address.'"):
-            f.clean('not an email')
-        self.assertEqual('', f.clean(''))
-        self.assertEqual('', f.clean(None))
+        self.assertEqual("test@example.com", f.clean("test@example.com"))
+        with self.assertRaisesMessage(
+            ValidationError,
+            "'Ensure this value has at most 20 characters (it has 28).'",
+        ):
+            f.clean("longemailaddress@example.com")
+        with self.assertRaisesMessage(
+            ValidationError, "'Enter a valid email address.'"
+        ):
+            f.clean("not an email")
+        self.assertEqual("", f.clean(""))
+        self.assertEqual("", f.clean(None))
diff --git a/tests/forms_tests/field_tests/test_datefield.py b/tests/forms_tests/field_tests/test_datefield.py
index 10d77bf1bb..a9f93f40ed 100644
--- a/tests/forms_tests/field_tests/test_datefield.py
+++ b/tests/forms_tests/field_tests/test_datefield.py
@@ -11,174 +11,195 @@ class GetDate(Form):
 
 
 class DateFieldTest(SimpleTestCase):
-
     def test_form_field(self):
-        a = GetDate({'mydate_month': '4', 'mydate_day': '1', 'mydate_year': '2008'})
+        a = GetDate({"mydate_month": "4", "mydate_day": "1", "mydate_year": "2008"})
         self.assertTrue(a.is_valid())
-        self.assertEqual(a.cleaned_data['mydate'], date(2008, 4, 1))
+        self.assertEqual(a.cleaned_data["mydate"], date(2008, 4, 1))
 
         # As with any widget that implements get_value_from_datadict(), we must
         # accept the input from the "as_hidden" rendering as well.
         self.assertHTMLEqual(
-            a['mydate'].as_hidden(),
+            a["mydate"].as_hidden(),
             '<input type="hidden" name="mydate" value="2008-04-01" id="id_mydate">',
         )
 
-        b = GetDate({'mydate': '2008-4-1'})
+        b = GetDate({"mydate": "2008-4-1"})
         self.assertTrue(b.is_valid())
-        self.assertEqual(b.cleaned_data['mydate'], date(2008, 4, 1))
+        self.assertEqual(b.cleaned_data["mydate"], date(2008, 4, 1))
 
         # Invalid dates shouldn't be allowed
-        c = GetDate({'mydate_month': '2', 'mydate_day': '31', 'mydate_year': '2010'})
+        c = GetDate({"mydate_month": "2", "mydate_day": "31", "mydate_year": "2010"})
         self.assertFalse(c.is_valid())
-        self.assertEqual(c.errors, {'mydate': ['Enter a valid date.']})
+        self.assertEqual(c.errors, {"mydate": ["Enter a valid date."]})
 
         # label tag is correctly associated with month dropdown
-        d = GetDate({'mydate_month': '1', 'mydate_day': '1', 'mydate_year': '2010'})
+        d = GetDate({"mydate_month": "1", "mydate_day": "1", "mydate_year": "2010"})
         self.assertIn('<label for="id_mydate_month">', d.as_p())
 
-    @translation.override('nl')
+    @translation.override("nl")
     def test_l10n_date_changed(self):
         """
         DateField.has_changed() with SelectDateWidget works with a localized
         date format (#17165).
         """
         # With Field.show_hidden_initial=False
-        b = GetDate({
-            'mydate_year': '2008',
-            'mydate_month': '4',
-            'mydate_day': '1',
-        }, initial={'mydate': date(2008, 4, 1)})
+        b = GetDate(
+            {
+                "mydate_year": "2008",
+                "mydate_month": "4",
+                "mydate_day": "1",
+            },
+            initial={"mydate": date(2008, 4, 1)},
+        )
         self.assertFalse(b.has_changed())
 
-        b = GetDate({
-            'mydate_year': '2008',
-            'mydate_month': '4',
-            'mydate_day': '2',
-        }, initial={'mydate': date(2008, 4, 1)})
+        b = GetDate(
+            {
+                "mydate_year": "2008",
+                "mydate_month": "4",
+                "mydate_day": "2",
+            },
+            initial={"mydate": date(2008, 4, 1)},
+        )
         self.assertTrue(b.has_changed())
 
         # With Field.show_hidden_initial=True
         class GetDateShowHiddenInitial(Form):
             mydate = DateField(widget=SelectDateWidget, show_hidden_initial=True)
 
-        b = GetDateShowHiddenInitial({
-            'mydate_year': '2008',
-            'mydate_month': '4',
-            'mydate_day': '1',
-            'initial-mydate': HiddenInput().format_value(date(2008, 4, 1)),
-        }, initial={'mydate': date(2008, 4, 1)})
+        b = GetDateShowHiddenInitial(
+            {
+                "mydate_year": "2008",
+                "mydate_month": "4",
+                "mydate_day": "1",
+                "initial-mydate": HiddenInput().format_value(date(2008, 4, 1)),
+            },
+            initial={"mydate": date(2008, 4, 1)},
+        )
         self.assertFalse(b.has_changed())
 
-        b = GetDateShowHiddenInitial({
-            'mydate_year': '2008',
-            'mydate_month': '4',
-            'mydate_day': '22',
-            'initial-mydate': HiddenInput().format_value(date(2008, 4, 1)),
-        }, initial={'mydate': date(2008, 4, 1)})
+        b = GetDateShowHiddenInitial(
+            {
+                "mydate_year": "2008",
+                "mydate_month": "4",
+                "mydate_day": "22",
+                "initial-mydate": HiddenInput().format_value(date(2008, 4, 1)),
+            },
+            initial={"mydate": date(2008, 4, 1)},
+        )
         self.assertTrue(b.has_changed())
 
-        b = GetDateShowHiddenInitial({
-            'mydate_year': '2008',
-            'mydate_month': '4',
-            'mydate_day': '22',
-            'initial-mydate': HiddenInput().format_value(date(2008, 4, 1)),
-        }, initial={'mydate': date(2008, 4, 22)})
+        b = GetDateShowHiddenInitial(
+            {
+                "mydate_year": "2008",
+                "mydate_month": "4",
+                "mydate_day": "22",
+                "initial-mydate": HiddenInput().format_value(date(2008, 4, 1)),
+            },
+            initial={"mydate": date(2008, 4, 22)},
+        )
         self.assertTrue(b.has_changed())
 
-        b = GetDateShowHiddenInitial({
-            'mydate_year': '2008',
-            'mydate_month': '4',
-            'mydate_day': '22',
-            'initial-mydate': HiddenInput().format_value(date(2008, 4, 22)),
-        }, initial={'mydate': date(2008, 4, 1)})
+        b = GetDateShowHiddenInitial(
+            {
+                "mydate_year": "2008",
+                "mydate_month": "4",
+                "mydate_day": "22",
+                "initial-mydate": HiddenInput().format_value(date(2008, 4, 22)),
+            },
+            initial={"mydate": date(2008, 4, 1)},
+        )
         self.assertFalse(b.has_changed())
 
-    @translation.override('nl')
+    @translation.override("nl")
     def test_l10n_invalid_date_in(self):
         # Invalid dates shouldn't be allowed
-        a = GetDate({'mydate_month': '2', 'mydate_day': '31', 'mydate_year': '2010'})
+        a = GetDate({"mydate_month": "2", "mydate_day": "31", "mydate_year": "2010"})
         self.assertFalse(a.is_valid())
         # 'Geef een geldige datum op.' = 'Enter a valid date.'
-        self.assertEqual(a.errors, {'mydate': ['Voer een geldige datum in.']})
+        self.assertEqual(a.errors, {"mydate": ["Voer een geldige datum in."]})
 
-    @translation.override('nl')
+    @translation.override("nl")
     def test_form_label_association(self):
         # label tag is correctly associated with first rendered dropdown
-        a = GetDate({'mydate_month': '1', 'mydate_day': '1', 'mydate_year': '2010'})
+        a = GetDate({"mydate_month": "1", "mydate_day": "1", "mydate_year": "2010"})
         self.assertIn('<label for="id_mydate_day">', a.as_p())
 
     def test_datefield_1(self):
         f = DateField()
         self.assertEqual(date(2006, 10, 25), f.clean(date(2006, 10, 25)))
         self.assertEqual(date(2006, 10, 25), f.clean(datetime(2006, 10, 25, 14, 30)))
-        self.assertEqual(date(2006, 10, 25), f.clean(datetime(2006, 10, 25, 14, 30, 59)))
-        self.assertEqual(date(2006, 10, 25), f.clean(datetime(2006, 10, 25, 14, 30, 59, 200)))
-        self.assertEqual(date(2006, 10, 25), f.clean('2006-10-25'))
-        self.assertEqual(date(2006, 10, 25), f.clean('10/25/2006'))
-        self.assertEqual(date(2006, 10, 25), f.clean('10/25/06'))
-        self.assertEqual(date(2006, 10, 25), f.clean('Oct 25 2006'))
-        self.assertEqual(date(2006, 10, 25), f.clean('October 25 2006'))
-        self.assertEqual(date(2006, 10, 25), f.clean('October 25, 2006'))
-        self.assertEqual(date(2006, 10, 25), f.clean('25 October 2006'))
-        self.assertEqual(date(2006, 10, 25), f.clean('25 October, 2006'))
+        self.assertEqual(
+            date(2006, 10, 25), f.clean(datetime(2006, 10, 25, 14, 30, 59))
+        )
+        self.assertEqual(
+            date(2006, 10, 25), f.clean(datetime(2006, 10, 25, 14, 30, 59, 200))
+        )
+        self.assertEqual(date(2006, 10, 25), f.clean("2006-10-25"))
+        self.assertEqual(date(2006, 10, 25), f.clean("10/25/2006"))
+        self.assertEqual(date(2006, 10, 25), f.clean("10/25/06"))
+        self.assertEqual(date(2006, 10, 25), f.clean("Oct 25 2006"))
+        self.assertEqual(date(2006, 10, 25), f.clean("October 25 2006"))
+        self.assertEqual(date(2006, 10, 25), f.clean("October 25, 2006"))
+        self.assertEqual(date(2006, 10, 25), f.clean("25 October 2006"))
+        self.assertEqual(date(2006, 10, 25), f.clean("25 October, 2006"))
         with self.assertRaisesMessage(ValidationError, "'Enter a valid date.'"):
-            f.clean('2006-4-31')
+            f.clean("2006-4-31")
         with self.assertRaisesMessage(ValidationError, "'Enter a valid date.'"):
-            f.clean('200a-10-25')
+            f.clean("200a-10-25")
         with self.assertRaisesMessage(ValidationError, "'Enter a valid date.'"):
-            f.clean('25/10/06')
+            f.clean("25/10/06")
         with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
             f.clean(None)
 
     def test_datefield_2(self):
         f = DateField(required=False)
         self.assertIsNone(f.clean(None))
-        self.assertEqual('None', repr(f.clean(None)))
-        self.assertIsNone(f.clean(''))
-        self.assertEqual('None', repr(f.clean('')))
+        self.assertEqual("None", repr(f.clean(None)))
+        self.assertIsNone(f.clean(""))
+        self.assertEqual("None", repr(f.clean("")))
 
     def test_datefield_3(self):
-        f = DateField(input_formats=['%Y %m %d'])
+        f = DateField(input_formats=["%Y %m %d"])
         self.assertEqual(date(2006, 10, 25), f.clean(date(2006, 10, 25)))
         self.assertEqual(date(2006, 10, 25), f.clean(datetime(2006, 10, 25, 14, 30)))
-        self.assertEqual(date(2006, 10, 25), f.clean('2006 10 25'))
+        self.assertEqual(date(2006, 10, 25), f.clean("2006 10 25"))
         with self.assertRaisesMessage(ValidationError, "'Enter a valid date.'"):
-            f.clean('2006-10-25')
+            f.clean("2006-10-25")
         with self.assertRaisesMessage(ValidationError, "'Enter a valid date.'"):
-            f.clean('10/25/2006')
+            f.clean("10/25/2006")
         with self.assertRaisesMessage(ValidationError, "'Enter a valid date.'"):
-            f.clean('10/25/06')
+            f.clean("10/25/06")
 
     def test_datefield_4(self):
         # Test whitespace stripping behavior (#5714)
         f = DateField()
-        self.assertEqual(date(2006, 10, 25), f.clean(' 10/25/2006 '))
-        self.assertEqual(date(2006, 10, 25), f.clean(' 10/25/06 '))
-        self.assertEqual(date(2006, 10, 25), f.clean(' Oct 25   2006 '))
-        self.assertEqual(date(2006, 10, 25), f.clean(' October  25 2006 '))
-        self.assertEqual(date(2006, 10, 25), f.clean(' October 25, 2006 '))
-        self.assertEqual(date(2006, 10, 25), f.clean(' 25 October 2006 '))
+        self.assertEqual(date(2006, 10, 25), f.clean(" 10/25/2006 "))
+        self.assertEqual(date(2006, 10, 25), f.clean(" 10/25/06 "))
+        self.assertEqual(date(2006, 10, 25), f.clean(" Oct 25   2006 "))
+        self.assertEqual(date(2006, 10, 25), f.clean(" October  25 2006 "))
+        self.assertEqual(date(2006, 10, 25), f.clean(" October 25, 2006 "))
+        self.assertEqual(date(2006, 10, 25), f.clean(" 25 October 2006 "))
         with self.assertRaisesMessage(ValidationError, "'Enter a valid date.'"):
-            f.clean('   ')
+            f.clean("   ")
 
     def test_datefield_5(self):
         # Test null bytes (#18982)
         f = DateField()
         with self.assertRaisesMessage(ValidationError, "'Enter a valid date.'"):
-            f.clean('a\x00b')
+            f.clean("a\x00b")
 
     def test_datefield_changed(self):
-        format = '%d/%m/%Y'
+        format = "%d/%m/%Y"
         f = DateField(input_formats=[format])
         d = date(2007, 9, 17)
-        self.assertFalse(f.has_changed(d, '17/09/2007'))
+        self.assertFalse(f.has_changed(d, "17/09/2007"))
 
     def test_datefield_strptime(self):
         """field.strptime() doesn't raise a UnicodeEncodeError (#16123)"""
         f = DateField()
         try:
-            f.strptime('31 мая 2011', '%d-%b-%y')
+            f.strptime("31 мая 2011", "%d-%b-%y")
         except Exception as e:
             # assertIsInstance or assertRaises cannot be used because UnicodeEncodeError
             # is a subclass of ValueError
diff --git a/tests/forms_tests/field_tests/test_datetimefield.py b/tests/forms_tests/field_tests/test_datetimefield.py
index 5d118cfdd2..3d266da6b7 100644
--- a/tests/forms_tests/field_tests/test_datetimefield.py
+++ b/tests/forms_tests/field_tests/test_datetimefield.py
@@ -7,7 +7,6 @@ from django.utils.timezone import get_fixed_timezone, utc
 
 
 class DateTimeFieldTest(SimpleTestCase):
-
     def test_datetimefield_clean(self):
         tests = [
             (date(2006, 10, 25), datetime(2006, 10, 25, 0, 0)),
@@ -17,48 +16,48 @@ class DateTimeFieldTest(SimpleTestCase):
                 datetime(2006, 10, 25, 14, 30, 59, 200),
                 datetime(2006, 10, 25, 14, 30, 59, 200),
             ),
-            ('2006-10-25 14:30:45.000200', datetime(2006, 10, 25, 14, 30, 45, 200)),
-            ('2006-10-25 14:30:45.0002', datetime(2006, 10, 25, 14, 30, 45, 200)),
-            ('2006-10-25 14:30:45', datetime(2006, 10, 25, 14, 30, 45)),
-            ('2006-10-25 14:30:00', datetime(2006, 10, 25, 14, 30)),
-            ('2006-10-25 14:30', datetime(2006, 10, 25, 14, 30)),
-            ('2006-10-25', datetime(2006, 10, 25, 0, 0)),
-            ('10/25/2006 14:30:45.000200', datetime(2006, 10, 25, 14, 30, 45, 200)),
-            ('10/25/2006 14:30:45', datetime(2006, 10, 25, 14, 30, 45)),
-            ('10/25/2006 14:30:00', datetime(2006, 10, 25, 14, 30)),
-            ('10/25/2006 14:30', datetime(2006, 10, 25, 14, 30)),
-            ('10/25/2006', datetime(2006, 10, 25, 0, 0)),
-            ('10/25/06 14:30:45.000200', datetime(2006, 10, 25, 14, 30, 45, 200)),
-            ('10/25/06 14:30:45', datetime(2006, 10, 25, 14, 30, 45)),
-            ('10/25/06 14:30:00', datetime(2006, 10, 25, 14, 30)),
-            ('10/25/06 14:30', datetime(2006, 10, 25, 14, 30)),
-            ('10/25/06', datetime(2006, 10, 25, 0, 0)),
+            ("2006-10-25 14:30:45.000200", datetime(2006, 10, 25, 14, 30, 45, 200)),
+            ("2006-10-25 14:30:45.0002", datetime(2006, 10, 25, 14, 30, 45, 200)),
+            ("2006-10-25 14:30:45", datetime(2006, 10, 25, 14, 30, 45)),
+            ("2006-10-25 14:30:00", datetime(2006, 10, 25, 14, 30)),
+            ("2006-10-25 14:30", datetime(2006, 10, 25, 14, 30)),
+            ("2006-10-25", datetime(2006, 10, 25, 0, 0)),
+            ("10/25/2006 14:30:45.000200", datetime(2006, 10, 25, 14, 30, 45, 200)),
+            ("10/25/2006 14:30:45", datetime(2006, 10, 25, 14, 30, 45)),
+            ("10/25/2006 14:30:00", datetime(2006, 10, 25, 14, 30)),
+            ("10/25/2006 14:30", datetime(2006, 10, 25, 14, 30)),
+            ("10/25/2006", datetime(2006, 10, 25, 0, 0)),
+            ("10/25/06 14:30:45.000200", datetime(2006, 10, 25, 14, 30, 45, 200)),
+            ("10/25/06 14:30:45", datetime(2006, 10, 25, 14, 30, 45)),
+            ("10/25/06 14:30:00", datetime(2006, 10, 25, 14, 30)),
+            ("10/25/06 14:30", datetime(2006, 10, 25, 14, 30)),
+            ("10/25/06", datetime(2006, 10, 25, 0, 0)),
             # ISO 8601 formats.
             (
-                '2014-09-23T22:34:41.614804',
+                "2014-09-23T22:34:41.614804",
                 datetime(2014, 9, 23, 22, 34, 41, 614804),
             ),
-            ('2014-09-23T22:34:41', datetime(2014, 9, 23, 22, 34, 41)),
-            ('2014-09-23T22:34', datetime(2014, 9, 23, 22, 34)),
-            ('2014-09-23', datetime(2014, 9, 23, 0, 0)),
-            ('2014-09-23T22:34Z', datetime(2014, 9, 23, 22, 34, tzinfo=utc)),
+            ("2014-09-23T22:34:41", datetime(2014, 9, 23, 22, 34, 41)),
+            ("2014-09-23T22:34", datetime(2014, 9, 23, 22, 34)),
+            ("2014-09-23", datetime(2014, 9, 23, 0, 0)),
+            ("2014-09-23T22:34Z", datetime(2014, 9, 23, 22, 34, tzinfo=utc)),
             (
-                '2014-09-23T22:34+07:00',
+                "2014-09-23T22:34+07:00",
                 datetime(2014, 9, 23, 22, 34, tzinfo=get_fixed_timezone(420)),
             ),
             # Whitespace stripping.
-            (' 2006-10-25   14:30:45 ', datetime(2006, 10, 25, 14, 30, 45)),
-            (' 2006-10-25 ', datetime(2006, 10, 25, 0, 0)),
-            (' 10/25/2006 14:30:45 ', datetime(2006, 10, 25, 14, 30, 45)),
-            (' 10/25/2006 14:30 ', datetime(2006, 10, 25, 14, 30)),
-            (' 10/25/2006 ', datetime(2006, 10, 25, 0, 0)),
-            (' 10/25/06 14:30:45 ', datetime(2006, 10, 25, 14, 30, 45)),
-            (' 10/25/06 ', datetime(2006, 10, 25, 0, 0)),
+            (" 2006-10-25   14:30:45 ", datetime(2006, 10, 25, 14, 30, 45)),
+            (" 2006-10-25 ", datetime(2006, 10, 25, 0, 0)),
+            (" 10/25/2006 14:30:45 ", datetime(2006, 10, 25, 14, 30, 45)),
+            (" 10/25/2006 14:30 ", datetime(2006, 10, 25, 14, 30)),
+            (" 10/25/2006 ", datetime(2006, 10, 25, 0, 0)),
+            (" 10/25/06 14:30:45 ", datetime(2006, 10, 25, 14, 30, 45)),
+            (" 10/25/06 ", datetime(2006, 10, 25, 0, 0)),
             (
-                ' 2014-09-23T22:34:41.614804 ',
+                " 2014-09-23T22:34:41.614804 ",
                 datetime(2014, 9, 23, 22, 34, 41, 614804),
             ),
-            (' 2014-09-23T22:34Z ', datetime(2014, 9, 23, 22, 34, tzinfo=utc)),
+            (" 2014-09-23T22:34Z ", datetime(2014, 9, 23, 22, 34, tzinfo=utc)),
         ]
         f = DateTimeField()
         for value, expected_datetime in tests:
@@ -69,40 +68,46 @@ class DateTimeFieldTest(SimpleTestCase):
         f = DateTimeField()
         msg = "'Enter a valid date/time.'"
         with self.assertRaisesMessage(ValidationError, msg):
-            f.clean('hello')
+            f.clean("hello")
         with self.assertRaisesMessage(ValidationError, msg):
-            f.clean('2006-10-25 4:30 p.m.')
+            f.clean("2006-10-25 4:30 p.m.")
         with self.assertRaisesMessage(ValidationError, msg):
-            f.clean('   ')
+            f.clean("   ")
         with self.assertRaisesMessage(ValidationError, msg):
-            f.clean('2014-09-23T28:23')
-        f = DateTimeField(input_formats=['%Y %m %d %I:%M %p'])
+            f.clean("2014-09-23T28:23")
+        f = DateTimeField(input_formats=["%Y %m %d %I:%M %p"])
         with self.assertRaisesMessage(ValidationError, msg):
-            f.clean('2006.10.25 14:30:45')
+            f.clean("2006.10.25 14:30:45")
 
     def test_datetimefield_clean_input_formats(self):
         tests = [
-            ('%Y %m %d %I:%M %p', (
-                (date(2006, 10, 25), datetime(2006, 10, 25, 0, 0)),
-                (datetime(2006, 10, 25, 14, 30), datetime(2006, 10, 25, 14, 30)),
-                (
-                    datetime(2006, 10, 25, 14, 30, 59),
-                    datetime(2006, 10, 25, 14, 30, 59),
-                ),
+            (
+                "%Y %m %d %I:%M %p",
                 (
-                    datetime(2006, 10, 25, 14, 30, 59, 200),
-                    datetime(2006, 10, 25, 14, 30, 59, 200),
+                    (date(2006, 10, 25), datetime(2006, 10, 25, 0, 0)),
+                    (datetime(2006, 10, 25, 14, 30), datetime(2006, 10, 25, 14, 30)),
+                    (
+                        datetime(2006, 10, 25, 14, 30, 59),
+                        datetime(2006, 10, 25, 14, 30, 59),
+                    ),
+                    (
+                        datetime(2006, 10, 25, 14, 30, 59, 200),
+                        datetime(2006, 10, 25, 14, 30, 59, 200),
+                    ),
+                    ("2006 10 25 2:30 PM", datetime(2006, 10, 25, 14, 30)),
+                    # ISO-like formats are always accepted.
+                    ("2006-10-25 14:30:45", datetime(2006, 10, 25, 14, 30, 45)),
                 ),
-                ('2006 10 25 2:30 PM', datetime(2006, 10, 25, 14, 30)),
-                # ISO-like formats are always accepted.
-                ('2006-10-25 14:30:45', datetime(2006, 10, 25, 14, 30, 45)),
-            )),
-            ('%Y.%m.%d %H:%M:%S.%f', (
+            ),
+            (
+                "%Y.%m.%d %H:%M:%S.%f",
                 (
-                    '2006.10.25 14:30:45.0002',
-                    datetime(2006, 10, 25, 14, 30, 45, 200),
+                    (
+                        "2006.10.25 14:30:45.0002",
+                        datetime(2006, 10, 25, 14, 30, 45, 200),
+                    ),
                 ),
-            )),
+            ),
         ]
         for input_format, values in tests:
             f = DateTimeField(input_formats=[input_format])
@@ -113,11 +118,11 @@ class DateTimeFieldTest(SimpleTestCase):
     def test_datetimefield_not_required(self):
         f = DateTimeField(required=False)
         self.assertIsNone(f.clean(None))
-        self.assertEqual('None', repr(f.clean(None)))
-        self.assertIsNone(f.clean(''))
-        self.assertEqual('None', repr(f.clean('')))
+        self.assertEqual("None", repr(f.clean(None)))
+        self.assertIsNone(f.clean(""))
+        self.assertEqual("None", repr(f.clean("")))
 
     def test_datetimefield_changed(self):
-        f = DateTimeField(input_formats=['%Y %m %d %I:%M %p'])
+        f = DateTimeField(input_formats=["%Y %m %d %I:%M %p"])
         d = datetime(2006, 9, 17, 14, 30, 0)
-        self.assertFalse(f.has_changed(d, '2006 09 17 2:30 PM'))
+        self.assertFalse(f.has_changed(d, "2006 09 17 2:30 PM"))
diff --git a/tests/forms_tests/field_tests/test_decimalfield.py b/tests/forms_tests/field_tests/test_decimalfield.py
index 1dd0984ac7..6e49a41341 100644
--- a/tests/forms_tests/field_tests/test_decimalfield.py
+++ b/tests/forms_tests/field_tests/test_decimalfield.py
@@ -10,40 +10,51 @@ from . import FormFieldAssertionsMixin
 
 
 class DecimalFieldTest(FormFieldAssertionsMixin, SimpleTestCase):
-
     def test_decimalfield_1(self):
         f = DecimalField(max_digits=4, decimal_places=2)
-        self.assertWidgetRendersTo(f, '<input id="id_f" step="0.01" type="number" name="f" required>')
+        self.assertWidgetRendersTo(
+            f, '<input id="id_f" step="0.01" type="number" name="f" required>'
+        )
         with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
-            f.clean('')
+            f.clean("")
         with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
             f.clean(None)
-        self.assertEqual(f.clean('1'), decimal.Decimal("1"))
-        self.assertIsInstance(f.clean('1'), decimal.Decimal)
-        self.assertEqual(f.clean('23'), decimal.Decimal("23"))
-        self.assertEqual(f.clean('3.14'), decimal.Decimal("3.14"))
+        self.assertEqual(f.clean("1"), decimal.Decimal("1"))
+        self.assertIsInstance(f.clean("1"), decimal.Decimal)
+        self.assertEqual(f.clean("23"), decimal.Decimal("23"))
+        self.assertEqual(f.clean("3.14"), decimal.Decimal("3.14"))
         self.assertEqual(f.clean(3.14), decimal.Decimal("3.14"))
-        self.assertEqual(f.clean(decimal.Decimal('3.14')), decimal.Decimal("3.14"))
-        self.assertEqual(f.clean('1.0 '), decimal.Decimal("1.0"))
-        self.assertEqual(f.clean(' 1.0'), decimal.Decimal("1.0"))
-        self.assertEqual(f.clean(' 1.0 '), decimal.Decimal("1.0"))
-        with self.assertRaisesMessage(ValidationError, "'Ensure that there are no more than 4 digits in total.'"):
-            f.clean('123.45')
-        with self.assertRaisesMessage(ValidationError, "'Ensure that there are no more than 2 decimal places.'"):
-            f.clean('1.234')
+        self.assertEqual(f.clean(decimal.Decimal("3.14")), decimal.Decimal("3.14"))
+        self.assertEqual(f.clean("1.0 "), decimal.Decimal("1.0"))
+        self.assertEqual(f.clean(" 1.0"), decimal.Decimal("1.0"))
+        self.assertEqual(f.clean(" 1.0 "), decimal.Decimal("1.0"))
+        with self.assertRaisesMessage(
+            ValidationError, "'Ensure that there are no more than 4 digits in total.'"
+        ):
+            f.clean("123.45")
+        with self.assertRaisesMessage(
+            ValidationError, "'Ensure that there are no more than 2 decimal places.'"
+        ):
+            f.clean("1.234")
         msg = "'Ensure that there are no more than 2 digits before the decimal point.'"
         with self.assertRaisesMessage(ValidationError, msg):
-            f.clean('123.4')
-        self.assertEqual(f.clean('-12.34'), decimal.Decimal("-12.34"))
-        with self.assertRaisesMessage(ValidationError, "'Ensure that there are no more than 4 digits in total.'"):
-            f.clean('-123.45')
-        self.assertEqual(f.clean('-.12'), decimal.Decimal("-0.12"))
-        self.assertEqual(f.clean('-00.12'), decimal.Decimal("-0.12"))
-        self.assertEqual(f.clean('-000.12'), decimal.Decimal("-0.12"))
-        with self.assertRaisesMessage(ValidationError, "'Ensure that there are no more than 2 decimal places.'"):
-            f.clean('-000.123')
-        with self.assertRaisesMessage(ValidationError, "'Ensure that there are no more than 4 digits in total.'"):
-            f.clean('-000.12345')
+            f.clean("123.4")
+        self.assertEqual(f.clean("-12.34"), decimal.Decimal("-12.34"))
+        with self.assertRaisesMessage(
+            ValidationError, "'Ensure that there are no more than 4 digits in total.'"
+        ):
+            f.clean("-123.45")
+        self.assertEqual(f.clean("-.12"), decimal.Decimal("-0.12"))
+        self.assertEqual(f.clean("-00.12"), decimal.Decimal("-0.12"))
+        self.assertEqual(f.clean("-000.12"), decimal.Decimal("-0.12"))
+        with self.assertRaisesMessage(
+            ValidationError, "'Ensure that there are no more than 2 decimal places.'"
+        ):
+            f.clean("-000.123")
+        with self.assertRaisesMessage(
+            ValidationError, "'Ensure that there are no more than 4 digits in total.'"
+        ):
+            f.clean("-000.12345")
         self.assertEqual(f.max_digits, 4)
         self.assertEqual(f.decimal_places, 2)
         self.assertIsNone(f.max_value)
@@ -52,21 +63,34 @@ class DecimalFieldTest(FormFieldAssertionsMixin, SimpleTestCase):
     def test_enter_a_number_error(self):
         f = DecimalField(max_value=1, max_digits=4, decimal_places=2)
         values = (
-            '-NaN', 'NaN', '+NaN',
-            '-sNaN', 'sNaN', '+sNaN',
-            '-Inf', 'Inf', '+Inf',
-            '-Infinity', 'Infinity', '+Infinity',
-            'a', 'łąść', '1.0a', '--0.12',
+            "-NaN",
+            "NaN",
+            "+NaN",
+            "-sNaN",
+            "sNaN",
+            "+sNaN",
+            "-Inf",
+            "Inf",
+            "+Inf",
+            "-Infinity",
+            "Infinity",
+            "+Infinity",
+            "a",
+            "łąść",
+            "1.0a",
+            "--0.12",
         )
         for value in values:
-            with self.subTest(value=value), self.assertRaisesMessage(ValidationError, "'Enter a number.'"):
+            with self.subTest(value=value), self.assertRaisesMessage(
+                ValidationError, "'Enter a number.'"
+            ):
                 f.clean(value)
 
     def test_decimalfield_2(self):
         f = DecimalField(max_digits=4, decimal_places=2, required=False)
-        self.assertIsNone(f.clean(''))
+        self.assertIsNone(f.clean(""))
         self.assertIsNone(f.clean(None))
-        self.assertEqual(f.clean('1'), decimal.Decimal("1"))
+        self.assertEqual(f.clean("1"), decimal.Decimal("1"))
         self.assertEqual(f.max_digits, 4)
         self.assertEqual(f.decimal_places, 2)
         self.assertIsNone(f.max_value)
@@ -74,71 +98,82 @@ class DecimalFieldTest(FormFieldAssertionsMixin, SimpleTestCase):
 
     def test_decimalfield_3(self):
         f = DecimalField(
-            max_digits=4, decimal_places=2,
-            max_value=decimal.Decimal('1.5'),
-            min_value=decimal.Decimal('0.5')
+            max_digits=4,
+            decimal_places=2,
+            max_value=decimal.Decimal("1.5"),
+            min_value=decimal.Decimal("0.5"),
         )
         self.assertWidgetRendersTo(
             f,
             '<input step="0.01" name="f" min="0.5" max="1.5" type="number" id="id_f" required>',
         )
-        with self.assertRaisesMessage(ValidationError, "'Ensure this value is less than or equal to 1.5.'"):
-            f.clean('1.6')
-        with self.assertRaisesMessage(ValidationError, "'Ensure this value is greater than or equal to 0.5.'"):
-            f.clean('0.4')
-        self.assertEqual(f.clean('1.5'), decimal.Decimal("1.5"))
-        self.assertEqual(f.clean('0.5'), decimal.Decimal("0.5"))
-        self.assertEqual(f.clean('.5'), decimal.Decimal("0.5"))
-        self.assertEqual(f.clean('00.50'), decimal.Decimal("0.50"))
+        with self.assertRaisesMessage(
+            ValidationError, "'Ensure this value is less than or equal to 1.5.'"
+        ):
+            f.clean("1.6")
+        with self.assertRaisesMessage(
+            ValidationError, "'Ensure this value is greater than or equal to 0.5.'"
+        ):
+            f.clean("0.4")
+        self.assertEqual(f.clean("1.5"), decimal.Decimal("1.5"))
+        self.assertEqual(f.clean("0.5"), decimal.Decimal("0.5"))
+        self.assertEqual(f.clean(".5"), decimal.Decimal("0.5"))
+        self.assertEqual(f.clean("00.50"), decimal.Decimal("0.50"))
         self.assertEqual(f.max_digits, 4)
         self.assertEqual(f.decimal_places, 2)
-        self.assertEqual(f.max_value, decimal.Decimal('1.5'))
-        self.assertEqual(f.min_value, decimal.Decimal('0.5'))
+        self.assertEqual(f.max_value, decimal.Decimal("1.5"))
+        self.assertEqual(f.min_value, decimal.Decimal("0.5"))
 
     def test_decimalfield_4(self):
         f = DecimalField(decimal_places=2)
-        with self.assertRaisesMessage(ValidationError, "'Ensure that there are no more than 2 decimal places.'"):
-            f.clean('0.00000001')
+        with self.assertRaisesMessage(
+            ValidationError, "'Ensure that there are no more than 2 decimal places.'"
+        ):
+            f.clean("0.00000001")
 
     def test_decimalfield_5(self):
         f = DecimalField(max_digits=3)
         # Leading whole zeros "collapse" to one digit.
-        self.assertEqual(f.clean('0000000.10'), decimal.Decimal("0.1"))
+        self.assertEqual(f.clean("0000000.10"), decimal.Decimal("0.1"))
         # But a leading 0 before the . doesn't count toward max_digits
-        self.assertEqual(f.clean('0000000.100'), decimal.Decimal("0.100"))
+        self.assertEqual(f.clean("0000000.100"), decimal.Decimal("0.100"))
         # Only leading whole zeros "collapse" to one digit.
-        self.assertEqual(f.clean('000000.02'), decimal.Decimal('0.02'))
-        with self.assertRaisesMessage(ValidationError, "'Ensure that there are no more than 3 digits in total.'"):
-            f.clean('000000.0002')
-        self.assertEqual(f.clean('.002'), decimal.Decimal("0.002"))
+        self.assertEqual(f.clean("000000.02"), decimal.Decimal("0.02"))
+        with self.assertRaisesMessage(
+            ValidationError, "'Ensure that there are no more than 3 digits in total.'"
+        ):
+            f.clean("000000.0002")
+        self.assertEqual(f.clean(".002"), decimal.Decimal("0.002"))
 
     def test_decimalfield_6(self):
         f = DecimalField(max_digits=2, decimal_places=2)
-        self.assertEqual(f.clean('.01'), decimal.Decimal(".01"))
+        self.assertEqual(f.clean(".01"), decimal.Decimal(".01"))
         msg = "'Ensure that there are no more than 0 digits before the decimal point.'"
         with self.assertRaisesMessage(ValidationError, msg):
-            f.clean('1.1')
+            f.clean("1.1")
 
     def test_decimalfield_scientific(self):
         f = DecimalField(max_digits=4, decimal_places=2)
         with self.assertRaisesMessage(ValidationError, "Ensure that there are no more"):
-            f.clean('1E+2')
-        self.assertEqual(f.clean('1E+1'), decimal.Decimal('10'))
-        self.assertEqual(f.clean('1E-1'), decimal.Decimal('0.1'))
-        self.assertEqual(f.clean('0.546e+2'), decimal.Decimal('54.6'))
+            f.clean("1E+2")
+        self.assertEqual(f.clean("1E+1"), decimal.Decimal("10"))
+        self.assertEqual(f.clean("1E-1"), decimal.Decimal("0.1"))
+        self.assertEqual(f.clean("0.546e+2"), decimal.Decimal("54.6"))
 
     def test_decimalfield_widget_attrs(self):
         f = DecimalField(max_digits=6, decimal_places=2)
         self.assertEqual(f.widget_attrs(Widget()), {})
-        self.assertEqual(f.widget_attrs(NumberInput()), {'step': '0.01'})
+        self.assertEqual(f.widget_attrs(NumberInput()), {"step": "0.01"})
         f = DecimalField(max_digits=10, decimal_places=0)
-        self.assertEqual(f.widget_attrs(NumberInput()), {'step': '1'})
+        self.assertEqual(f.widget_attrs(NumberInput()), {"step": "1"})
         f = DecimalField(max_digits=19, decimal_places=19)
-        self.assertEqual(f.widget_attrs(NumberInput()), {'step': '1e-19'})
+        self.assertEqual(f.widget_attrs(NumberInput()), {"step": "1e-19"})
         f = DecimalField(max_digits=20)
-        self.assertEqual(f.widget_attrs(NumberInput()), {'step': 'any'})
-        f = DecimalField(max_digits=6, widget=NumberInput(attrs={'step': '0.01'}))
-        self.assertWidgetRendersTo(f, '<input step="0.01" name="f" type="number" id="id_f" required>')
+        self.assertEqual(f.widget_attrs(NumberInput()), {"step": "any"})
+        f = DecimalField(max_digits=6, widget=NumberInput(attrs={"step": "0.01"}))
+        self.assertWidgetRendersTo(
+            f, '<input step="0.01" name="f" type="number" id="id_f" required>'
+        )
 
     def test_decimalfield_localized(self):
         """
@@ -151,10 +186,10 @@ class DecimalFieldTest(FormFieldAssertionsMixin, SimpleTestCase):
     def test_decimalfield_changed(self):
         f = DecimalField(max_digits=2, decimal_places=2)
         d = decimal.Decimal("0.1")
-        self.assertFalse(f.has_changed(d, '0.10'))
-        self.assertTrue(f.has_changed(d, '0.101'))
+        self.assertFalse(f.has_changed(d, "0.10"))
+        self.assertTrue(f.has_changed(d, "0.101"))
 
-        with translation.override('fr'):
+        with translation.override("fr"):
             f = DecimalField(max_digits=2, decimal_places=2, localize=True)
             localized_d = formats.localize_input(d)  # -> '0,1' in French
             self.assertFalse(f.has_changed(d, localized_d))
@@ -164,22 +199,26 @@ class DecimalFieldTest(FormFieldAssertionsMixin, SimpleTestCase):
     # format-related settings will take precedence over locale-dictated
     # formats.
     @ignore_warnings(category=RemovedInDjango50Warning)
-    @override_settings(USE_L10N=False, DECIMAL_SEPARATOR=',')
+    @override_settings(USE_L10N=False, DECIMAL_SEPARATOR=",")
     def test_decimalfield_support_decimal_separator(self):
         f = DecimalField(localize=True)
-        self.assertEqual(f.clean('1001,10'), decimal.Decimal("1001.10"))
-        self.assertEqual(f.clean('1001.10'), decimal.Decimal("1001.10"))
+        self.assertEqual(f.clean("1001,10"), decimal.Decimal("1001.10"))
+        self.assertEqual(f.clean("1001.10"), decimal.Decimal("1001.10"))
 
     # RemovedInDjango50Warning: When the deprecation ends, remove
     # @ignore_warnings and USE_L10N=False. The test should remain because
     # format-related settings will take precedence over locale-dictated
     # formats.
     @ignore_warnings(category=RemovedInDjango50Warning)
-    @override_settings(USE_L10N=False, DECIMAL_SEPARATOR=',', USE_THOUSAND_SEPARATOR=True,
-                       THOUSAND_SEPARATOR='.')
+    @override_settings(
+        USE_L10N=False,
+        DECIMAL_SEPARATOR=",",
+        USE_THOUSAND_SEPARATOR=True,
+        THOUSAND_SEPARATOR=".",
+    )
     def test_decimalfield_support_thousands_separator(self):
         f = DecimalField(localize=True)
-        self.assertEqual(f.clean('1.001,10'), decimal.Decimal("1001.10"))
+        self.assertEqual(f.clean("1.001,10"), decimal.Decimal("1001.10"))
         msg = "'Enter a number.'"
         with self.assertRaisesMessage(ValidationError, msg):
-            f.clean('1,001.1')
+            f.clean("1,001.1")
diff --git a/tests/forms_tests/field_tests/test_durationfield.py b/tests/forms_tests/field_tests/test_durationfield.py
index dae139446d..834638354c 100644
--- a/tests/forms_tests/field_tests/test_durationfield.py
+++ b/tests/forms_tests/field_tests/test_durationfield.py
@@ -10,32 +10,35 @@ from . import FormFieldAssertionsMixin
 
 
 class DurationFieldTest(FormFieldAssertionsMixin, SimpleTestCase):
-
     def test_durationfield_clean(self):
         f = DurationField()
-        self.assertEqual(datetime.timedelta(seconds=30), f.clean('30'))
-        self.assertEqual(datetime.timedelta(minutes=15, seconds=30), f.clean('15:30'))
-        self.assertEqual(datetime.timedelta(hours=1, minutes=15, seconds=30), f.clean('1:15:30'))
+        self.assertEqual(datetime.timedelta(seconds=30), f.clean("30"))
+        self.assertEqual(datetime.timedelta(minutes=15, seconds=30), f.clean("15:30"))
+        self.assertEqual(
+            datetime.timedelta(hours=1, minutes=15, seconds=30), f.clean("1:15:30")
+        )
         self.assertEqual(
-            datetime.timedelta(days=1, hours=1, minutes=15, seconds=30, milliseconds=300),
-            f.clean('1 1:15:30.3')
+            datetime.timedelta(
+                days=1, hours=1, minutes=15, seconds=30, milliseconds=300
+            ),
+            f.clean("1 1:15:30.3"),
         )
         self.assertEqual(
             datetime.timedelta(0, 10800),
             f.clean(datetime.timedelta(0, 10800)),
         )
-        msg = 'This field is required.'
+        msg = "This field is required."
         with self.assertRaisesMessage(ValidationError, msg):
-            f.clean('')
-        msg = 'Enter a valid duration.'
+            f.clean("")
+        msg = "Enter a valid duration."
         with self.assertRaisesMessage(ValidationError, msg):
-            f.clean('not_a_time')
+            f.clean("not_a_time")
         with self.assertRaisesMessage(ValidationError, msg):
-            DurationField().clean('P3(3D')
+            DurationField().clean("P3(3D")
 
     def test_durationfield_clean_not_required(self):
         f = DurationField(required=False)
-        self.assertIsNone(f.clean(''))
+        self.assertIsNone(f.clean(""))
 
     def test_overflow(self):
         msg = "The number of days must be between {min_days} and {max_days}.".format(
@@ -44,18 +47,18 @@ class DurationFieldTest(FormFieldAssertionsMixin, SimpleTestCase):
         )
         f = DurationField()
         with self.assertRaisesMessage(ValidationError, msg):
-            f.clean('1000000000 00:00:00')
+            f.clean("1000000000 00:00:00")
         with self.assertRaisesMessage(ValidationError, msg):
-            f.clean('-1000000000 00:00:00')
+            f.clean("-1000000000 00:00:00")
 
     def test_overflow_translation(self):
         msg = "Le nombre de jours doit être entre {min_days} et {max_days}.".format(
             min_days=datetime.timedelta.min.days,
             max_days=datetime.timedelta.max.days,
         )
-        with translation.override('fr'):
+        with translation.override("fr"):
             with self.assertRaisesMessage(ValidationError, msg):
-                DurationField().clean('1000000000 00:00:00')
+                DurationField().clean("1000000000 00:00:00")
 
     def test_durationfield_render(self):
         self.assertWidgetRendersTo(
@@ -71,5 +74,5 @@ class DurationFieldTest(FormFieldAssertionsMixin, SimpleTestCase):
         field = DurationField()
         td = datetime.timedelta(minutes=15, seconds=30)
         self.assertEqual(field.prepare_value(td), duration_string(td))
-        self.assertEqual(field.prepare_value('arbitrary'), 'arbitrary')
+        self.assertEqual(field.prepare_value("arbitrary"), "arbitrary")
         self.assertIsNone(field.prepare_value(None))
diff --git a/tests/forms_tests/field_tests/test_emailfield.py b/tests/forms_tests/field_tests/test_emailfield.py
index 8b85e4dcc1..d1d52dd608 100644
--- a/tests/forms_tests/field_tests/test_emailfield.py
+++ b/tests/forms_tests/field_tests/test_emailfield.py
@@ -6,37 +6,44 @@ from . import FormFieldAssertionsMixin
 
 
 class EmailFieldTest(FormFieldAssertionsMixin, SimpleTestCase):
-
     def test_emailfield_1(self):
         f = EmailField()
-        self.assertWidgetRendersTo(f, '<input type="email" name="f" id="id_f" required>')
+        self.assertWidgetRendersTo(
+            f, '<input type="email" name="f" id="id_f" required>'
+        )
         with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
-            f.clean('')
+            f.clean("")
         with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
             f.clean(None)
-        self.assertEqual('person@example.com', f.clean('person@example.com'))
-        with self.assertRaisesMessage(ValidationError, "'Enter a valid email address.'"):
-            f.clean('foo')
+        self.assertEqual("person@example.com", f.clean("person@example.com"))
+        with self.assertRaisesMessage(
+            ValidationError, "'Enter a valid email address.'"
+        ):
+            f.clean("foo")
         self.assertEqual(
-            'local@domain.with.idn.xyz\xe4\xf6\xfc\xdfabc.part.com',
-            f.clean('local@domain.with.idn.xyzäöüßabc.part.com')
+            "local@domain.with.idn.xyz\xe4\xf6\xfc\xdfabc.part.com",
+            f.clean("local@domain.with.idn.xyzäöüßabc.part.com"),
         )
 
     def test_email_regexp_for_performance(self):
         f = EmailField()
         # Check for runaway regex security problem. This will take a long time
         # if the security fix isn't in place.
-        addr = 'viewx3dtextx26qx3d@yahoo.comx26latlngx3d15854521645943074058'
+        addr = "viewx3dtextx26qx3d@yahoo.comx26latlngx3d15854521645943074058"
         self.assertEqual(addr, f.clean(addr))
 
     def test_emailfield_not_required(self):
         f = EmailField(required=False)
-        self.assertEqual('', f.clean(''))
-        self.assertEqual('', f.clean(None))
-        self.assertEqual('person@example.com', f.clean('person@example.com'))
-        self.assertEqual('example@example.com', f.clean('      example@example.com  \t   \t '))
-        with self.assertRaisesMessage(ValidationError, "'Enter a valid email address.'"):
-            f.clean('foo')
+        self.assertEqual("", f.clean(""))
+        self.assertEqual("", f.clean(None))
+        self.assertEqual("person@example.com", f.clean("person@example.com"))
+        self.assertEqual(
+            "example@example.com", f.clean("      example@example.com  \t   \t ")
+        )
+        with self.assertRaisesMessage(
+            ValidationError, "'Enter a valid email address.'"
+        ):
+            f.clean("foo")
 
     def test_emailfield_min_max_length(self):
         f = EmailField(min_length=10, max_length=15)
@@ -44,15 +51,21 @@ class EmailFieldTest(FormFieldAssertionsMixin, SimpleTestCase):
             f,
             '<input id="id_f" type="email" name="f" maxlength="15" minlength="10" required>',
         )
-        with self.assertRaisesMessage(ValidationError, "'Ensure this value has at least 10 characters (it has 9).'"):
-            f.clean('a@foo.com')
-        self.assertEqual('alf@foo.com', f.clean('alf@foo.com'))
-        with self.assertRaisesMessage(ValidationError, "'Ensure this value has at most 15 characters (it has 20).'"):
-            f.clean('alf123456788@foo.com')
+        with self.assertRaisesMessage(
+            ValidationError,
+            "'Ensure this value has at least 10 characters (it has 9).'",
+        ):
+            f.clean("a@foo.com")
+        self.assertEqual("alf@foo.com", f.clean("alf@foo.com"))
+        with self.assertRaisesMessage(
+            ValidationError,
+            "'Ensure this value has at most 15 characters (it has 20).'",
+        ):
+            f.clean("alf123456788@foo.com")
 
     def test_emailfield_strip_on_none_value(self):
         f = EmailField(required=False, empty_value=None)
-        self.assertIsNone(f.clean(''))
+        self.assertIsNone(f.clean(""))
         self.assertIsNone(f.clean(None))
 
     def test_emailfield_unable_to_set_strip_kwarg(self):
diff --git a/tests/forms_tests/field_tests/test_filefield.py b/tests/forms_tests/field_tests/test_filefield.py
index 2db106e4a0..56aaa311e0 100644
--- a/tests/forms_tests/field_tests/test_filefield.py
+++ b/tests/forms_tests/field_tests/test_filefield.py
@@ -7,54 +7,74 @@ from django.test import SimpleTestCase
 
 
 class FileFieldTest(SimpleTestCase):
-
     def test_filefield_1(self):
         f = FileField()
         with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
-            f.clean('')
+            f.clean("")
         with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
-            f.clean('', '')
-        self.assertEqual('files/test1.pdf', f.clean('', 'files/test1.pdf'))
+            f.clean("", "")
+        self.assertEqual("files/test1.pdf", f.clean("", "files/test1.pdf"))
         with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
             f.clean(None)
         with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
-            f.clean(None, '')
-        self.assertEqual('files/test2.pdf', f.clean(None, 'files/test2.pdf'))
+            f.clean(None, "")
+        self.assertEqual("files/test2.pdf", f.clean(None, "files/test2.pdf"))
         no_file_msg = "'No file was submitted. Check the encoding type on the form.'"
-        file = SimpleUploadedFile(None, b'')
-        file._name = ''
+        file = SimpleUploadedFile(None, b"")
+        file._name = ""
         with self.assertRaisesMessage(ValidationError, no_file_msg):
             f.clean(file)
         with self.assertRaisesMessage(ValidationError, no_file_msg):
-            f.clean(file, '')
-        self.assertEqual('files/test3.pdf', f.clean(None, 'files/test3.pdf'))
+            f.clean(file, "")
+        self.assertEqual("files/test3.pdf", f.clean(None, "files/test3.pdf"))
         with self.assertRaisesMessage(ValidationError, no_file_msg):
-            f.clean('some content that is not a file')
-        with self.assertRaisesMessage(ValidationError, "'The submitted file is empty.'"):
-            f.clean(SimpleUploadedFile('name', None))
-        with self.assertRaisesMessage(ValidationError, "'The submitted file is empty.'"):
-            f.clean(SimpleUploadedFile('name', b''))
-        self.assertEqual(SimpleUploadedFile, type(f.clean(SimpleUploadedFile('name', b'Some File Content'))))
+            f.clean("some content that is not a file")
+        with self.assertRaisesMessage(
+            ValidationError, "'The submitted file is empty.'"
+        ):
+            f.clean(SimpleUploadedFile("name", None))
+        with self.assertRaisesMessage(
+            ValidationError, "'The submitted file is empty.'"
+        ):
+            f.clean(SimpleUploadedFile("name", b""))
+        self.assertEqual(
+            SimpleUploadedFile,
+            type(f.clean(SimpleUploadedFile("name", b"Some File Content"))),
+        )
         self.assertIsInstance(
-            f.clean(SimpleUploadedFile('我隻氣墊船裝滿晒鱔.txt', 'मेरी मँडराने वाली नाव सर्पमीनों से भरी ह'.encode())),
-            SimpleUploadedFile
+            f.clean(
+                SimpleUploadedFile(
+                    "我隻氣墊船裝滿晒鱔.txt", "मेरी मँडराने वाली नाव सर्पमीनों से भरी ह".encode()
+                )
+            ),
+            SimpleUploadedFile,
         )
         self.assertIsInstance(
-            f.clean(SimpleUploadedFile('name', b'Some File Content'), 'files/test4.pdf'),
-            SimpleUploadedFile
+            f.clean(
+                SimpleUploadedFile("name", b"Some File Content"), "files/test4.pdf"
+            ),
+            SimpleUploadedFile,
         )
 
     def test_filefield_2(self):
         f = FileField(max_length=5)
-        with self.assertRaisesMessage(ValidationError, "'Ensure this filename has at most 5 characters (it has 18).'"):
-            f.clean(SimpleUploadedFile('test_maxlength.txt', b'hello world'))
-        self.assertEqual('files/test1.pdf', f.clean('', 'files/test1.pdf'))
-        self.assertEqual('files/test2.pdf', f.clean(None, 'files/test2.pdf'))
-        self.assertIsInstance(f.clean(SimpleUploadedFile('name', b'Some File Content')), SimpleUploadedFile)
+        with self.assertRaisesMessage(
+            ValidationError,
+            "'Ensure this filename has at most 5 characters (it has 18).'",
+        ):
+            f.clean(SimpleUploadedFile("test_maxlength.txt", b"hello world"))
+        self.assertEqual("files/test1.pdf", f.clean("", "files/test1.pdf"))
+        self.assertEqual("files/test2.pdf", f.clean(None, "files/test2.pdf"))
+        self.assertIsInstance(
+            f.clean(SimpleUploadedFile("name", b"Some File Content")),
+            SimpleUploadedFile,
+        )
 
     def test_filefield_3(self):
         f = FileField(allow_empty_file=True)
-        self.assertIsInstance(f.clean(SimpleUploadedFile('name', b'')), SimpleUploadedFile)
+        self.assertIsInstance(
+            f.clean(SimpleUploadedFile("name", b"")), SimpleUploadedFile
+        )
 
     def test_filefield_changed(self):
         """
@@ -65,21 +85,27 @@ class FileFieldTest(SimpleTestCase):
         f = FileField()
 
         # No file was uploaded and no initial data.
-        self.assertFalse(f.has_changed('', None))
+        self.assertFalse(f.has_changed("", None))
 
         # A file was uploaded and no initial data.
-        self.assertTrue(f.has_changed('', {'filename': 'resume.txt', 'content': 'My resume'}))
+        self.assertTrue(
+            f.has_changed("", {"filename": "resume.txt", "content": "My resume"})
+        )
 
         # A file was not uploaded, but there is initial data
-        self.assertFalse(f.has_changed('resume.txt', None))
+        self.assertFalse(f.has_changed("resume.txt", None))
 
         # A file was uploaded and there is initial data (file identity is not dealt
         # with here)
-        self.assertTrue(f.has_changed('resume.txt', {'filename': 'resume.txt', 'content': 'My resume'}))
+        self.assertTrue(
+            f.has_changed(
+                "resume.txt", {"filename": "resume.txt", "content": "My resume"}
+            )
+        )
 
     def test_disabled_has_changed(self):
         f = FileField(disabled=True)
-        self.assertIs(f.has_changed('x', 'y'), False)
+        self.assertIs(f.has_changed("x", "y"), False)
 
     def test_file_picklable(self):
         self.assertIsInstance(pickle.loads(pickle.dumps(FileField())), FileField)
diff --git a/tests/forms_tests/field_tests/test_filepathfield.py b/tests/forms_tests/field_tests/test_filepathfield.py
index bdd55c32a5..ca0f6f3a7a 100644
--- a/tests/forms_tests/field_tests/test_filepathfield.py
+++ b/tests/forms_tests/field_tests/test_filepathfield.py
@@ -10,8 +10,8 @@ PATH = os.path.dirname(os.path.abspath(__file__))
 def fix_os_paths(x):
     if isinstance(x, str):
         if x.startswith(PATH):
-            x = x[len(PATH):]
-        return x.replace('\\', '/')
+            x = x[len(PATH) :]
+        return x.replace("\\", "/")
     elif isinstance(x, tuple):
         return tuple(fix_os_paths(list(x)))
     elif isinstance(x, list):
@@ -22,34 +22,34 @@ def fix_os_paths(x):
 
 class FilePathFieldTest(SimpleTestCase):
     expected_choices = [
-        ('/filepathfield_test_dir/__init__.py', '__init__.py'),
-        ('/filepathfield_test_dir/a.py', 'a.py'),
-        ('/filepathfield_test_dir/ab.py', 'ab.py'),
-        ('/filepathfield_test_dir/b.py', 'b.py'),
-        ('/filepathfield_test_dir/c/__init__.py', '__init__.py'),
-        ('/filepathfield_test_dir/c/d.py', 'd.py'),
-        ('/filepathfield_test_dir/c/e.py', 'e.py'),
-        ('/filepathfield_test_dir/c/f/__init__.py', '__init__.py'),
-        ('/filepathfield_test_dir/c/f/g.py', 'g.py'),
-        ('/filepathfield_test_dir/h/__init__.py', '__init__.py'),
-        ('/filepathfield_test_dir/j/__init__.py', '__init__.py'),
+        ("/filepathfield_test_dir/__init__.py", "__init__.py"),
+        ("/filepathfield_test_dir/a.py", "a.py"),
+        ("/filepathfield_test_dir/ab.py", "ab.py"),
+        ("/filepathfield_test_dir/b.py", "b.py"),
+        ("/filepathfield_test_dir/c/__init__.py", "__init__.py"),
+        ("/filepathfield_test_dir/c/d.py", "d.py"),
+        ("/filepathfield_test_dir/c/e.py", "e.py"),
+        ("/filepathfield_test_dir/c/f/__init__.py", "__init__.py"),
+        ("/filepathfield_test_dir/c/f/g.py", "g.py"),
+        ("/filepathfield_test_dir/h/__init__.py", "__init__.py"),
+        ("/filepathfield_test_dir/j/__init__.py", "__init__.py"),
     ]
-    path = os.path.join(PATH, 'filepathfield_test_dir') + '/'
+    path = os.path.join(PATH, "filepathfield_test_dir") + "/"
 
     def assertChoices(self, field, expected_choices):
         self.assertEqual(fix_os_paths(field.choices), expected_choices)
 
     def test_fix_os_paths(self):
-        self.assertEqual(fix_os_paths(self.path), ('/filepathfield_test_dir/'))
+        self.assertEqual(fix_os_paths(self.path), ("/filepathfield_test_dir/"))
 
     def test_nonexistent_path(self):
-        with self.assertRaisesMessage(FileNotFoundError, 'nonexistent'):
-            FilePathField(path='nonexistent')
+        with self.assertRaisesMessage(FileNotFoundError, "nonexistent"):
+            FilePathField(path="nonexistent")
 
     def test_no_options(self):
         f = FilePathField(path=self.path)
         expected = [
-            ('/filepathfield_test_dir/README', 'README'),
+            ("/filepathfield_test_dir/README", "README"),
         ] + self.expected_choices[:4]
         self.assertChoices(f, expected)
 
@@ -57,48 +57,59 @@ class FilePathFieldTest(SimpleTestCase):
         f = FilePathField(path=self.path)
         msg = "'Select a valid choice. a.py is not one of the available choices.'"
         with self.assertRaisesMessage(ValidationError, msg):
-            f.clean('a.py')
-        self.assertEqual(fix_os_paths(f.clean(self.path + 'a.py')), '/filepathfield_test_dir/a.py')
+            f.clean("a.py")
+        self.assertEqual(
+            fix_os_paths(f.clean(self.path + "a.py")), "/filepathfield_test_dir/a.py"
+        )
 
     def test_match(self):
-        f = FilePathField(path=self.path, match=r'^.*?\.py$')
+        f = FilePathField(path=self.path, match=r"^.*?\.py$")
         self.assertChoices(f, self.expected_choices[:4])
 
     def test_recursive(self):
-        f = FilePathField(path=self.path, recursive=True, match=r'^.*?\.py$')
+        f = FilePathField(path=self.path, recursive=True, match=r"^.*?\.py$")
         expected = [
-            ('/filepathfield_test_dir/__init__.py', '__init__.py'),
-            ('/filepathfield_test_dir/a.py', 'a.py'),
-            ('/filepathfield_test_dir/ab.py', 'ab.py'),
-            ('/filepathfield_test_dir/b.py', 'b.py'),
-            ('/filepathfield_test_dir/c/__init__.py', 'c/__init__.py'),
-            ('/filepathfield_test_dir/c/d.py', 'c/d.py'),
-            ('/filepathfield_test_dir/c/e.py', 'c/e.py'),
-            ('/filepathfield_test_dir/c/f/__init__.py', 'c/f/__init__.py'),
-            ('/filepathfield_test_dir/c/f/g.py', 'c/f/g.py'),
-            ('/filepathfield_test_dir/h/__init__.py', 'h/__init__.py'),
-            ('/filepathfield_test_dir/j/__init__.py', 'j/__init__.py'),
-
+            ("/filepathfield_test_dir/__init__.py", "__init__.py"),
+            ("/filepathfield_test_dir/a.py", "a.py"),
+            ("/filepathfield_test_dir/ab.py", "ab.py"),
+            ("/filepathfield_test_dir/b.py", "b.py"),
+            ("/filepathfield_test_dir/c/__init__.py", "c/__init__.py"),
+            ("/filepathfield_test_dir/c/d.py", "c/d.py"),
+            ("/filepathfield_test_dir/c/e.py", "c/e.py"),
+            ("/filepathfield_test_dir/c/f/__init__.py", "c/f/__init__.py"),
+            ("/filepathfield_test_dir/c/f/g.py", "c/f/g.py"),
+            ("/filepathfield_test_dir/h/__init__.py", "h/__init__.py"),
+            ("/filepathfield_test_dir/j/__init__.py", "j/__init__.py"),
         ]
         self.assertChoices(f, expected)
 
     def test_allow_folders(self):
         f = FilePathField(path=self.path, allow_folders=True, allow_files=False)
-        self.assertChoices(f, [
-            ('/filepathfield_test_dir/c', 'c'),
-            ('/filepathfield_test_dir/h', 'h'),
-            ('/filepathfield_test_dir/j', 'j'),
-        ])
+        self.assertChoices(
+            f,
+            [
+                ("/filepathfield_test_dir/c", "c"),
+                ("/filepathfield_test_dir/h", "h"),
+                ("/filepathfield_test_dir/j", "j"),
+            ],
+        )
 
     def test_recursive_no_folders_or_files(self):
-        f = FilePathField(path=self.path, recursive=True, allow_folders=False, allow_files=False)
+        f = FilePathField(
+            path=self.path, recursive=True, allow_folders=False, allow_files=False
+        )
         self.assertChoices(f, [])
 
     def test_recursive_folders_without_files(self):
-        f = FilePathField(path=self.path, recursive=True, allow_folders=True, allow_files=False)
-        self.assertChoices(f, [
-            ('/filepathfield_test_dir/c', 'c'),
-            ('/filepathfield_test_dir/h', 'h'),
-            ('/filepathfield_test_dir/j', 'j'),
-            ('/filepathfield_test_dir/c/f', 'c/f'),
-        ])
+        f = FilePathField(
+            path=self.path, recursive=True, allow_folders=True, allow_files=False
+        )
+        self.assertChoices(
+            f,
+            [
+                ("/filepathfield_test_dir/c", "c"),
+                ("/filepathfield_test_dir/h", "h"),
+                ("/filepathfield_test_dir/j", "j"),
+                ("/filepathfield_test_dir/c/f", "c/f"),
+            ],
+        )
diff --git a/tests/forms_tests/field_tests/test_floatfield.py b/tests/forms_tests/field_tests/test_floatfield.py
index 7330c33503..365684c2db 100644
--- a/tests/forms_tests/field_tests/test_floatfield.py
+++ b/tests/forms_tests/field_tests/test_floatfield.py
@@ -11,41 +11,42 @@ from . import FormFieldAssertionsMixin
 
 
 class FloatFieldTest(FormFieldAssertionsMixin, SimpleTestCase):
-
     def test_floatfield_1(self):
         f = FloatField()
-        self.assertWidgetRendersTo(f, '<input step="any" type="number" name="f" id="id_f" required>')
+        self.assertWidgetRendersTo(
+            f, '<input step="any" type="number" name="f" id="id_f" required>'
+        )
         with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
-            f.clean('')
+            f.clean("")
         with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
             f.clean(None)
-        self.assertEqual(1.0, f.clean('1'))
-        self.assertIsInstance(f.clean('1'), float)
-        self.assertEqual(23.0, f.clean('23'))
-        self.assertEqual(3.1400000000000001, f.clean('3.14'))
+        self.assertEqual(1.0, f.clean("1"))
+        self.assertIsInstance(f.clean("1"), float)
+        self.assertEqual(23.0, f.clean("23"))
+        self.assertEqual(3.1400000000000001, f.clean("3.14"))
         self.assertEqual(3.1400000000000001, f.clean(3.14))
         self.assertEqual(42.0, f.clean(42))
         with self.assertRaisesMessage(ValidationError, "'Enter a number.'"):
-            f.clean('a')
-        self.assertEqual(1.0, f.clean('1.0 '))
-        self.assertEqual(1.0, f.clean(' 1.0'))
-        self.assertEqual(1.0, f.clean(' 1.0 '))
+            f.clean("a")
+        self.assertEqual(1.0, f.clean("1.0 "))
+        self.assertEqual(1.0, f.clean(" 1.0"))
+        self.assertEqual(1.0, f.clean(" 1.0 "))
         with self.assertRaisesMessage(ValidationError, "'Enter a number.'"):
-            f.clean('1.0a')
+            f.clean("1.0a")
         self.assertIsNone(f.max_value)
         self.assertIsNone(f.min_value)
         with self.assertRaisesMessage(ValidationError, "'Enter a number.'"):
-            f.clean('Infinity')
+            f.clean("Infinity")
         with self.assertRaisesMessage(ValidationError, "'Enter a number.'"):
-            f.clean('NaN')
+            f.clean("NaN")
         with self.assertRaisesMessage(ValidationError, "'Enter a number.'"):
-            f.clean('-Inf')
+            f.clean("-Inf")
 
     def test_floatfield_2(self):
         f = FloatField(required=False)
-        self.assertIsNone(f.clean(''))
+        self.assertIsNone(f.clean(""))
         self.assertIsNone(f.clean(None))
-        self.assertEqual(1.0, f.clean('1'))
+        self.assertEqual(1.0, f.clean("1"))
         self.assertIsNone(f.max_value)
         self.assertIsNone(f.min_value)
 
@@ -55,17 +56,21 @@ class FloatFieldTest(FormFieldAssertionsMixin, SimpleTestCase):
             f,
             '<input step="any" name="f" min="0.5" max="1.5" type="number" id="id_f" required>',
         )
-        with self.assertRaisesMessage(ValidationError, "'Ensure this value is less than or equal to 1.5.'"):
-            f.clean('1.6')
-        with self.assertRaisesMessage(ValidationError, "'Ensure this value is greater than or equal to 0.5.'"):
-            f.clean('0.4')
-        self.assertEqual(1.5, f.clean('1.5'))
-        self.assertEqual(0.5, f.clean('0.5'))
+        with self.assertRaisesMessage(
+            ValidationError, "'Ensure this value is less than or equal to 1.5.'"
+        ):
+            f.clean("1.6")
+        with self.assertRaisesMessage(
+            ValidationError, "'Ensure this value is greater than or equal to 0.5.'"
+        ):
+            f.clean("0.4")
+        self.assertEqual(1.5, f.clean("1.5"))
+        self.assertEqual(0.5, f.clean("0.5"))
         self.assertEqual(f.max_value, 1.5)
         self.assertEqual(f.min_value, 0.5)
 
     def test_floatfield_widget_attrs(self):
-        f = FloatField(widget=NumberInput(attrs={'step': 0.01, 'max': 1.0, 'min': 0.0}))
+        f = FloatField(widget=NumberInput(attrs={"step": 0.01, "max": 1.0, "min": 0.0}))
         self.assertWidgetRendersTo(
             f,
             '<input step="0.01" name="f" min="0.0" max="1.0" type="number" id="id_f" required>',
@@ -82,9 +87,9 @@ class FloatFieldTest(FormFieldAssertionsMixin, SimpleTestCase):
     def test_floatfield_changed(self):
         f = FloatField()
         n = 4.35
-        self.assertFalse(f.has_changed(n, '4.3500'))
+        self.assertFalse(f.has_changed(n, "4.3500"))
 
-        with translation.override('fr'):
+        with translation.override("fr"):
             f = FloatField(localize=True)
             localized_n = formats.localize_input(n)  # -> '4,35' in French
             self.assertFalse(f.has_changed(n, localized_n))
@@ -94,31 +99,35 @@ class FloatFieldTest(FormFieldAssertionsMixin, SimpleTestCase):
     # format-related settings will take precedence over locale-dictated
     # formats.
     @ignore_warnings(category=RemovedInDjango50Warning)
-    @override_settings(USE_L10N=False, DECIMAL_SEPARATOR=',')
+    @override_settings(USE_L10N=False, DECIMAL_SEPARATOR=",")
     def test_decimalfield_support_decimal_separator(self):
         f = FloatField(localize=True)
-        self.assertEqual(f.clean('1001,10'), 1001.10)
-        self.assertEqual(f.clean('1001.10'), 1001.10)
+        self.assertEqual(f.clean("1001,10"), 1001.10)
+        self.assertEqual(f.clean("1001.10"), 1001.10)
 
     # RemovedInDjango50Warning: When the deprecation ends, remove
     # @ignore_warnings and USE_L10N=False. The test should remain because
     # format-related settings will take precedence over locale-dictated
     # formats.
     @ignore_warnings(category=RemovedInDjango50Warning)
-    @override_settings(USE_L10N=False, DECIMAL_SEPARATOR=',', USE_THOUSAND_SEPARATOR=True,
-                       THOUSAND_SEPARATOR='.')
+    @override_settings(
+        USE_L10N=False,
+        DECIMAL_SEPARATOR=",",
+        USE_THOUSAND_SEPARATOR=True,
+        THOUSAND_SEPARATOR=".",
+    )
     def test_decimalfield_support_thousands_separator(self):
         f = FloatField(localize=True)
-        self.assertEqual(f.clean('1.001,10'), 1001.10)
+        self.assertEqual(f.clean("1.001,10"), 1001.10)
         msg = "'Enter a number.'"
         with self.assertRaisesMessage(ValidationError, msg):
-            f.clean('1,001.1')
+            f.clean("1,001.1")
 
 
-@override_settings(ROOT_URLCONF='forms_tests.urls')
+@override_settings(ROOT_URLCONF="forms_tests.urls")
 class FloatFieldHTMLTest(SeleniumTestCase):
 
-    available_apps = ['forms_tests']
+    available_apps = ["forms_tests"]
 
     def test_float_field_rendering_passes_client_side_validation(self):
         """
@@ -127,9 +136,9 @@ class FloatFieldHTMLTest(SeleniumTestCase):
         """
         from selenium.webdriver.common.by import By
 
-        self.selenium.get(self.live_server_url + reverse('form_view'))
-        number_input = self.selenium.find_element(By.ID, 'id_number')
-        number_input.send_keys('0.5')
+        self.selenium.get(self.live_server_url + reverse("form_view"))
+        number_input = self.selenium.find_element(By.ID, "id_number")
+        number_input.send_keys("0.5")
         is_valid = self.selenium.execute_script(
             "return document.getElementById('id_number').checkValidity()"
         )
diff --git a/tests/forms_tests/field_tests/test_genericipaddressfield.py b/tests/forms_tests/field_tests/test_genericipaddressfield.py
index 92dbd71a28..80722f5c65 100644
--- a/tests/forms_tests/field_tests/test_genericipaddressfield.py
+++ b/tests/forms_tests/field_tests/test_genericipaddressfield.py
@@ -4,125 +4,186 @@ from django.test import SimpleTestCase
 
 
 class GenericIPAddressFieldTest(SimpleTestCase):
-
     def test_generic_ipaddress_invalid_arguments(self):
         with self.assertRaises(ValueError):
-            GenericIPAddressField(protocol='hamster')
+            GenericIPAddressField(protocol="hamster")
         with self.assertRaises(ValueError):
-            GenericIPAddressField(protocol='ipv4', unpack_ipv4=True)
+            GenericIPAddressField(protocol="ipv4", unpack_ipv4=True)
 
     def test_generic_ipaddress_as_generic(self):
         # The edge cases of the IPv6 validation code are not deeply tested
         # here, they are covered in the tests for django.utils.ipv6
         f = GenericIPAddressField()
         with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
-            f.clean('')
+            f.clean("")
         with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
             f.clean(None)
-        self.assertEqual(f.clean(' 127.0.0.1 '), '127.0.0.1')
-        with self.assertRaisesMessage(ValidationError, "'Enter a valid IPv4 or IPv6 address.'"):
-            f.clean('foo')
-        with self.assertRaisesMessage(ValidationError, "'Enter a valid IPv4 or IPv6 address.'"):
-            f.clean('127.0.0.')
-        with self.assertRaisesMessage(ValidationError, "'Enter a valid IPv4 or IPv6 address.'"):
-            f.clean('1.2.3.4.5')
-        with self.assertRaisesMessage(ValidationError, "'Enter a valid IPv4 or IPv6 address.'"):
-            f.clean('256.125.1.5')
-        self.assertEqual(f.clean(' fe80::223:6cff:fe8a:2e8a '), 'fe80::223:6cff:fe8a:2e8a')
-        self.assertEqual(f.clean(' 2a02::223:6cff:fe8a:2e8a '), '2a02::223:6cff:fe8a:2e8a')
-        with self.assertRaisesMessage(ValidationError, "'This is not a valid IPv6 address.'"):
-            f.clean('12345:2:3:4')
-        with self.assertRaisesMessage(ValidationError, "'This is not a valid IPv6 address.'"):
-            f.clean('1::2:3::4')
-        with self.assertRaisesMessage(ValidationError, "'This is not a valid IPv6 address.'"):
-            f.clean('foo::223:6cff:fe8a:2e8a')
-        with self.assertRaisesMessage(ValidationError, "'This is not a valid IPv6 address.'"):
-            f.clean('1::2:3:4:5:6:7:8')
-        with self.assertRaisesMessage(ValidationError, "'This is not a valid IPv6 address.'"):
-            f.clean('1:2')
+        self.assertEqual(f.clean(" 127.0.0.1 "), "127.0.0.1")
+        with self.assertRaisesMessage(
+            ValidationError, "'Enter a valid IPv4 or IPv6 address.'"
+        ):
+            f.clean("foo")
+        with self.assertRaisesMessage(
+            ValidationError, "'Enter a valid IPv4 or IPv6 address.'"
+        ):
+            f.clean("127.0.0.")
+        with self.assertRaisesMessage(
+            ValidationError, "'Enter a valid IPv4 or IPv6 address.'"
+        ):
+            f.clean("1.2.3.4.5")
+        with self.assertRaisesMessage(
+            ValidationError, "'Enter a valid IPv4 or IPv6 address.'"
+        ):
+            f.clean("256.125.1.5")
+        self.assertEqual(
+            f.clean(" fe80::223:6cff:fe8a:2e8a "), "fe80::223:6cff:fe8a:2e8a"
+        )
+        self.assertEqual(
+            f.clean(" 2a02::223:6cff:fe8a:2e8a "), "2a02::223:6cff:fe8a:2e8a"
+        )
+        with self.assertRaisesMessage(
+            ValidationError, "'This is not a valid IPv6 address.'"
+        ):
+            f.clean("12345:2:3:4")
+        with self.assertRaisesMessage(
+            ValidationError, "'This is not a valid IPv6 address.'"
+        ):
+            f.clean("1::2:3::4")
+        with self.assertRaisesMessage(
+            ValidationError, "'This is not a valid IPv6 address.'"
+        ):
+            f.clean("foo::223:6cff:fe8a:2e8a")
+        with self.assertRaisesMessage(
+            ValidationError, "'This is not a valid IPv6 address.'"
+        ):
+            f.clean("1::2:3:4:5:6:7:8")
+        with self.assertRaisesMessage(
+            ValidationError, "'This is not a valid IPv6 address.'"
+        ):
+            f.clean("1:2")
 
     def test_generic_ipaddress_as_ipv4_only(self):
         f = GenericIPAddressField(protocol="IPv4")
         with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
-            f.clean('')
+            f.clean("")
         with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
             f.clean(None)
-        self.assertEqual(f.clean(' 127.0.0.1 '), '127.0.0.1')
+        self.assertEqual(f.clean(" 127.0.0.1 "), "127.0.0.1")
         with self.assertRaisesMessage(ValidationError, "'Enter a valid IPv4 address.'"):
-            f.clean('foo')
+            f.clean("foo")
         with self.assertRaisesMessage(ValidationError, "'Enter a valid IPv4 address.'"):
-            f.clean('127.0.0.')
+            f.clean("127.0.0.")
         with self.assertRaisesMessage(ValidationError, "'Enter a valid IPv4 address.'"):
-            f.clean('1.2.3.4.5')
+            f.clean("1.2.3.4.5")
         with self.assertRaisesMessage(ValidationError, "'Enter a valid IPv4 address.'"):
-            f.clean('256.125.1.5')
+            f.clean("256.125.1.5")
         with self.assertRaisesMessage(ValidationError, "'Enter a valid IPv4 address.'"):
-            f.clean('fe80::223:6cff:fe8a:2e8a')
+            f.clean("fe80::223:6cff:fe8a:2e8a")
         with self.assertRaisesMessage(ValidationError, "'Enter a valid IPv4 address.'"):
-            f.clean('2a02::223:6cff:fe8a:2e8a')
+            f.clean("2a02::223:6cff:fe8a:2e8a")
 
     def test_generic_ipaddress_as_ipv6_only(self):
         f = GenericIPAddressField(protocol="IPv6")
         with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
-            f.clean('')
+            f.clean("")
         with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
             f.clean(None)
         with self.assertRaisesMessage(ValidationError, "'Enter a valid IPv6 address.'"):
-            f.clean('127.0.0.1')
+            f.clean("127.0.0.1")
         with self.assertRaisesMessage(ValidationError, "'Enter a valid IPv6 address.'"):
-            f.clean('foo')
+            f.clean("foo")
         with self.assertRaisesMessage(ValidationError, "'Enter a valid IPv6 address.'"):
-            f.clean('127.0.0.')
+            f.clean("127.0.0.")
         with self.assertRaisesMessage(ValidationError, "'Enter a valid IPv6 address.'"):
-            f.clean('1.2.3.4.5')
+            f.clean("1.2.3.4.5")
         with self.assertRaisesMessage(ValidationError, "'Enter a valid IPv6 address.'"):
-            f.clean('256.125.1.5')
-        self.assertEqual(f.clean(' fe80::223:6cff:fe8a:2e8a '), 'fe80::223:6cff:fe8a:2e8a')
-        self.assertEqual(f.clean(' 2a02::223:6cff:fe8a:2e8a '), '2a02::223:6cff:fe8a:2e8a')
-        with self.assertRaisesMessage(ValidationError, "'This is not a valid IPv6 address.'"):
-            f.clean('12345:2:3:4')
-        with self.assertRaisesMessage(ValidationError, "'This is not a valid IPv6 address.'"):
-            f.clean('1::2:3::4')
-        with self.assertRaisesMessage(ValidationError, "'This is not a valid IPv6 address.'"):
-            f.clean('foo::223:6cff:fe8a:2e8a')
-        with self.assertRaisesMessage(ValidationError, "'This is not a valid IPv6 address.'"):
-            f.clean('1::2:3:4:5:6:7:8')
-        with self.assertRaisesMessage(ValidationError, "'This is not a valid IPv6 address.'"):
-            f.clean('1:2')
+            f.clean("256.125.1.5")
+        self.assertEqual(
+            f.clean(" fe80::223:6cff:fe8a:2e8a "), "fe80::223:6cff:fe8a:2e8a"
+        )
+        self.assertEqual(
+            f.clean(" 2a02::223:6cff:fe8a:2e8a "), "2a02::223:6cff:fe8a:2e8a"
+        )
+        with self.assertRaisesMessage(
+            ValidationError, "'This is not a valid IPv6 address.'"
+        ):
+            f.clean("12345:2:3:4")
+        with self.assertRaisesMessage(
+            ValidationError, "'This is not a valid IPv6 address.'"
+        ):
+            f.clean("1::2:3::4")
+        with self.assertRaisesMessage(
+            ValidationError, "'This is not a valid IPv6 address.'"
+        ):
+            f.clean("foo::223:6cff:fe8a:2e8a")
+        with self.assertRaisesMessage(
+            ValidationError, "'This is not a valid IPv6 address.'"
+        ):
+            f.clean("1::2:3:4:5:6:7:8")
+        with self.assertRaisesMessage(
+            ValidationError, "'This is not a valid IPv6 address.'"
+        ):
+            f.clean("1:2")
 
     def test_generic_ipaddress_as_generic_not_required(self):
         f = GenericIPAddressField(required=False)
-        self.assertEqual(f.clean(''), '')
-        self.assertEqual(f.clean(None), '')
-        self.assertEqual(f.clean('127.0.0.1'), '127.0.0.1')
-        with self.assertRaisesMessage(ValidationError, "'Enter a valid IPv4 or IPv6 address.'"):
-            f.clean('foo')
-        with self.assertRaisesMessage(ValidationError, "'Enter a valid IPv4 or IPv6 address.'"):
-            f.clean('127.0.0.')
-        with self.assertRaisesMessage(ValidationError, "'Enter a valid IPv4 or IPv6 address.'"):
-            f.clean('1.2.3.4.5')
-        with self.assertRaisesMessage(ValidationError, "'Enter a valid IPv4 or IPv6 address.'"):
-            f.clean('256.125.1.5')
-        self.assertEqual(f.clean(' fe80::223:6cff:fe8a:2e8a '), 'fe80::223:6cff:fe8a:2e8a')
-        self.assertEqual(f.clean(' 2a02::223:6cff:fe8a:2e8a '), '2a02::223:6cff:fe8a:2e8a')
-        with self.assertRaisesMessage(ValidationError, "'This is not a valid IPv6 address.'"):
-            f.clean('12345:2:3:4')
-        with self.assertRaisesMessage(ValidationError, "'This is not a valid IPv6 address.'"):
-            f.clean('1::2:3::4')
-        with self.assertRaisesMessage(ValidationError, "'This is not a valid IPv6 address.'"):
-            f.clean('foo::223:6cff:fe8a:2e8a')
-        with self.assertRaisesMessage(ValidationError, "'This is not a valid IPv6 address.'"):
-            f.clean('1::2:3:4:5:6:7:8')
-        with self.assertRaisesMessage(ValidationError, "'This is not a valid IPv6 address.'"):
-            f.clean('1:2')
+        self.assertEqual(f.clean(""), "")
+        self.assertEqual(f.clean(None), "")
+        self.assertEqual(f.clean("127.0.0.1"), "127.0.0.1")
+        with self.assertRaisesMessage(
+            ValidationError, "'Enter a valid IPv4 or IPv6 address.'"
+        ):
+            f.clean("foo")
+        with self.assertRaisesMessage(
+            ValidationError, "'Enter a valid IPv4 or IPv6 address.'"
+        ):
+            f.clean("127.0.0.")
+        with self.assertRaisesMessage(
+            ValidationError, "'Enter a valid IPv4 or IPv6 address.'"
+        ):
+            f.clean("1.2.3.4.5")
+        with self.assertRaisesMessage(
+            ValidationError, "'Enter a valid IPv4 or IPv6 address.'"
+        ):
+            f.clean("256.125.1.5")
+        self.assertEqual(
+            f.clean(" fe80::223:6cff:fe8a:2e8a "), "fe80::223:6cff:fe8a:2e8a"
+        )
+        self.assertEqual(
+            f.clean(" 2a02::223:6cff:fe8a:2e8a "), "2a02::223:6cff:fe8a:2e8a"
+        )
+        with self.assertRaisesMessage(
+            ValidationError, "'This is not a valid IPv6 address.'"
+        ):
+            f.clean("12345:2:3:4")
+        with self.assertRaisesMessage(
+            ValidationError, "'This is not a valid IPv6 address.'"
+        ):
+            f.clean("1::2:3::4")
+        with self.assertRaisesMessage(
+            ValidationError, "'This is not a valid IPv6 address.'"
+        ):
+            f.clean("foo::223:6cff:fe8a:2e8a")
+        with self.assertRaisesMessage(
+            ValidationError, "'This is not a valid IPv6 address.'"
+        ):
+            f.clean("1::2:3:4:5:6:7:8")
+        with self.assertRaisesMessage(
+            ValidationError, "'This is not a valid IPv6 address.'"
+        ):
+            f.clean("1:2")
 
     def test_generic_ipaddress_normalization(self):
         # Test the normalizing code
         f = GenericIPAddressField()
-        self.assertEqual(f.clean(' ::ffff:0a0a:0a0a  '), '::ffff:10.10.10.10')
-        self.assertEqual(f.clean(' ::ffff:10.10.10.10  '), '::ffff:10.10.10.10')
-        self.assertEqual(f.clean(' 2001:000:a:0000:0:fe:fe:beef  '), '2001:0:a::fe:fe:beef')
-        self.assertEqual(f.clean(' 2001::a:0000:0:fe:fe:beef  '), '2001:0:a::fe:fe:beef')
+        self.assertEqual(f.clean(" ::ffff:0a0a:0a0a  "), "::ffff:10.10.10.10")
+        self.assertEqual(f.clean(" ::ffff:10.10.10.10  "), "::ffff:10.10.10.10")
+        self.assertEqual(
+            f.clean(" 2001:000:a:0000:0:fe:fe:beef  "), "2001:0:a::fe:fe:beef"
+        )
+        self.assertEqual(
+            f.clean(" 2001::a:0000:0:fe:fe:beef  "), "2001:0:a::fe:fe:beef"
+        )
 
         f = GenericIPAddressField(unpack_ipv4=True)
-        self.assertEqual(f.clean(' ::ffff:0a0a:0a0a'), '10.10.10.10')
+        self.assertEqual(f.clean(" ::ffff:0a0a:0a0a"), "10.10.10.10")
diff --git a/tests/forms_tests/field_tests/test_imagefield.py b/tests/forms_tests/field_tests/test_imagefield.py
index 1cb34bf058..c138ee5c09 100644
--- a/tests/forms_tests/field_tests/test_imagefield.py
+++ b/tests/forms_tests/field_tests/test_imagefield.py
@@ -2,9 +2,7 @@ import os
 import unittest
 
 from django.core.exceptions import ValidationError
-from django.core.files.uploadedfile import (
-    SimpleUploadedFile, TemporaryUploadedFile,
-)
+from django.core.files.uploadedfile import SimpleUploadedFile, TemporaryUploadedFile
 from django.forms import ClearableFileInput, FileInput, ImageField, Widget
 from django.test import SimpleTestCase
 
@@ -17,26 +15,27 @@ except ImportError:
 
 
 def get_img_path(path):
-    return os.path.join(os.path.abspath(os.path.join(__file__, '..', '..')), 'tests', path)
+    return os.path.join(
+        os.path.abspath(os.path.join(__file__, "..", "..")), "tests", path
+    )
 
 
 @unittest.skipUnless(Image, "Pillow is required to test ImageField")
 class ImageFieldTest(FormFieldAssertionsMixin, SimpleTestCase):
-
     def test_imagefield_annotate_with_image_after_clean(self):
         f = ImageField()
 
-        img_path = get_img_path('filepath_test_files/1x1.png')
-        with open(img_path, 'rb') as img_file:
+        img_path = get_img_path("filepath_test_files/1x1.png")
+        with open(img_path, "rb") as img_file:
             img_data = img_file.read()
 
-        img_file = SimpleUploadedFile('1x1.png', img_data)
-        img_file.content_type = 'text/plain'
+        img_file = SimpleUploadedFile("1x1.png", img_data)
+        img_file.content_type = "text/plain"
 
         uploaded_file = f.clean(img_file)
 
-        self.assertEqual('PNG', uploaded_file.image.format)
-        self.assertEqual('image/png', uploaded_file.content_type)
+        self.assertEqual("PNG", uploaded_file.image.format)
+        self.assertEqual("image/png", uploaded_file.content_type)
 
     def test_imagefield_annotate_with_bitmap_image_after_clean(self):
         """
@@ -44,42 +43,47 @@ class ImageFieldTest(FormFieldAssertionsMixin, SimpleTestCase):
         of the image (#24948).
         """
         from PIL.BmpImagePlugin import BmpImageFile
+
         try:
             Image.register_mime(BmpImageFile.format, None)
             f = ImageField()
-            img_path = get_img_path('filepath_test_files/1x1.bmp')
-            with open(img_path, 'rb') as img_file:
+            img_path = get_img_path("filepath_test_files/1x1.bmp")
+            with open(img_path, "rb") as img_file:
                 img_data = img_file.read()
 
-            img_file = SimpleUploadedFile('1x1.bmp', img_data)
-            img_file.content_type = 'text/plain'
+            img_file = SimpleUploadedFile("1x1.bmp", img_data)
+            img_file.content_type = "text/plain"
 
             uploaded_file = f.clean(img_file)
 
-            self.assertEqual('BMP', uploaded_file.image.format)
+            self.assertEqual("BMP", uploaded_file.image.format)
             self.assertIsNone(uploaded_file.content_type)
         finally:
-            Image.register_mime(BmpImageFile.format, 'image/bmp')
+            Image.register_mime(BmpImageFile.format, "image/bmp")
 
     def test_file_extension_validation(self):
         f = ImageField()
-        img_path = get_img_path('filepath_test_files/1x1.png')
-        with open(img_path, 'rb') as img_file:
+        img_path = get_img_path("filepath_test_files/1x1.png")
+        with open(img_path, "rb") as img_file:
             img_data = img_file.read()
-        img_file = SimpleUploadedFile('1x1.txt', img_data)
-        with self.assertRaisesMessage(ValidationError, 'File extension “txt” is not allowed.'):
+        img_file = SimpleUploadedFile("1x1.txt", img_data)
+        with self.assertRaisesMessage(
+            ValidationError, "File extension “txt” is not allowed."
+        ):
             f.clean(img_file)
 
     def test_corrupted_image(self):
         f = ImageField()
-        img_file = SimpleUploadedFile('not_an_image.jpg', b'not an image')
+        img_file = SimpleUploadedFile("not_an_image.jpg", b"not an image")
         msg = (
-            'Upload a valid image. The file you uploaded was either not an '
-            'image or a corrupted image.'
+            "Upload a valid image. The file you uploaded was either not an "
+            "image or a corrupted image."
         )
         with self.assertRaisesMessage(ValidationError, msg):
             f.clean(img_file)
-        with TemporaryUploadedFile('not_an_image_tmp.png', 'text/plain', 1, 'utf-8') as tmp_file:
+        with TemporaryUploadedFile(
+            "not_an_image_tmp.png", "text/plain", 1, "utf-8"
+        ) as tmp_file:
             with self.assertRaisesMessage(ValidationError, msg):
                 f.clean(tmp_file)
 
@@ -87,16 +91,22 @@ class ImageFieldTest(FormFieldAssertionsMixin, SimpleTestCase):
         f = ImageField()
         # Nothing added for non-FileInput widgets.
         self.assertEqual(f.widget_attrs(Widget()), {})
-        self.assertEqual(f.widget_attrs(FileInput()), {'accept': 'image/*'})
-        self.assertEqual(f.widget_attrs(ClearableFileInput()), {'accept': 'image/*'})
-        self.assertWidgetRendersTo(f, '<input type="file" name="f" accept="image/*" required id="id_f" />')
+        self.assertEqual(f.widget_attrs(FileInput()), {"accept": "image/*"})
+        self.assertEqual(f.widget_attrs(ClearableFileInput()), {"accept": "image/*"})
+        self.assertWidgetRendersTo(
+            f, '<input type="file" name="f" accept="image/*" required id="id_f" />'
+        )
 
     def test_widget_attrs_accept_specified(self):
-        f = ImageField(widget=FileInput(attrs={'accept': 'image/png'}))
+        f = ImageField(widget=FileInput(attrs={"accept": "image/png"}))
         self.assertEqual(f.widget_attrs(f.widget), {})
-        self.assertWidgetRendersTo(f, '<input type="file" name="f" accept="image/png" required id="id_f" />')
+        self.assertWidgetRendersTo(
+            f, '<input type="file" name="f" accept="image/png" required id="id_f" />'
+        )
 
     def test_widget_attrs_accept_false(self):
-        f = ImageField(widget=FileInput(attrs={'accept': False}))
+        f = ImageField(widget=FileInput(attrs={"accept": False}))
         self.assertEqual(f.widget_attrs(f.widget), {})
-        self.assertWidgetRendersTo(f, '<input type="file" name="f" required id="id_f" />')
+        self.assertWidgetRendersTo(
+            f, '<input type="file" name="f" required id="id_f" />'
+        )
diff --git a/tests/forms_tests/field_tests/test_integerfield.py b/tests/forms_tests/field_tests/test_integerfield.py
index 0dde7ff488..15314d53a4 100644
--- a/tests/forms_tests/field_tests/test_integerfield.py
+++ b/tests/forms_tests/field_tests/test_integerfield.py
@@ -6,91 +6,108 @@ from . import FormFieldAssertionsMixin
 
 
 class IntegerFieldTest(FormFieldAssertionsMixin, SimpleTestCase):
-
     def test_integerfield_1(self):
         f = IntegerField()
-        self.assertWidgetRendersTo(f, '<input type="number" name="f" id="id_f" required>')
+        self.assertWidgetRendersTo(
+            f, '<input type="number" name="f" id="id_f" required>'
+        )
         with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
-            f.clean('')
+            f.clean("")
         with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
             f.clean(None)
-        self.assertEqual(1, f.clean('1'))
-        self.assertIsInstance(f.clean('1'), int)
-        self.assertEqual(23, f.clean('23'))
+        self.assertEqual(1, f.clean("1"))
+        self.assertIsInstance(f.clean("1"), int)
+        self.assertEqual(23, f.clean("23"))
         with self.assertRaisesMessage(ValidationError, "'Enter a whole number.'"):
-            f.clean('a')
+            f.clean("a")
         self.assertEqual(42, f.clean(42))
         with self.assertRaisesMessage(ValidationError, "'Enter a whole number.'"):
             f.clean(3.14)
-        self.assertEqual(1, f.clean('1 '))
-        self.assertEqual(1, f.clean(' 1'))
-        self.assertEqual(1, f.clean(' 1 '))
+        self.assertEqual(1, f.clean("1 "))
+        self.assertEqual(1, f.clean(" 1"))
+        self.assertEqual(1, f.clean(" 1 "))
         with self.assertRaisesMessage(ValidationError, "'Enter a whole number.'"):
-            f.clean('1a')
+            f.clean("1a")
         self.assertIsNone(f.max_value)
         self.assertIsNone(f.min_value)
 
     def test_integerfield_2(self):
         f = IntegerField(required=False)
-        self.assertIsNone(f.clean(''))
-        self.assertEqual('None', repr(f.clean('')))
+        self.assertIsNone(f.clean(""))
+        self.assertEqual("None", repr(f.clean("")))
         self.assertIsNone(f.clean(None))
-        self.assertEqual('None', repr(f.clean(None)))
-        self.assertEqual(1, f.clean('1'))
-        self.assertIsInstance(f.clean('1'), int)
-        self.assertEqual(23, f.clean('23'))
+        self.assertEqual("None", repr(f.clean(None)))
+        self.assertEqual(1, f.clean("1"))
+        self.assertIsInstance(f.clean("1"), int)
+        self.assertEqual(23, f.clean("23"))
         with self.assertRaisesMessage(ValidationError, "'Enter a whole number.'"):
-            f.clean('a')
-        self.assertEqual(1, f.clean('1 '))
-        self.assertEqual(1, f.clean(' 1'))
-        self.assertEqual(1, f.clean(' 1 '))
+            f.clean("a")
+        self.assertEqual(1, f.clean("1 "))
+        self.assertEqual(1, f.clean(" 1"))
+        self.assertEqual(1, f.clean(" 1 "))
         with self.assertRaisesMessage(ValidationError, "'Enter a whole number.'"):
-            f.clean('1a')
+            f.clean("1a")
         self.assertIsNone(f.max_value)
         self.assertIsNone(f.min_value)
 
     def test_integerfield_3(self):
         f = IntegerField(max_value=10)
-        self.assertWidgetRendersTo(f, '<input max="10" type="number" name="f" id="id_f" required>')
+        self.assertWidgetRendersTo(
+            f, '<input max="10" type="number" name="f" id="id_f" required>'
+        )
         with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
             f.clean(None)
         self.assertEqual(1, f.clean(1))
         self.assertEqual(10, f.clean(10))
-        with self.assertRaisesMessage(ValidationError, "'Ensure this value is less than or equal to 10.'"):
+        with self.assertRaisesMessage(
+            ValidationError, "'Ensure this value is less than or equal to 10.'"
+        ):
             f.clean(11)
-        self.assertEqual(10, f.clean('10'))
-        with self.assertRaisesMessage(ValidationError, "'Ensure this value is less than or equal to 10.'"):
-            f.clean('11')
+        self.assertEqual(10, f.clean("10"))
+        with self.assertRaisesMessage(
+            ValidationError, "'Ensure this value is less than or equal to 10.'"
+        ):
+            f.clean("11")
         self.assertEqual(f.max_value, 10)
         self.assertIsNone(f.min_value)
 
     def test_integerfield_4(self):
         f = IntegerField(min_value=10)
-        self.assertWidgetRendersTo(f, '<input id="id_f" type="number" name="f" min="10" required>')
+        self.assertWidgetRendersTo(
+            f, '<input id="id_f" type="number" name="f" min="10" required>'
+        )
         with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
             f.clean(None)
-        with self.assertRaisesMessage(ValidationError, "'Ensure this value is greater than or equal to 10.'"):
+        with self.assertRaisesMessage(
+            ValidationError, "'Ensure this value is greater than or equal to 10.'"
+        ):
             f.clean(1)
         self.assertEqual(10, f.clean(10))
         self.assertEqual(11, f.clean(11))
-        self.assertEqual(10, f.clean('10'))
-        self.assertEqual(11, f.clean('11'))
+        self.assertEqual(10, f.clean("10"))
+        self.assertEqual(11, f.clean("11"))
         self.assertIsNone(f.max_value)
         self.assertEqual(f.min_value, 10)
 
     def test_integerfield_5(self):
         f = IntegerField(min_value=10, max_value=20)
-        self.assertWidgetRendersTo(f, '<input id="id_f" max="20" type="number" name="f" min="10" required>')
+        self.assertWidgetRendersTo(
+            f, '<input id="id_f" max="20" type="number" name="f" min="10" required>'
+        )
         with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
             f.clean(None)
-        with self.assertRaisesMessage(ValidationError, "'Ensure this value is greater than or equal to 10.'"):
+        with self.assertRaisesMessage(
+            ValidationError, "'Ensure this value is greater than or equal to 10.'"
+        ):
             f.clean(1)
         self.assertEqual(10, f.clean(10))
         self.assertEqual(11, f.clean(11))
-        self.assertEqual(10, f.clean('10'))
-        self.assertEqual(11, f.clean('11'))
+        self.assertEqual(10, f.clean("10"))
+        self.assertEqual(11, f.clean("11"))
         self.assertEqual(20, f.clean(20))
-        with self.assertRaisesMessage(ValidationError, "'Ensure this value is less than or equal to 20.'"):
+        with self.assertRaisesMessage(
+            ValidationError, "'Ensure this value is less than or equal to 20.'"
+        ):
             f.clean(21)
         self.assertEqual(f.max_value, 20)
         self.assertEqual(f.min_value, 10)
@@ -101,34 +118,37 @@ class IntegerFieldTest(FormFieldAssertionsMixin, SimpleTestCase):
         number input specific attributes.
         """
         f1 = IntegerField(localize=True)
-        self.assertWidgetRendersTo(f1, '<input id="id_f" name="f" type="text" required>')
+        self.assertWidgetRendersTo(
+            f1, '<input id="id_f" name="f" type="text" required>'
+        )
 
     def test_integerfield_float(self):
         f = IntegerField()
         self.assertEqual(1, f.clean(1.0))
-        self.assertEqual(1, f.clean('1.0'))
-        self.assertEqual(1, f.clean(' 1.0 '))
-        self.assertEqual(1, f.clean('1.'))
-        self.assertEqual(1, f.clean(' 1. '))
+        self.assertEqual(1, f.clean("1.0"))
+        self.assertEqual(1, f.clean(" 1.0 "))
+        self.assertEqual(1, f.clean("1."))
+        self.assertEqual(1, f.clean(" 1. "))
         with self.assertRaisesMessage(ValidationError, "'Enter a whole number.'"):
-            f.clean('1.5')
+            f.clean("1.5")
         with self.assertRaisesMessage(ValidationError, "'Enter a whole number.'"):
-            f.clean('…')
+            f.clean("…")
 
     def test_integerfield_big_num(self):
         f = IntegerField()
         self.assertEqual(9223372036854775808, f.clean(9223372036854775808))
-        self.assertEqual(9223372036854775808, f.clean('9223372036854775808'))
-        self.assertEqual(9223372036854775808, f.clean('9223372036854775808.0'))
+        self.assertEqual(9223372036854775808, f.clean("9223372036854775808"))
+        self.assertEqual(9223372036854775808, f.clean("9223372036854775808.0"))
 
     def test_integerfield_unicode_number(self):
         f = IntegerField()
-        self.assertEqual(50, f.clean('５０'))
+        self.assertEqual(50, f.clean("５０"))
 
     def test_integerfield_subclass(self):
         """
         Class-defined widget is not overwritten by __init__() (#22245).
         """
+
         class MyIntegerField(IntegerField):
             widget = Textarea
 
diff --git a/tests/forms_tests/field_tests/test_jsonfield.py b/tests/forms_tests/field_tests/test_jsonfield.py
index b4f3e74f6a..be2b077e64 100644
--- a/tests/forms_tests/field_tests/test_jsonfield.py
+++ b/tests/forms_tests/field_tests/test_jsonfield.py
@@ -3,7 +3,12 @@ import uuid
 
 from django.core.serializers.json import DjangoJSONEncoder
 from django.forms import (
-    CharField, Form, JSONField, Textarea, TextInput, ValidationError,
+    CharField,
+    Form,
+    JSONField,
+    Textarea,
+    TextInput,
+    ValidationError,
 )
 from django.test import SimpleTestCase
 
@@ -12,25 +17,25 @@ class JSONFieldTest(SimpleTestCase):
     def test_valid(self):
         field = JSONField()
         value = field.clean('{"a": "b"}')
-        self.assertEqual(value, {'a': 'b'})
+        self.assertEqual(value, {"a": "b"})
 
     def test_valid_empty(self):
         field = JSONField(required=False)
-        self.assertIsNone(field.clean(''))
+        self.assertIsNone(field.clean(""))
         self.assertIsNone(field.clean(None))
 
     def test_invalid(self):
         field = JSONField()
-        with self.assertRaisesMessage(ValidationError, 'Enter a valid JSON.'):
-            field.clean('{some badly formed: json}')
+        with self.assertRaisesMessage(ValidationError, "Enter a valid JSON."):
+            field.clean("{some badly formed: json}")
 
     def test_prepare_value(self):
         field = JSONField()
-        self.assertEqual(field.prepare_value({'a': 'b'}), '{"a": "b"}')
-        self.assertEqual(field.prepare_value(None), 'null')
-        self.assertEqual(field.prepare_value('foo'), '"foo"')
-        self.assertEqual(field.prepare_value('你好，世界'), '"你好，世界"')
-        self.assertEqual(field.prepare_value({'a': '😀🐱'}), '{"a": "😀🐱"}')
+        self.assertEqual(field.prepare_value({"a": "b"}), '{"a": "b"}')
+        self.assertEqual(field.prepare_value(None), "null")
+        self.assertEqual(field.prepare_value("foo"), '"foo"')
+        self.assertEqual(field.prepare_value("你好，世界"), '"你好，世界"')
+        self.assertEqual(field.prepare_value({"a": "😀🐱"}), '{"a": "😀🐱"}')
         self.assertEqual(
             field.prepare_value(["你好，世界", "jaźń"]),
             '["你好，世界", "jaźń"]',
@@ -46,6 +51,7 @@ class JSONFieldTest(SimpleTestCase):
 
     def test_custom_widget_attribute(self):
         """The widget can be overridden with an attribute."""
+
         class CustomJSONField(JSONField):
             widget = TextInput
 
@@ -57,12 +63,12 @@ class JSONFieldTest(SimpleTestCase):
         tests = [
             '["a", "b", "c"]',
             '{"a": 1, "b": 2}',
-            '1',
-            '1.5',
+            "1",
+            "1.5",
             '"foo"',
-            'true',
-            'false',
-            'null',
+            "true",
+            "false",
+            "null",
         ]
         for json_string in tests:
             with self.subTest(json_string=json_string):
@@ -71,8 +77,8 @@ class JSONFieldTest(SimpleTestCase):
 
     def test_has_changed(self):
         field = JSONField()
-        self.assertIs(field.has_changed({'a': True}, '{"a": 1}'), True)
-        self.assertIs(field.has_changed({'a': 1, 'b': 2}, '{"b": 2, "a": 1}'), False)
+        self.assertIs(field.has_changed({"a": True}, '{"a": 1}'), True)
+        self.assertIs(field.has_changed({"a": 1, "b": 2}, '{"b": 2, "a": 1}'), False)
 
     def test_custom_encoder_decoder(self):
         class CustomDecoder(json.JSONDecoder):
@@ -80,11 +86,11 @@ class JSONFieldTest(SimpleTestCase):
                 return super().__init__(object_hook=self.as_uuid, *args, **kwargs)
 
             def as_uuid(self, dct):
-                if 'uuid' in dct:
-                    dct['uuid'] = uuid.UUID(dct['uuid'])
+                if "uuid" in dct:
+                    dct["uuid"] = uuid.UUID(dct["uuid"])
                 return dct
 
-        value = {'uuid': uuid.UUID('{c141e152-6550-4172-a784-05448d98204b}')}
+        value = {"uuid": uuid.UUID("{c141e152-6550-4172-a784-05448d98204b}")}
         encoded_value = '{"uuid": "c141e152-6550-4172-a784-05448d98204b"}'
         field = JSONField(encoder=DjangoJSONEncoder, decoder=CustomDecoder)
         self.assertEqual(field.prepare_value(value), encoded_value)
@@ -94,8 +100,8 @@ class JSONFieldTest(SimpleTestCase):
         class JSONForm(Form):
             json_field = JSONField(disabled=True)
 
-        form = JSONForm({'json_field': '["bar"]'}, initial={'json_field': ['foo']})
-        self.assertIn('[&quot;foo&quot;]</textarea>', form.as_p())
+        form = JSONForm({"json_field": '["bar"]'}, initial={"json_field": ["foo"]})
+        self.assertIn("[&quot;foo&quot;]</textarea>", form.as_p())
 
     def test_redisplay_none_input(self):
         class JSONForm(Form):
@@ -103,29 +109,30 @@ class JSONFieldTest(SimpleTestCase):
 
         tests = [
             {},
-            {'json_field': None},
+            {"json_field": None},
         ]
         for data in tests:
             with self.subTest(data=data):
                 form = JSONForm(data)
-                self.assertEqual(form['json_field'].value(), 'null')
-                self.assertIn('null</textarea>', form.as_p())
-                self.assertEqual(form.errors['json_field'], ['This field is required.'])
+                self.assertEqual(form["json_field"].value(), "null")
+                self.assertIn("null</textarea>", form.as_p())
+                self.assertEqual(form.errors["json_field"], ["This field is required."])
 
     def test_redisplay_wrong_input(self):
         """
         Displaying a bound form (typically due to invalid input). The form
         should not overquote JSONField inputs.
         """
+
         class JSONForm(Form):
             name = CharField(max_length=2)
             json_field = JSONField()
 
         # JSONField input is valid, name is too long.
-        form = JSONForm({'name': 'xyz', 'json_field': '["foo"]'})
-        self.assertNotIn('json_field', form.errors)
-        self.assertIn('[&quot;foo&quot;]</textarea>', form.as_p())
+        form = JSONForm({"name": "xyz", "json_field": '["foo"]'})
+        self.assertNotIn("json_field", form.errors)
+        self.assertIn("[&quot;foo&quot;]</textarea>", form.as_p())
         # Invalid JSONField.
-        form = JSONForm({'name': 'xy', 'json_field': '{"foo"}'})
-        self.assertEqual(form.errors['json_field'], ['Enter a valid JSON.'])
-        self.assertIn('{&quot;foo&quot;}</textarea>', form.as_p())
+        form = JSONForm({"name": "xy", "json_field": '{"foo"}'})
+        self.assertEqual(form.errors["json_field"], ["Enter a valid JSON."])
+        self.assertIn("{&quot;foo&quot;}</textarea>", form.as_p())
diff --git a/tests/forms_tests/field_tests/test_multiplechoicefield.py b/tests/forms_tests/field_tests/test_multiplechoicefield.py
index 6dbeee2685..f316e1de8e 100644
--- a/tests/forms_tests/field_tests/test_multiplechoicefield.py
+++ b/tests/forms_tests/field_tests/test_multiplechoicefield.py
@@ -4,72 +4,75 @@ from django.test import SimpleTestCase
 
 
 class MultipleChoiceFieldTest(SimpleTestCase):
-
     def test_multiplechoicefield_1(self):
-        f = MultipleChoiceField(choices=[('1', 'One'), ('2', 'Two')])
+        f = MultipleChoiceField(choices=[("1", "One"), ("2", "Two")])
         with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
-            f.clean('')
+            f.clean("")
         with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
             f.clean(None)
-        self.assertEqual(['1'], f.clean([1]))
-        self.assertEqual(['1'], f.clean(['1']))
-        self.assertEqual(['1', '2'], f.clean(['1', '2']))
-        self.assertEqual(['1', '2'], f.clean([1, '2']))
-        self.assertEqual(['1', '2'], f.clean((1, '2')))
+        self.assertEqual(["1"], f.clean([1]))
+        self.assertEqual(["1"], f.clean(["1"]))
+        self.assertEqual(["1", "2"], f.clean(["1", "2"]))
+        self.assertEqual(["1", "2"], f.clean([1, "2"]))
+        self.assertEqual(["1", "2"], f.clean((1, "2")))
         with self.assertRaisesMessage(ValidationError, "'Enter a list of values.'"):
-            f.clean('hello')
+            f.clean("hello")
         with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
             f.clean([])
         with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
             f.clean(())
         msg = "'Select a valid choice. 3 is not one of the available choices.'"
         with self.assertRaisesMessage(ValidationError, msg):
-            f.clean(['3'])
+            f.clean(["3"])
 
     def test_multiplechoicefield_2(self):
-        f = MultipleChoiceField(choices=[('1', 'One'), ('2', 'Two')], required=False)
-        self.assertEqual([], f.clean(''))
+        f = MultipleChoiceField(choices=[("1", "One"), ("2", "Two")], required=False)
+        self.assertEqual([], f.clean(""))
         self.assertEqual([], f.clean(None))
-        self.assertEqual(['1'], f.clean([1]))
-        self.assertEqual(['1'], f.clean(['1']))
-        self.assertEqual(['1', '2'], f.clean(['1', '2']))
-        self.assertEqual(['1', '2'], f.clean([1, '2']))
-        self.assertEqual(['1', '2'], f.clean((1, '2')))
+        self.assertEqual(["1"], f.clean([1]))
+        self.assertEqual(["1"], f.clean(["1"]))
+        self.assertEqual(["1", "2"], f.clean(["1", "2"]))
+        self.assertEqual(["1", "2"], f.clean([1, "2"]))
+        self.assertEqual(["1", "2"], f.clean((1, "2")))
         with self.assertRaisesMessage(ValidationError, "'Enter a list of values.'"):
-            f.clean('hello')
+            f.clean("hello")
         self.assertEqual([], f.clean([]))
         self.assertEqual([], f.clean(()))
         msg = "'Select a valid choice. 3 is not one of the available choices.'"
         with self.assertRaisesMessage(ValidationError, msg):
-            f.clean(['3'])
+            f.clean(["3"])
 
     def test_multiplechoicefield_3(self):
         f = MultipleChoiceField(
-            choices=[('Numbers', (('1', 'One'), ('2', 'Two'))), ('Letters', (('3', 'A'), ('4', 'B'))), ('5', 'Other')]
+            choices=[
+                ("Numbers", (("1", "One"), ("2", "Two"))),
+                ("Letters", (("3", "A"), ("4", "B"))),
+                ("5", "Other"),
+            ]
         )
-        self.assertEqual(['1'], f.clean([1]))
-        self.assertEqual(['1'], f.clean(['1']))
-        self.assertEqual(['1', '5'], f.clean([1, 5]))
-        self.assertEqual(['1', '5'], f.clean([1, '5']))
-        self.assertEqual(['1', '5'], f.clean(['1', 5]))
-        self.assertEqual(['1', '5'], f.clean(['1', '5']))
+        self.assertEqual(["1"], f.clean([1]))
+        self.assertEqual(["1"], f.clean(["1"]))
+        self.assertEqual(["1", "5"], f.clean([1, 5]))
+        self.assertEqual(["1", "5"], f.clean([1, "5"]))
+        self.assertEqual(["1", "5"], f.clean(["1", 5]))
+        self.assertEqual(["1", "5"], f.clean(["1", "5"]))
         msg = "'Select a valid choice. 6 is not one of the available choices.'"
         with self.assertRaisesMessage(ValidationError, msg):
-            f.clean(['6'])
+            f.clean(["6"])
         msg = "'Select a valid choice. 6 is not one of the available choices.'"
         with self.assertRaisesMessage(ValidationError, msg):
-            f.clean(['1', '6'])
+            f.clean(["1", "6"])
 
     def test_multiplechoicefield_changed(self):
-        f = MultipleChoiceField(choices=[('1', 'One'), ('2', 'Two'), ('3', 'Three')])
+        f = MultipleChoiceField(choices=[("1", "One"), ("2", "Two"), ("3", "Three")])
         self.assertFalse(f.has_changed(None, None))
         self.assertFalse(f.has_changed([], None))
-        self.assertTrue(f.has_changed(None, ['1']))
-        self.assertFalse(f.has_changed([1, 2], ['1', '2']))
-        self.assertFalse(f.has_changed([2, 1], ['1', '2']))
-        self.assertTrue(f.has_changed([1, 2], ['1']))
-        self.assertTrue(f.has_changed([1, 2], ['1', '3']))
+        self.assertTrue(f.has_changed(None, ["1"]))
+        self.assertFalse(f.has_changed([1, 2], ["1", "2"]))
+        self.assertFalse(f.has_changed([2, 1], ["1", "2"]))
+        self.assertTrue(f.has_changed([1, 2], ["1"]))
+        self.assertTrue(f.has_changed([1, 2], ["1", "3"]))
 
     def test_disabled_has_changed(self):
-        f = MultipleChoiceField(choices=[('1', 'One'), ('2', 'Two')], disabled=True)
-        self.assertIs(f.has_changed('x', 'y'), False)
+        f = MultipleChoiceField(choices=[("1", "One"), ("2", "Two")], disabled=True)
+        self.assertIs(f.has_changed("x", "y"), False)
diff --git a/tests/forms_tests/field_tests/test_multivaluefield.py b/tests/forms_tests/field_tests/test_multivaluefield.py
index 449bf16d19..88f7490013 100644
--- a/tests/forms_tests/field_tests/test_multivaluefield.py
+++ b/tests/forms_tests/field_tests/test_multivaluefield.py
@@ -2,17 +2,24 @@ from datetime import datetime
 
 from django.core.exceptions import ValidationError
 from django.forms import (
-    CharField, Form, MultipleChoiceField, MultiValueField, MultiWidget,
-    SelectMultiple, SplitDateTimeField, SplitDateTimeWidget, TextInput,
+    CharField,
+    Form,
+    MultipleChoiceField,
+    MultiValueField,
+    MultiWidget,
+    SelectMultiple,
+    SplitDateTimeField,
+    SplitDateTimeWidget,
+    TextInput,
 )
 from django.test import SimpleTestCase
 
-beatles = (('J', 'John'), ('P', 'Paul'), ('G', 'George'), ('R', 'Ringo'))
+beatles = (("J", "John"), ("P", "Paul"), ("G", "George"), ("R", "Ringo"))
 
 
 class PartiallyRequiredField(MultiValueField):
     def compress(self, data_list):
-        return ','.join(data_list) if data_list else None
+        return ",".join(data_list) if data_list else None
 
 
 class PartiallyRequiredForm(Form):
@@ -35,7 +42,7 @@ class ComplexMultiWidget(MultiWidget):
 
     def decompress(self, value):
         if value:
-            data = value.split(',')
+            data = value.split(",")
             return [
                 data[0],
                 list(data[1]),
@@ -55,7 +62,7 @@ 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
 
 
@@ -64,7 +71,6 @@ class ComplexFieldForm(Form):
 
 
 class MultiValueFieldTest(SimpleTestCase):
-
     @classmethod
     def setUpClass(cls):
         cls.field = ComplexField(widget=ComplexMultiWidget())
@@ -72,8 +78,8 @@ class MultiValueFieldTest(SimpleTestCase):
 
     def test_clean(self):
         self.assertEqual(
-            self.field.clean(['some text', ['J', 'P'], ['2007-04-25', '6:24:00']]),
-            'some text,JP,2007-04-25 06:24:00',
+            self.field.clean(["some text", ["J", "P"], ["2007-04-25", "6:24:00"]]),
+            "some text,JP,2007-04-25 06:24:00",
         )
 
     def test_clean_disabled_multivalue(self):
@@ -81,20 +87,20 @@ class MultiValueFieldTest(SimpleTestCase):
             f = ComplexField(disabled=True, widget=ComplexMultiWidget)
 
         inputs = (
-            'some text,JP,2007-04-25 06:24:00',
-            ['some text', ['J', 'P'], ['2007-04-25', '6:24:00']],
+            "some text,JP,2007-04-25 06:24:00",
+            ["some text", ["J", "P"], ["2007-04-25", "6:24:00"]],
         )
         for data in inputs:
             with self.subTest(data=data):
-                form = ComplexFieldForm({}, initial={'f': data})
+                form = ComplexFieldForm({}, initial={"f": data})
                 form.full_clean()
                 self.assertEqual(form.errors, {})
-                self.assertEqual(form.cleaned_data, {'f': inputs[0]})
+                self.assertEqual(form.cleaned_data, {"f": inputs[0]})
 
     def test_bad_choice(self):
         msg = "'Select a valid choice. X is not one of the available choices.'"
         with self.assertRaisesMessage(ValidationError, msg):
-            self.field.clean(['some text', ['X'], ['2007-04-25', '6:24:00']])
+            self.field.clean(["some text", ["X"], ["2007-04-25", "6:24:00"]])
 
     def test_no_value(self):
         """
@@ -102,39 +108,49 @@ class MultiValueFieldTest(SimpleTestCase):
         """
         msg = "'This field is required.'"
         with self.assertRaisesMessage(ValidationError, msg):
-            self.field.clean(['some text', ['JP']])
+            self.field.clean(["some text", ["JP"]])
 
     def test_has_changed_no_initial(self):
-        self.assertTrue(self.field.has_changed(None, ['some text', ['J', 'P'], ['2007-04-25', '6:24:00']]))
+        self.assertTrue(
+            self.field.has_changed(
+                None, ["some text", ["J", "P"], ["2007-04-25", "6:24:00"]]
+            )
+        )
 
     def test_has_changed_same(self):
-        self.assertFalse(self.field.has_changed(
-            'some text,JP,2007-04-25 06:24:00',
-            ['some text', ['J', 'P'], ['2007-04-25', '6:24:00']],
-        ))
+        self.assertFalse(
+            self.field.has_changed(
+                "some text,JP,2007-04-25 06:24:00",
+                ["some text", ["J", "P"], ["2007-04-25", "6:24:00"]],
+            )
+        )
 
     def test_has_changed_first_widget(self):
         """
         Test when the first widget's data has changed.
         """
-        self.assertTrue(self.field.has_changed(
-            'some text,JP,2007-04-25 06:24:00',
-            ['other text', ['J', 'P'], ['2007-04-25', '6:24:00']],
-        ))
+        self.assertTrue(
+            self.field.has_changed(
+                "some text,JP,2007-04-25 06:24:00",
+                ["other text", ["J", "P"], ["2007-04-25", "6:24:00"]],
+            )
+        )
 
     def test_has_changed_last_widget(self):
         """
         Test when the last widget's data has changed. This ensures that it is
         not short circuiting while testing the widgets.
         """
-        self.assertTrue(self.field.has_changed(
-            'some text,JP,2007-04-25 06:24:00',
-            ['some text', ['J', 'P'], ['2009-04-25', '11:44:00']],
-        ))
+        self.assertTrue(
+            self.field.has_changed(
+                "some text,JP,2007-04-25 06:24:00",
+                ["some text", ["J", "P"], ["2009-04-25", "11:44:00"]],
+            )
+        )
 
     def test_disabled_has_changed(self):
         f = MultiValueField(fields=(CharField(), CharField()), disabled=True)
-        self.assertIs(f.has_changed(['x', 'x'], ['y', 'y']), False)
+        self.assertIs(f.has_changed(["x", "x"], ["y", "y"]), False)
 
     def test_form_as_table(self):
         form = ComplexFieldForm()
@@ -155,12 +171,14 @@ class MultiValueFieldTest(SimpleTestCase):
         )
 
     def test_form_as_table_data(self):
-        form = ComplexFieldForm({
-            'field1_0': 'some text',
-            'field1_1': ['J', 'P'],
-            'field1_2_0': '2007-04-25',
-            'field1_2_1': '06:24:00',
-        })
+        form = ComplexFieldForm(
+            {
+                "field1_0": "some text",
+                "field1_1": ["J", "P"],
+                "field1_2_0": "2007-04-25",
+                "field1_2_1": "06:24:00",
+            }
+        )
         self.assertHTMLEqual(
             form.as_table(),
             """
@@ -178,19 +196,26 @@ class MultiValueFieldTest(SimpleTestCase):
         )
 
     def test_form_cleaned_data(self):
-        form = ComplexFieldForm({
-            'field1_0': 'some text',
-            'field1_1': ['J', 'P'],
-            'field1_2_0': '2007-04-25',
-            'field1_2_1': '06:24:00',
-        })
+        form = ComplexFieldForm(
+            {
+                "field1_0": "some text",
+                "field1_1": ["J", "P"],
+                "field1_2_0": "2007-04-25",
+                "field1_2_1": "06:24:00",
+            }
+        )
         form.is_valid()
-        self.assertEqual(form.cleaned_data['field1'], 'some text,JP,2007-04-25 06:24:00')
+        self.assertEqual(
+            form.cleaned_data["field1"], "some text,JP,2007-04-25 06:24:00"
+        )
 
     def test_render_required_attributes(self):
-        form = PartiallyRequiredForm({'f_0': 'Hello', 'f_1': ''})
+        form = PartiallyRequiredForm({"f_0": "Hello", "f_1": ""})
         self.assertTrue(form.is_valid())
-        self.assertInHTML('<input type="text" name="f_0" value="Hello" required id="id_f_0">', form.as_p())
+        self.assertInHTML(
+            '<input type="text" name="f_0" value="Hello" required id="id_f_0">',
+            form.as_p(),
+        )
         self.assertInHTML('<input type="text" name="f_1" id="id_f_1">', form.as_p())
-        form = PartiallyRequiredForm({'f_0': '', 'f_1': ''})
+        form = PartiallyRequiredForm({"f_0": "", "f_1": ""})
         self.assertFalse(form.is_valid())
diff --git a/tests/forms_tests/field_tests/test_nullbooleanfield.py b/tests/forms_tests/field_tests/test_nullbooleanfield.py
index 55812612c9..5b632c8de3 100644
--- a/tests/forms_tests/field_tests/test_nullbooleanfield.py
+++ b/tests/forms_tests/field_tests/test_nullbooleanfield.py
@@ -5,56 +5,60 @@ from . import FormFieldAssertionsMixin
 
 
 class NullBooleanFieldTest(FormFieldAssertionsMixin, SimpleTestCase):
-
     def test_nullbooleanfield_clean(self):
         f = NullBooleanField()
-        self.assertIsNone(f.clean(''))
+        self.assertIsNone(f.clean(""))
         self.assertTrue(f.clean(True))
         self.assertFalse(f.clean(False))
         self.assertIsNone(f.clean(None))
-        self.assertFalse(f.clean('0'))
-        self.assertTrue(f.clean('1'))
-        self.assertIsNone(f.clean('2'))
-        self.assertIsNone(f.clean('3'))
-        self.assertIsNone(f.clean('hello'))
-        self.assertTrue(f.clean('true'))
-        self.assertFalse(f.clean('false'))
+        self.assertFalse(f.clean("0"))
+        self.assertTrue(f.clean("1"))
+        self.assertIsNone(f.clean("2"))
+        self.assertIsNone(f.clean("3"))
+        self.assertIsNone(f.clean("hello"))
+        self.assertTrue(f.clean("true"))
+        self.assertFalse(f.clean("false"))
 
     def test_nullbooleanfield_2(self):
         # The internal value is preserved if using HiddenInput (#7753).
         class HiddenNullBooleanForm(Form):
             hidden_nullbool1 = NullBooleanField(widget=HiddenInput, initial=True)
             hidden_nullbool2 = NullBooleanField(widget=HiddenInput, initial=False)
+
         f = HiddenNullBooleanForm()
         self.assertHTMLEqual(
             '<input type="hidden" name="hidden_nullbool1" value="True" id="id_hidden_nullbool1">'
             '<input type="hidden" name="hidden_nullbool2" value="False" id="id_hidden_nullbool2">',
-            str(f)
+            str(f),
         )
 
     def test_nullbooleanfield_3(self):
         class HiddenNullBooleanForm(Form):
             hidden_nullbool1 = NullBooleanField(widget=HiddenInput, initial=True)
             hidden_nullbool2 = NullBooleanField(widget=HiddenInput, initial=False)
-        f = HiddenNullBooleanForm({'hidden_nullbool1': 'True', 'hidden_nullbool2': 'False'})
+
+        f = HiddenNullBooleanForm(
+            {"hidden_nullbool1": "True", "hidden_nullbool2": "False"}
+        )
         self.assertIsNone(f.full_clean())
-        self.assertTrue(f.cleaned_data['hidden_nullbool1'])
-        self.assertFalse(f.cleaned_data['hidden_nullbool2'])
+        self.assertTrue(f.cleaned_data["hidden_nullbool1"])
+        self.assertFalse(f.cleaned_data["hidden_nullbool2"])
 
     def test_nullbooleanfield_4(self):
         # Make sure we're compatible with MySQL, which uses 0 and 1 for its
         # boolean values (#9609).
-        NULLBOOL_CHOICES = (('1', 'Yes'), ('0', 'No'), ('', 'Unknown'))
+        NULLBOOL_CHOICES = (("1", "Yes"), ("0", "No"), ("", "Unknown"))
 
         class MySQLNullBooleanForm(Form):
             nullbool0 = NullBooleanField(widget=RadioSelect(choices=NULLBOOL_CHOICES))
             nullbool1 = NullBooleanField(widget=RadioSelect(choices=NULLBOOL_CHOICES))
             nullbool2 = NullBooleanField(widget=RadioSelect(choices=NULLBOOL_CHOICES))
-        f = MySQLNullBooleanForm({'nullbool0': '1', 'nullbool1': '0', 'nullbool2': ''})
+
+        f = MySQLNullBooleanForm({"nullbool0": "1", "nullbool1": "0", "nullbool2": ""})
         self.assertIsNone(f.full_clean())
-        self.assertTrue(f.cleaned_data['nullbool0'])
-        self.assertFalse(f.cleaned_data['nullbool1'])
-        self.assertIsNone(f.cleaned_data['nullbool2'])
+        self.assertTrue(f.cleaned_data["nullbool0"])
+        self.assertFalse(f.cleaned_data["nullbool1"])
+        self.assertIsNone(f.cleaned_data["nullbool2"])
 
     def test_nullbooleanfield_changed(self):
         f = NullBooleanField()
@@ -66,9 +70,9 @@ class NullBooleanFieldTest(FormFieldAssertionsMixin, SimpleTestCase):
         self.assertTrue(f.has_changed(True, None))
         self.assertTrue(f.has_changed(True, False))
         # HiddenInput widget sends string values for boolean but doesn't clean them in value_from_datadict
-        self.assertFalse(f.has_changed(False, 'False'))
-        self.assertFalse(f.has_changed(True, 'True'))
-        self.assertFalse(f.has_changed(None, ''))
-        self.assertTrue(f.has_changed(False, 'True'))
-        self.assertTrue(f.has_changed(True, 'False'))
-        self.assertTrue(f.has_changed(None, 'False'))
+        self.assertFalse(f.has_changed(False, "False"))
+        self.assertFalse(f.has_changed(True, "True"))
+        self.assertFalse(f.has_changed(None, ""))
+        self.assertTrue(f.has_changed(False, "True"))
+        self.assertTrue(f.has_changed(True, "False"))
+        self.assertTrue(f.has_changed(None, "False"))
diff --git a/tests/forms_tests/field_tests/test_regexfield.py b/tests/forms_tests/field_tests/test_regexfield.py
index 80d0f1c7cd..9a2b1387f6 100644
--- a/tests/forms_tests/field_tests/test_regexfield.py
+++ b/tests/forms_tests/field_tests/test_regexfield.py
@@ -6,80 +6,84 @@ from django.test import SimpleTestCase
 
 
 class RegexFieldTest(SimpleTestCase):
-
     def test_regexfield_1(self):
-        f = RegexField('^[0-9][A-F][0-9]$')
-        self.assertEqual('2A2', f.clean('2A2'))
-        self.assertEqual('3F3', f.clean('3F3'))
+        f = RegexField("^[0-9][A-F][0-9]$")
+        self.assertEqual("2A2", f.clean("2A2"))
+        self.assertEqual("3F3", f.clean("3F3"))
         with self.assertRaisesMessage(ValidationError, "'Enter a valid value.'"):
-            f.clean('3G3')
+            f.clean("3G3")
         with self.assertRaisesMessage(ValidationError, "'Enter a valid value.'"):
-            f.clean(' 2A2')
+            f.clean(" 2A2")
         with self.assertRaisesMessage(ValidationError, "'Enter a valid value.'"):
-            f.clean('2A2 ')
+            f.clean("2A2 ")
         with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
-            f.clean('')
+            f.clean("")
 
     def test_regexfield_2(self):
-        f = RegexField('^[0-9][A-F][0-9]$', required=False)
-        self.assertEqual('2A2', f.clean('2A2'))
-        self.assertEqual('3F3', f.clean('3F3'))
+        f = RegexField("^[0-9][A-F][0-9]$", required=False)
+        self.assertEqual("2A2", f.clean("2A2"))
+        self.assertEqual("3F3", f.clean("3F3"))
         with self.assertRaisesMessage(ValidationError, "'Enter a valid value.'"):
-            f.clean('3G3')
-        self.assertEqual('', f.clean(''))
+            f.clean("3G3")
+        self.assertEqual("", f.clean(""))
 
     def test_regexfield_3(self):
-        f = RegexField(re.compile('^[0-9][A-F][0-9]$'))
-        self.assertEqual('2A2', f.clean('2A2'))
-        self.assertEqual('3F3', f.clean('3F3'))
+        f = RegexField(re.compile("^[0-9][A-F][0-9]$"))
+        self.assertEqual("2A2", f.clean("2A2"))
+        self.assertEqual("3F3", f.clean("3F3"))
         with self.assertRaisesMessage(ValidationError, "'Enter a valid value.'"):
-            f.clean('3G3')
+            f.clean("3G3")
         with self.assertRaisesMessage(ValidationError, "'Enter a valid value.'"):
-            f.clean(' 2A2')
+            f.clean(" 2A2")
         with self.assertRaisesMessage(ValidationError, "'Enter a valid value.'"):
-            f.clean('2A2 ')
+            f.clean("2A2 ")
 
     def test_regexfield_4(self):
-        f = RegexField('^[0-9]+$', min_length=5, max_length=10)
-        with self.assertRaisesMessage(ValidationError, "'Ensure this value has at least 5 characters (it has 3).'"):
-            f.clean('123')
+        f = RegexField("^[0-9]+$", min_length=5, max_length=10)
+        with self.assertRaisesMessage(
+            ValidationError, "'Ensure this value has at least 5 characters (it has 3).'"
+        ):
+            f.clean("123")
         with self.assertRaisesMessage(
             ValidationError,
             "'Ensure this value has at least 5 characters (it has 3).', "
             "'Enter a valid value.'",
         ):
-            f.clean('abc')
-        self.assertEqual('12345', f.clean('12345'))
-        self.assertEqual('1234567890', f.clean('1234567890'))
-        with self.assertRaisesMessage(ValidationError, "'Ensure this value has at most 10 characters (it has 11).'"):
-            f.clean('12345678901')
+            f.clean("abc")
+        self.assertEqual("12345", f.clean("12345"))
+        self.assertEqual("1234567890", f.clean("1234567890"))
+        with self.assertRaisesMessage(
+            ValidationError,
+            "'Ensure this value has at most 10 characters (it has 11).'",
+        ):
+            f.clean("12345678901")
         with self.assertRaisesMessage(ValidationError, "'Enter a valid value.'"):
-            f.clean('12345a')
+            f.clean("12345a")
 
     def test_regexfield_unicode_characters(self):
-        f = RegexField(r'^\w+$')
-        self.assertEqual('éèøçÎÎ你好', f.clean('éèøçÎÎ你好'))
+        f = RegexField(r"^\w+$")
+        self.assertEqual("éèøçÎÎ你好", f.clean("éèøçÎÎ你好"))
 
     def test_change_regex_after_init(self):
-        f = RegexField('^[a-z]+$')
-        f.regex = '^[0-9]+$'
-        self.assertEqual('1234', f.clean('1234'))
+        f = RegexField("^[a-z]+$")
+        f.regex = "^[0-9]+$"
+        self.assertEqual("1234", f.clean("1234"))
         with self.assertRaisesMessage(ValidationError, "'Enter a valid value.'"):
-            f.clean('abcd')
+            f.clean("abcd")
 
     def test_get_regex(self):
-        f = RegexField('^[a-z]+$')
-        self.assertEqual(f.regex, re.compile('^[a-z]+$'))
+        f = RegexField("^[a-z]+$")
+        self.assertEqual(f.regex, re.compile("^[a-z]+$"))
 
     def test_regexfield_strip(self):
-        f = RegexField('^[a-z]+$', strip=True)
-        self.assertEqual(f.clean(' a'), 'a')
-        self.assertEqual(f.clean('a '), 'a')
+        f = RegexField("^[a-z]+$", strip=True)
+        self.assertEqual(f.clean(" a"), "a")
+        self.assertEqual(f.clean("a "), "a")
 
     def test_empty_value(self):
-        f = RegexField('', required=False)
-        self.assertEqual(f.clean(''), '')
-        self.assertEqual(f.clean(None), '')
-        f = RegexField('', empty_value=None, required=False)
-        self.assertIsNone(f.clean(''))
+        f = RegexField("", required=False)
+        self.assertEqual(f.clean(""), "")
+        self.assertEqual(f.clean(None), "")
+        f = RegexField("", empty_value=None, required=False)
+        self.assertIsNone(f.clean(""))
         self.assertIsNone(f.clean(None))
diff --git a/tests/forms_tests/field_tests/test_slugfield.py b/tests/forms_tests/field_tests/test_slugfield.py
index 6d766e8af5..d796a2c3aa 100644
--- a/tests/forms_tests/field_tests/test_slugfield.py
+++ b/tests/forms_tests/field_tests/test_slugfield.py
@@ -3,25 +3,24 @@ from django.test import SimpleTestCase
 
 
 class SlugFieldTest(SimpleTestCase):
-
     def test_slugfield_normalization(self):
         f = SlugField()
-        self.assertEqual(f.clean('    aa-bb-cc    '), 'aa-bb-cc')
+        self.assertEqual(f.clean("    aa-bb-cc    "), "aa-bb-cc")
 
     def test_slugfield_unicode_normalization(self):
         f = SlugField(allow_unicode=True)
-        self.assertEqual(f.clean('a'), 'a')
-        self.assertEqual(f.clean('1'), '1')
-        self.assertEqual(f.clean('a1'), 'a1')
-        self.assertEqual(f.clean('你好'), '你好')
-        self.assertEqual(f.clean('  你-好  '), '你-好')
-        self.assertEqual(f.clean('ıçğüş'), 'ıçğüş')
-        self.assertEqual(f.clean('foo-ıç-bar'), 'foo-ıç-bar')
+        self.assertEqual(f.clean("a"), "a")
+        self.assertEqual(f.clean("1"), "1")
+        self.assertEqual(f.clean("a1"), "a1")
+        self.assertEqual(f.clean("你好"), "你好")
+        self.assertEqual(f.clean("  你-好  "), "你-好")
+        self.assertEqual(f.clean("ıçğüş"), "ıçğüş")
+        self.assertEqual(f.clean("foo-ıç-bar"), "foo-ıç-bar")
 
     def test_empty_value(self):
         f = SlugField(required=False)
-        self.assertEqual(f.clean(''), '')
-        self.assertEqual(f.clean(None), '')
+        self.assertEqual(f.clean(""), "")
+        self.assertEqual(f.clean(None), "")
         f = SlugField(required=False, empty_value=None)
-        self.assertIsNone(f.clean(''))
+        self.assertIsNone(f.clean(""))
         self.assertIsNone(f.clean(None))
diff --git a/tests/forms_tests/field_tests/test_splitdatetimefield.py b/tests/forms_tests/field_tests/test_splitdatetimefield.py
index bf20587682..788ca592fa 100644
--- a/tests/forms_tests/field_tests/test_splitdatetimefield.py
+++ b/tests/forms_tests/field_tests/test_splitdatetimefield.py
@@ -7,59 +7,78 @@ from django.test import SimpleTestCase
 
 
 class SplitDateTimeFieldTest(SimpleTestCase):
-
     def test_splitdatetimefield_1(self):
         f = SplitDateTimeField()
         self.assertIsInstance(f.widget, SplitDateTimeWidget)
         self.assertEqual(
             datetime.datetime(2006, 1, 10, 7, 30),
-            f.clean([datetime.date(2006, 1, 10), datetime.time(7, 30)])
+            f.clean([datetime.date(2006, 1, 10), datetime.time(7, 30)]),
         )
         with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
             f.clean(None)
         with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
-            f.clean('')
+            f.clean("")
         with self.assertRaisesMessage(ValidationError, "'Enter a list of values.'"):
-            f.clean('hello')
-        with self.assertRaisesMessage(ValidationError, "'Enter a valid date.', 'Enter a valid time.'"):
-            f.clean(['hello', 'there'])
+            f.clean("hello")
+        with self.assertRaisesMessage(
+            ValidationError, "'Enter a valid date.', 'Enter a valid time.'"
+        ):
+            f.clean(["hello", "there"])
         with self.assertRaisesMessage(ValidationError, "'Enter a valid time.'"):
-            f.clean(['2006-01-10', 'there'])
+            f.clean(["2006-01-10", "there"])
         with self.assertRaisesMessage(ValidationError, "'Enter a valid date.'"):
-            f.clean(['hello', '07:30'])
+            f.clean(["hello", "07:30"])
 
     def test_splitdatetimefield_2(self):
         f = SplitDateTimeField(required=False)
         self.assertEqual(
             datetime.datetime(2006, 1, 10, 7, 30),
-            f.clean([datetime.date(2006, 1, 10), datetime.time(7, 30)])
+            f.clean([datetime.date(2006, 1, 10), datetime.time(7, 30)]),
+        )
+        self.assertEqual(
+            datetime.datetime(2006, 1, 10, 7, 30), f.clean(["2006-01-10", "07:30"])
         )
-        self.assertEqual(datetime.datetime(2006, 1, 10, 7, 30), f.clean(['2006-01-10', '07:30']))
         self.assertIsNone(f.clean(None))
-        self.assertIsNone(f.clean(''))
-        self.assertIsNone(f.clean(['']))
-        self.assertIsNone(f.clean(['', '']))
+        self.assertIsNone(f.clean(""))
+        self.assertIsNone(f.clean([""]))
+        self.assertIsNone(f.clean(["", ""]))
         with self.assertRaisesMessage(ValidationError, "'Enter a list of values.'"):
-            f.clean('hello')
-        with self.assertRaisesMessage(ValidationError, "'Enter a valid date.', 'Enter a valid time.'"):
-            f.clean(['hello', 'there'])
+            f.clean("hello")
+        with self.assertRaisesMessage(
+            ValidationError, "'Enter a valid date.', 'Enter a valid time.'"
+        ):
+            f.clean(["hello", "there"])
         with self.assertRaisesMessage(ValidationError, "'Enter a valid time.'"):
-            f.clean(['2006-01-10', 'there'])
+            f.clean(["2006-01-10", "there"])
         with self.assertRaisesMessage(ValidationError, "'Enter a valid date.'"):
-            f.clean(['hello', '07:30'])
+            f.clean(["hello", "07:30"])
         with self.assertRaisesMessage(ValidationError, "'Enter a valid time.'"):
-            f.clean(['2006-01-10', ''])
+            f.clean(["2006-01-10", ""])
         with self.assertRaisesMessage(ValidationError, "'Enter a valid time.'"):
-            f.clean(['2006-01-10'])
+            f.clean(["2006-01-10"])
         with self.assertRaisesMessage(ValidationError, "'Enter a valid date.'"):
-            f.clean(['', '07:30'])
+            f.clean(["", "07:30"])
 
     def test_splitdatetimefield_changed(self):
-        f = SplitDateTimeField(input_date_formats=['%d/%m/%Y'])
-        self.assertFalse(f.has_changed(['11/01/2012', '09:18:15'], ['11/01/2012', '09:18:15']))
-        self.assertTrue(f.has_changed(datetime.datetime(2008, 5, 6, 12, 40, 00), ['2008-05-06', '12:40:00']))
-        self.assertFalse(f.has_changed(datetime.datetime(2008, 5, 6, 12, 40, 00), ['06/05/2008', '12:40']))
-        self.assertTrue(f.has_changed(datetime.datetime(2008, 5, 6, 12, 40, 00), ['06/05/2008', '12:41']))
+        f = SplitDateTimeField(input_date_formats=["%d/%m/%Y"])
+        self.assertFalse(
+            f.has_changed(["11/01/2012", "09:18:15"], ["11/01/2012", "09:18:15"])
+        )
+        self.assertTrue(
+            f.has_changed(
+                datetime.datetime(2008, 5, 6, 12, 40, 00), ["2008-05-06", "12:40:00"]
+            )
+        )
+        self.assertFalse(
+            f.has_changed(
+                datetime.datetime(2008, 5, 6, 12, 40, 00), ["06/05/2008", "12:40"]
+            )
+        )
+        self.assertTrue(
+            f.has_changed(
+                datetime.datetime(2008, 5, 6, 12, 40, 00), ["06/05/2008", "12:41"]
+            )
+        )
 
     def test_form_as_table(self):
         class TestForm(Form):
@@ -68,8 +87,8 @@ class SplitDateTimeFieldTest(SimpleTestCase):
         f = TestForm()
         self.assertHTMLEqual(
             f.as_table(),
-            '<tr><th><label>Datetime:</label></th><td>'
+            "<tr><th><label>Datetime:</label></th><td>"
             '<input type="text" name="datetime_0" required id="id_datetime_0">'
             '<input type="text" name="datetime_1" required id="id_datetime_1">'
-            '</td></tr>',
+            "</td></tr>",
         )
diff --git a/tests/forms_tests/field_tests/test_timefield.py b/tests/forms_tests/field_tests/test_timefield.py
index a44b10fa07..fbe6a3cf31 100644
--- a/tests/forms_tests/field_tests/test_timefield.py
+++ b/tests/forms_tests/field_tests/test_timefield.py
@@ -8,39 +8,38 @@ from . import FormFieldAssertionsMixin
 
 
 class TimeFieldTest(FormFieldAssertionsMixin, SimpleTestCase):
-
     def test_timefield_1(self):
         f = TimeField()
         self.assertEqual(datetime.time(14, 25), f.clean(datetime.time(14, 25)))
         self.assertEqual(datetime.time(14, 25, 59), f.clean(datetime.time(14, 25, 59)))
-        self.assertEqual(datetime.time(14, 25), f.clean('14:25'))
-        self.assertEqual(datetime.time(14, 25, 59), f.clean('14:25:59'))
+        self.assertEqual(datetime.time(14, 25), f.clean("14:25"))
+        self.assertEqual(datetime.time(14, 25, 59), f.clean("14:25:59"))
         with self.assertRaisesMessage(ValidationError, "'Enter a valid time.'"):
-            f.clean('hello')
+            f.clean("hello")
         with self.assertRaisesMessage(ValidationError, "'Enter a valid time.'"):
-            f.clean('1:24 p.m.')
+            f.clean("1:24 p.m.")
 
     def test_timefield_2(self):
-        f = TimeField(input_formats=['%I:%M %p'])
+        f = TimeField(input_formats=["%I:%M %p"])
         self.assertEqual(datetime.time(14, 25), f.clean(datetime.time(14, 25)))
         self.assertEqual(datetime.time(14, 25, 59), f.clean(datetime.time(14, 25, 59)))
-        self.assertEqual(datetime.time(4, 25), f.clean('4:25 AM'))
-        self.assertEqual(datetime.time(16, 25), f.clean('4:25 PM'))
+        self.assertEqual(datetime.time(4, 25), f.clean("4:25 AM"))
+        self.assertEqual(datetime.time(16, 25), f.clean("4:25 PM"))
         with self.assertRaisesMessage(ValidationError, "'Enter a valid time.'"):
-            f.clean('14:30:45')
+            f.clean("14:30:45")
 
     def test_timefield_3(self):
         f = TimeField()
         # Test whitespace stripping behavior (#5714)
-        self.assertEqual(datetime.time(14, 25), f.clean(' 14:25 '))
-        self.assertEqual(datetime.time(14, 25, 59), f.clean(' 14:25:59 '))
+        self.assertEqual(datetime.time(14, 25), f.clean(" 14:25 "))
+        self.assertEqual(datetime.time(14, 25, 59), f.clean(" 14:25:59 "))
         with self.assertRaisesMessage(ValidationError, "'Enter a valid time.'"):
-            f.clean('   ')
+            f.clean("   ")
 
     def test_timefield_changed(self):
         t1 = datetime.time(12, 51, 34, 482548)
         t2 = datetime.time(12, 51)
-        f = TimeField(input_formats=['%H:%M', '%H:%M %p'])
-        self.assertTrue(f.has_changed(t1, '12:51'))
-        self.assertFalse(f.has_changed(t2, '12:51'))
-        self.assertFalse(f.has_changed(t2, '12:51 PM'))
+        f = TimeField(input_formats=["%H:%M", "%H:%M %p"])
+        self.assertTrue(f.has_changed(t1, "12:51"))
+        self.assertFalse(f.has_changed(t2, "12:51"))
+        self.assertFalse(f.has_changed(t2, "12:51 PM"))
diff --git a/tests/forms_tests/field_tests/test_typedchoicefield.py b/tests/forms_tests/field_tests/test_typedchoicefield.py
index 2c6cd265b5..52a83eca37 100644
--- a/tests/forms_tests/field_tests/test_typedchoicefield.py
+++ b/tests/forms_tests/field_tests/test_typedchoicefield.py
@@ -6,72 +6,84 @@ from django.test import SimpleTestCase
 
 
 class TypedChoiceFieldTest(SimpleTestCase):
-
     def test_typedchoicefield_1(self):
         f = TypedChoiceField(choices=[(1, "+1"), (-1, "-1")], coerce=int)
-        self.assertEqual(1, f.clean('1'))
+        self.assertEqual(1, f.clean("1"))
         msg = "'Select a valid choice. 2 is not one of the available choices.'"
         with self.assertRaisesMessage(ValidationError, msg):
-            f.clean('2')
+            f.clean("2")
 
     def test_typedchoicefield_2(self):
         # Different coercion, same validation.
         f = TypedChoiceField(choices=[(1, "+1"), (-1, "-1")], coerce=float)
-        self.assertEqual(1.0, f.clean('1'))
+        self.assertEqual(1.0, f.clean("1"))
 
     def test_typedchoicefield_3(self):
         # This can also cause weirdness: be careful (bool(-1) == True, remember)
         f = TypedChoiceField(choices=[(1, "+1"), (-1, "-1")], coerce=bool)
-        self.assertTrue(f.clean('-1'))
+        self.assertTrue(f.clean("-1"))
 
     def test_typedchoicefield_4(self):
         # Even more weirdness: if you have a valid choice but your coercion function
         # can't coerce, you'll still get a validation error. Don't do this!
-        f = TypedChoiceField(choices=[('A', 'A'), ('B', 'B')], coerce=int)
+        f = TypedChoiceField(choices=[("A", "A"), ("B", "B")], coerce=int)
         msg = "'Select a valid choice. B is not one of the available choices.'"
         with self.assertRaisesMessage(ValidationError, msg):
-            f.clean('B')
+            f.clean("B")
         # Required fields require values
         with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
-            f.clean('')
+            f.clean("")
 
     def test_typedchoicefield_5(self):
         # Non-required fields aren't required
-        f = TypedChoiceField(choices=[(1, "+1"), (-1, "-1")], coerce=int, required=False)
-        self.assertEqual('', f.clean(''))
+        f = TypedChoiceField(
+            choices=[(1, "+1"), (-1, "-1")], coerce=int, required=False
+        )
+        self.assertEqual("", f.clean(""))
         # If you want cleaning an empty value to return a different type, tell the field
 
     def test_typedchoicefield_6(self):
-        f = TypedChoiceField(choices=[(1, "+1"), (-1, "-1")], coerce=int, required=False, empty_value=None)
-        self.assertIsNone(f.clean(''))
+        f = TypedChoiceField(
+            choices=[(1, "+1"), (-1, "-1")],
+            coerce=int,
+            required=False,
+            empty_value=None,
+        )
+        self.assertIsNone(f.clean(""))
 
     def test_typedchoicefield_has_changed(self):
         # has_changed should not trigger required validation
         f = TypedChoiceField(choices=[(1, "+1"), (-1, "-1")], coerce=int, required=True)
-        self.assertFalse(f.has_changed(None, ''))
-        self.assertFalse(f.has_changed(1, '1'))
-        self.assertFalse(f.has_changed('1', '1'))
+        self.assertFalse(f.has_changed(None, ""))
+        self.assertFalse(f.has_changed(1, "1"))
+        self.assertFalse(f.has_changed("1", "1"))
 
         f = TypedChoiceField(
-            choices=[('', '---------'), ('a', "a"), ('b', "b")], coerce=str,
-            required=False, initial=None, empty_value=None,
+            choices=[("", "---------"), ("a", "a"), ("b", "b")],
+            coerce=str,
+            required=False,
+            initial=None,
+            empty_value=None,
         )
-        self.assertFalse(f.has_changed(None, ''))
-        self.assertTrue(f.has_changed('', 'a'))
-        self.assertFalse(f.has_changed('a', 'a'))
+        self.assertFalse(f.has_changed(None, ""))
+        self.assertTrue(f.has_changed("", "a"))
+        self.assertFalse(f.has_changed("a", "a"))
 
     def test_typedchoicefield_special_coerce(self):
         """
         A coerce function which results in a value not present in choices
         should raise an appropriate error (#21397).
         """
+
         def coerce_func(val):
-            return decimal.Decimal('1.%s' % val)
+            return decimal.Decimal("1.%s" % val)
 
-        f = TypedChoiceField(choices=[(1, "1"), (2, "2")], coerce=coerce_func, required=True)
-        self.assertEqual(decimal.Decimal('1.2'), f.clean('2'))
+        f = TypedChoiceField(
+            choices=[(1, "1"), (2, "2")], coerce=coerce_func, required=True
+        )
+        self.assertEqual(decimal.Decimal("1.2"), f.clean("2"))
         with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
-            f.clean('')
+            f.clean("")
         msg = "'Select a valid choice. 3 is not one of the available choices.'"
         with self.assertRaisesMessage(ValidationError, msg):
-            f.clean('3')
+            f.clean("3")
diff --git a/tests/forms_tests/field_tests/test_typedmultiplechoicefield.py b/tests/forms_tests/field_tests/test_typedmultiplechoicefield.py
index 1c97676a87..6810f1ed19 100644
--- a/tests/forms_tests/field_tests/test_typedmultiplechoicefield.py
+++ b/tests/forms_tests/field_tests/test_typedmultiplechoicefield.py
@@ -6,70 +6,80 @@ from django.test import SimpleTestCase
 
 
 class TypedMultipleChoiceFieldTest(SimpleTestCase):
-
     def test_typedmultiplechoicefield_1(self):
         f = TypedMultipleChoiceField(choices=[(1, "+1"), (-1, "-1")], coerce=int)
-        self.assertEqual([1], f.clean(['1']))
+        self.assertEqual([1], f.clean(["1"]))
         msg = "'Select a valid choice. 2 is not one of the available choices.'"
         with self.assertRaisesMessage(ValidationError, msg):
-            f.clean(['2'])
+            f.clean(["2"])
 
     def test_typedmultiplechoicefield_2(self):
         # Different coercion, same validation.
         f = TypedMultipleChoiceField(choices=[(1, "+1"), (-1, "-1")], coerce=float)
-        self.assertEqual([1.0], f.clean(['1']))
+        self.assertEqual([1.0], f.clean(["1"]))
 
     def test_typedmultiplechoicefield_3(self):
         # This can also cause weirdness: be careful (bool(-1) == True, remember)
         f = TypedMultipleChoiceField(choices=[(1, "+1"), (-1, "-1")], coerce=bool)
-        self.assertEqual([True], f.clean(['-1']))
+        self.assertEqual([True], f.clean(["-1"]))
 
     def test_typedmultiplechoicefield_4(self):
         f = TypedMultipleChoiceField(choices=[(1, "+1"), (-1, "-1")], coerce=int)
-        self.assertEqual([1, -1], f.clean(['1', '-1']))
+        self.assertEqual([1, -1], f.clean(["1", "-1"]))
         msg = "'Select a valid choice. 2 is not one of the available choices.'"
         with self.assertRaisesMessage(ValidationError, msg):
-            f.clean(['1', '2'])
+            f.clean(["1", "2"])
 
     def test_typedmultiplechoicefield_5(self):
         # Even more weirdness: if you have a valid choice but your coercion function
         # can't coerce, you'll still get a validation error. Don't do this!
-        f = TypedMultipleChoiceField(choices=[('A', 'A'), ('B', 'B')], coerce=int)
+        f = TypedMultipleChoiceField(choices=[("A", "A"), ("B", "B")], coerce=int)
         msg = "'Select a valid choice. B is not one of the available choices.'"
         with self.assertRaisesMessage(ValidationError, msg):
-            f.clean(['B'])
+            f.clean(["B"])
         # Required fields require values
         with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
             f.clean([])
 
     def test_typedmultiplechoicefield_6(self):
         # Non-required fields aren't required
-        f = TypedMultipleChoiceField(choices=[(1, "+1"), (-1, "-1")], coerce=int, required=False)
+        f = TypedMultipleChoiceField(
+            choices=[(1, "+1"), (-1, "-1")], coerce=int, required=False
+        )
         self.assertEqual([], f.clean([]))
 
     def test_typedmultiplechoicefield_7(self):
         # If you want cleaning an empty value to return a different type, tell the field
-        f = TypedMultipleChoiceField(choices=[(1, "+1"), (-1, "-1")], coerce=int, required=False, empty_value=None)
+        f = TypedMultipleChoiceField(
+            choices=[(1, "+1"), (-1, "-1")],
+            coerce=int,
+            required=False,
+            empty_value=None,
+        )
         self.assertIsNone(f.clean([]))
 
     def test_typedmultiplechoicefield_has_changed(self):
         # has_changed should not trigger required validation
-        f = TypedMultipleChoiceField(choices=[(1, "+1"), (-1, "-1")], coerce=int, required=True)
-        self.assertFalse(f.has_changed(None, ''))
+        f = TypedMultipleChoiceField(
+            choices=[(1, "+1"), (-1, "-1")], coerce=int, required=True
+        )
+        self.assertFalse(f.has_changed(None, ""))
 
     def test_typedmultiplechoicefield_special_coerce(self):
         """
         A coerce function which results in a value not present in choices
         should raise an appropriate error (#21397).
         """
+
         def coerce_func(val):
-            return decimal.Decimal('1.%s' % val)
+            return decimal.Decimal("1.%s" % val)
 
         f = TypedMultipleChoiceField(
-            choices=[(1, "1"), (2, "2")], coerce=coerce_func, required=True)
-        self.assertEqual([decimal.Decimal('1.2')], f.clean(['2']))
+            choices=[(1, "1"), (2, "2")], coerce=coerce_func, required=True
+        )
+        self.assertEqual([decimal.Decimal("1.2")], f.clean(["2"]))
         with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
             f.clean([])
         msg = "'Select a valid choice. 3 is not one of the available choices.'"
         with self.assertRaisesMessage(ValidationError, msg):
-            f.clean(['3'])
+            f.clean(["3"])
diff --git a/tests/forms_tests/field_tests/test_urlfield.py b/tests/forms_tests/field_tests/test_urlfield.py
index 187d44a050..042a3bf586 100644
--- a/tests/forms_tests/field_tests/test_urlfield.py
+++ b/tests/forms_tests/field_tests/test_urlfield.py
@@ -6,14 +6,13 @@ from . import FormFieldAssertionsMixin
 
 
 class URLFieldTest(FormFieldAssertionsMixin, SimpleTestCase):
-
     def test_urlfield_widget(self):
         f = URLField()
         self.assertWidgetRendersTo(f, '<input type="url" name="f" id="id_f" required>')
 
     def test_urlfield_widget_max_min_length(self):
         f = URLField(min_length=15, max_length=20)
-        self.assertEqual('http://example.com', f.clean('http://example.com'))
+        self.assertEqual("http://example.com", f.clean("http://example.com"))
         self.assertWidgetRendersTo(
             f,
             '<input id="id_f" type="url" name="f" maxlength="20" '
@@ -21,55 +20,58 @@ class URLFieldTest(FormFieldAssertionsMixin, SimpleTestCase):
         )
         msg = "'Ensure this value has at least 15 characters (it has 12).'"
         with self.assertRaisesMessage(ValidationError, msg):
-            f.clean('http://f.com')
+            f.clean("http://f.com")
         msg = "'Ensure this value has at most 20 characters (it has 37).'"
         with self.assertRaisesMessage(ValidationError, msg):
-            f.clean('http://abcdefghijklmnopqrstuvwxyz.com')
+            f.clean("http://abcdefghijklmnopqrstuvwxyz.com")
 
     def test_urlfield_clean(self):
         f = URLField(required=False)
         tests = [
-            ('http://localhost', 'http://localhost'),
-            ('http://example.com', 'http://example.com'),
-            ('http://example.com/test', 'http://example.com/test'),
-            ('http://example.com.', 'http://example.com.'),
-            ('http://www.example.com', 'http://www.example.com'),
-            ('http://www.example.com:8000/test', 'http://www.example.com:8000/test'),
+            ("http://localhost", "http://localhost"),
+            ("http://example.com", "http://example.com"),
+            ("http://example.com/test", "http://example.com/test"),
+            ("http://example.com.", "http://example.com."),
+            ("http://www.example.com", "http://www.example.com"),
+            ("http://www.example.com:8000/test", "http://www.example.com:8000/test"),
             (
-                'http://example.com?some_param=some_value',
-                'http://example.com?some_param=some_value',
+                "http://example.com?some_param=some_value",
+                "http://example.com?some_param=some_value",
             ),
-            ('valid-with-hyphens.com', 'http://valid-with-hyphens.com'),
-            ('subdomain.domain.com', 'http://subdomain.domain.com'),
-            ('http://200.8.9.10', 'http://200.8.9.10'),
-            ('http://200.8.9.10:8000/test', 'http://200.8.9.10:8000/test'),
-            ('http://valid-----hyphens.com', 'http://valid-----hyphens.com'),
+            ("valid-with-hyphens.com", "http://valid-with-hyphens.com"),
+            ("subdomain.domain.com", "http://subdomain.domain.com"),
+            ("http://200.8.9.10", "http://200.8.9.10"),
+            ("http://200.8.9.10:8000/test", "http://200.8.9.10:8000/test"),
+            ("http://valid-----hyphens.com", "http://valid-----hyphens.com"),
             (
-                'http://some.idn.xyzäöüßabc.domain.com:123/blah',
-                'http://some.idn.xyz\xe4\xf6\xfc\xdfabc.domain.com:123/blah',
+                "http://some.idn.xyzäöüßabc.domain.com:123/blah",
+                "http://some.idn.xyz\xe4\xf6\xfc\xdfabc.domain.com:123/blah",
             ),
             (
-                'www.example.com/s/http://code.djangoproject.com/ticket/13804',
-                'http://www.example.com/s/http://code.djangoproject.com/ticket/13804',
+                "www.example.com/s/http://code.djangoproject.com/ticket/13804",
+                "http://www.example.com/s/http://code.djangoproject.com/ticket/13804",
             ),
             # Normalization.
-            ('http://example.com/     ', 'http://example.com/'),
+            ("http://example.com/     ", "http://example.com/"),
             # Valid IDN.
-            ('http://עברית.idn.icann.org/', 'http://עברית.idn.icann.org/'),
-            ('http://sãopaulo.com/', 'http://sãopaulo.com/'),
-            ('http://sãopaulo.com.br/', 'http://sãopaulo.com.br/'),
-            ('http://пример.испытание/', 'http://пример.испытание/'),
-            ('http://مثال.إختبار/', 'http://مثال.إختبار/'),
-            ('http://例子.测试/', 'http://例子.测试/'),
-            ('http://例子.測試/', 'http://例子.測試/'),
-            ('http://उदाहरण.परीक्षा/', 'http://उदाहरण.परीक्षा/',),
-            ('http://例え.テスト/', 'http://例え.テスト/'),
-            ('http://مثال.آزمایشی/', 'http://مثال.آزمایشی/'),
-            ('http://실례.테스트/', 'http://실례.테스트/'),
-            ('http://العربية.idn.icann.org/', 'http://العربية.idn.icann.org/'),
+            ("http://עברית.idn.icann.org/", "http://עברית.idn.icann.org/"),
+            ("http://sãopaulo.com/", "http://sãopaulo.com/"),
+            ("http://sãopaulo.com.br/", "http://sãopaulo.com.br/"),
+            ("http://пример.испытание/", "http://пример.испытание/"),
+            ("http://مثال.إختبار/", "http://مثال.إختبار/"),
+            ("http://例子.测试/", "http://例子.测试/"),
+            ("http://例子.測試/", "http://例子.測試/"),
+            (
+                "http://उदाहरण.परीक्षा/",
+                "http://उदाहरण.परीक्षा/",
+            ),
+            ("http://例え.テスト/", "http://例え.テスト/"),
+            ("http://مثال.آزمایشی/", "http://مثال.آزمایشی/"),
+            ("http://실례.테스트/", "http://실례.테스트/"),
+            ("http://العربية.idn.icann.org/", "http://العربية.idn.icann.org/"),
             # IPv6.
-            ('http://[12:34::3a53]/', 'http://[12:34::3a53]/'),
-            ('http://[a34:9238::]:8080/', 'http://[a34:9238::]:8080/'),
+            ("http://[12:34::3a53]/", "http://[12:34::3a53]/"),
+            ("http://[a34:9238::]:8080/", "http://[a34:9238::]:8080/"),
         ]
         for url, expected in tests:
             with self.subTest(url=url):
@@ -78,32 +80,32 @@ class URLFieldTest(FormFieldAssertionsMixin, SimpleTestCase):
     def test_urlfield_clean_invalid(self):
         f = URLField()
         tests = [
-            'foo',
-            'com.',
-            '.',
-            'http://',
-            'http://example',
-            'http://example.',
-            'http://.com',
-            'http://invalid-.com',
-            'http://-invalid.com',
-            'http://inv-.alid-.com',
-            'http://inv-.-alid.com',
-            '[a',
-            'http://[a',
+            "foo",
+            "com.",
+            ".",
+            "http://",
+            "http://example",
+            "http://example.",
+            "http://.com",
+            "http://invalid-.com",
+            "http://-invalid.com",
+            "http://inv-.alid-.com",
+            "http://inv-.-alid.com",
+            "[a",
+            "http://[a",
             # Non-string.
             23,
             # Hangs "forever" before fixing a catastrophic backtracking,
             # see #11198.
-            'http://%s' % ('X' * 60,),
+            "http://%s" % ("X" * 60,),
             # A second example, to make sure the problem is really addressed,
             # even on domains that don't fail the domain label length check in
             # the regex.
-            'http://%s' % ("X" * 200,),
+            "http://%s" % ("X" * 200,),
             # urlsplit() raises ValueError.
-            '////]@N.AN',
+            "////]@N.AN",
             # Empty hostname.
-            '#@A.bO',
+            "#@A.bO",
         ]
         msg = "'Enter a valid URL.'"
         for value in tests:
@@ -117,16 +119,16 @@ class URLFieldTest(FormFieldAssertionsMixin, SimpleTestCase):
         with self.assertRaisesMessage(ValidationError, msg):
             f.clean(None)
         with self.assertRaisesMessage(ValidationError, msg):
-            f.clean('')
+            f.clean("")
 
     def test_urlfield_clean_not_required(self):
         f = URLField(required=False)
-        self.assertEqual(f.clean(None), '')
-        self.assertEqual(f.clean(''), '')
+        self.assertEqual(f.clean(None), "")
+        self.assertEqual(f.clean(""), "")
 
     def test_urlfield_strip_on_none_value(self):
         f = URLField(required=False, empty_value=None)
-        self.assertIsNone(f.clean(''))
+        self.assertIsNone(f.clean(""))
         self.assertIsNone(f.clean(None))
 
     def test_urlfield_unable_to_set_strip_kwarg(self):
diff --git a/tests/forms_tests/field_tests/test_uuidfield.py b/tests/forms_tests/field_tests/test_uuidfield.py
index e1c1698d02..b039c4a0c3 100644
--- a/tests/forms_tests/field_tests/test_uuidfield.py
+++ b/tests/forms_tests/field_tests/test_uuidfield.py
@@ -6,28 +6,27 @@ from django.test import SimpleTestCase
 
 
 class UUIDFieldTest(SimpleTestCase):
-
     def test_uuidfield_1(self):
         field = UUIDField()
-        value = field.clean('550e8400e29b41d4a716446655440000')
-        self.assertEqual(value, uuid.UUID('550e8400e29b41d4a716446655440000'))
+        value = field.clean("550e8400e29b41d4a716446655440000")
+        self.assertEqual(value, uuid.UUID("550e8400e29b41d4a716446655440000"))
 
     def test_clean_value_with_dashes(self):
         field = UUIDField()
-        value = field.clean('550e8400-e29b-41d4-a716-446655440000')
-        self.assertEqual(value, uuid.UUID('550e8400e29b41d4a716446655440000'))
+        value = field.clean("550e8400-e29b-41d4-a716-446655440000")
+        self.assertEqual(value, uuid.UUID("550e8400e29b41d4a716446655440000"))
 
     def test_uuidfield_2(self):
         field = UUIDField(required=False)
-        self.assertIsNone(field.clean(''))
+        self.assertIsNone(field.clean(""))
         self.assertIsNone(field.clean(None))
 
     def test_uuidfield_3(self):
         field = UUIDField()
-        with self.assertRaisesMessage(ValidationError, 'Enter a valid UUID.'):
-            field.clean('550e8400')
+        with self.assertRaisesMessage(ValidationError, "Enter a valid UUID."):
+            field.clean("550e8400")
 
     def test_uuidfield_4(self):
         field = UUIDField()
-        value = field.prepare_value(uuid.UUID('550e8400e29b41d4a716446655440000'))
-        self.assertEqual(value, '550e8400-e29b-41d4-a716-446655440000')
+        value = field.prepare_value(uuid.UUID("550e8400e29b41d4a716446655440000"))
+        self.assertEqual(value, "550e8400-e29b-41d4-a716-446655440000")