Fixed #26176 -- Fixed E123 flake8 warnings.26176

16 files changed, 537 insertions, 549 deletions

diff --git a/django/contrib/admin/checks.py b/django/contrib/admin/checks.py
index 48539fe9e5..62c3710cdb 100644
--- a/django/contrib/admin/checks.py
+++ b/django/contrib/admin/checks.py
@@ -58,7 +58,7 @@ def check_dependencies(**kwargs):
                 "'django.contrib.auth.context_processors.auth' must be in "
                 "TEMPLATES in order to use the admin application.",
                 id="admin.E402"
-                )
+            )
             errors.append(missing_template)
     return errors
 
diff --git a/django/contrib/flatpages/forms.py b/django/contrib/flatpages/forms.py
index b990fa36de..19f3b6309c 100644
--- a/django/contrib/flatpages/forms.py
+++ b/django/contrib/flatpages/forms.py
@@ -5,12 +5,16 @@ from django.utils.translation import ugettext, ugettext_lazy as _
 
 
 class FlatpageForm(forms.ModelForm):
-    url = forms.RegexField(label=_("URL"), max_length=100, regex=r'^[-\w/\.~]+$',
-        help_text=_("Example: '/about/contact/'. Make sure to have leading"
-                    " and trailing slashes."),
+    url = forms.RegexField(
+        label=_("URL"),
+        max_length=100,
+        regex=r'^[-\w/\.~]+$',
+        help_text=_("Example: '/about/contact/'. Make sure to have leading and trailing slashes."),
         error_messages={
-            "invalid": _("This value must contain only letters, numbers,"
-                         " dots, underscores, dashes, slashes or tildes."),
+            "invalid": _(
+                "This value must contain only letters, numbers, dots, "
+                "underscores, dashes, slashes or tildes."
+            ),
         },
     )
 
diff --git a/django/contrib/flatpages/models.py b/django/contrib/flatpages/models.py
index 67e1a30bac..b3cad733aa 100644
--- a/django/contrib/flatpages/models.py
+++ b/django/contrib/flatpages/models.py
@@ -13,7 +13,10 @@ class FlatPage(models.Model):
     title = models.CharField(_('title'), max_length=200)
     content = models.TextField(_('content'), blank=True)
     enable_comments = models.BooleanField(_('enable comments'), default=False)
-    template_name = models.CharField(_('template name'), max_length=70, blank=True,
+    template_name = models.CharField(
+        _('template name'),
+        max_length=70,
+        blank=True,
         help_text=_(
             "Example: 'flatpages/contact_page.html'. If this isn't provided, "
             "the system will use 'flatpages/default.html'."
diff --git a/django/contrib/gis/gdal/prototypes/raster.py b/django/contrib/gis/gdal/prototypes/raster.py
index 4058e1912a..8b3c3504d4 100644
--- a/django/contrib/gis/gdal/prototypes/raster.py
+++ b/django/contrib/gis/gdal/prototypes/raster.py
@@ -62,7 +62,8 @@ get_band_ds = voidptr_output(std_call('GDALGetBandDataset'), [c_void_p])
 get_band_datatype = int_output(std_call('GDALGetRasterDataType'), [c_void_p])
 get_band_nodata_value = double_output(std_call('GDALGetRasterNoDataValue'), [c_void_p, POINTER(c_int)])
 set_band_nodata_value = void_output(std_call('GDALSetRasterNoDataValue'), [c_void_p, c_double])
-get_band_statistics = void_output(std_call('GDALGetRasterStatistics'),
+get_band_statistics = void_output(
+    std_call('GDALGetRasterStatistics'),
     [
         c_void_p, c_int, c_int, POINTER(c_double), POINTER(c_double),
         POINTER(c_double), POINTER(c_double), c_void_p, c_void_p,
diff --git a/django/views/generic/dates.py b/django/views/generic/dates.py
index d403db8207..52b3b39062 100644
--- a/django/views/generic/dates.py
+++ b/django/views/generic/dates.py
@@ -658,11 +658,11 @@ class BaseDateDetailView(YearMixin, MonthMixin, DayMixin, DateMixin, BaseDetailV
         if not self.get_allow_future() and date > datetime.date.today():
             raise Http404(_(
                 "Future %(verbose_name_plural)s not available because "
-                "%(class_name)s.allow_future is False.") % {
+                "%(class_name)s.allow_future is False."
+            ) % {
                 'verbose_name_plural': qs.model._meta.verbose_name_plural,
                 'class_name': self.__class__.__name__,
-                },
-            )
+            })
 
         # Filter down a queryset from self.queryset using the date from the
         # URL. This'll get passed as the queryset to DetailView.get_object,
diff --git a/setup.cfg b/setup.cfg
index 8579282aec..f6ab266215 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -4,7 +4,7 @@ install-script = scripts/rpm-install.sh
 
 [flake8]
 exclude = build,.git,./django/utils/lru_cache.py,./django/utils/six.py,./django/conf/app_template/*,./django/dispatch/weakref_backports.py,./tests/.env,./xmlrunner,tests/view_tests/tests/py3_test_debug.py,tests/template_tests/annotated_tag_function.py
-ignore = E123,E128,E402,W503,W601
+ignore = E128,E402,W503,W601
 max-line-length = 119
 
 [isort]
diff --git a/tests/aggregation_regress/tests.py b/tests/aggregation_regress/tests.py
index 7068b86f6a..c207776822 100644
--- a/tests/aggregation_regress/tests.py
+++ b/tests/aggregation_regress/tests.py
@@ -963,7 +963,7 @@ class AggregationTests(TestCase):
         """
         books = Book.objects.values_list("publisher__name").annotate(
             Count("id"), Avg("price"), Avg("authors__age"), avg_pgs=Avg("pages")
-            ).order_by("-publisher__name")
+        ).order_by("-publisher__name")
         self.assertEqual(books[0], ('Sams', 1, 23.09, 45.0, 528.0))
 
     def test_annotation_disjunction(self):
diff --git a/tests/annotations/tests.py b/tests/annotations/tests.py
index 5ff4df100d..c001b4e7f2 100644
--- a/tests/annotations/tests.py
+++ b/tests/annotations/tests.py
@@ -428,8 +428,9 @@ class NonAggregateAnnotationTestCase(TestCase):
                 F('ticker_name'),
                 F('description'),
                 Value('No Tag'),
-                function='COALESCE')
-            ).order_by('name')
+                function='COALESCE'
+            )
+        ).order_by('name')
 
         self.assertQuerysetEqual(
             qs, [
diff --git a/tests/gis_tests/geoapp/test_functions.py b/tests/gis_tests/geoapp/test_functions.py
index 50649e2f52..aeb1007c56 100644
--- a/tests/gis_tests/geoapp/test_functions.py
+++ b/tests/gis_tests/geoapp/test_functions.py
@@ -89,7 +89,7 @@ class GISFunctionsTests(TestCase):
             chicago_json,
             City.objects.annotate(
                 geojson=functions.AsGeoJSON('point', bbox=True, crs=True, precision=5)
-                ).get(name='Chicago').geojson
+            ).get(name='Chicago').geojson
         )
 
     @skipUnlessDBFeature("has_AsGML_function")
diff --git a/tests/gis_tests/gis_migrations/test_commands.py b/tests/gis_tests/gis_migrations/test_commands.py
index 77bbdf3349..b9efc2c39c 100644
--- a/tests/gis_tests/gis_migrations/test_commands.py
+++ b/tests/gis_tests/gis_migrations/test_commands.py
@@ -56,10 +56,9 @@ class MigrateTests(TransactionTestCase):
             # Not all GIS backends have geometry columns model
             pass
         else:
-            self.assertEqual(
-                GeoColumn.objects.filter(
-                    **{'%s__in' % GeoColumn.table_name_col(): ["gis_neighborhood", "gis_household"]}
-                    ).count(),
-                0)
+            qs = GeoColumn.objects.filter(
+                **{'%s__in' % GeoColumn.table_name_col(): ["gis_neighborhood", "gis_household"]}
+            )
+            self.assertEqual(qs.count(), 0)
         # Revert the "unmigration"
         call_command("migrate", "gis_migrations", verbosity=0)
diff --git a/tests/lookup/tests.py b/tests/lookup/tests.py
index ac96e8ac7a..557d0895e7 100644
--- a/tests/lookup/tests.py
+++ b/tests/lookup/tests.py
@@ -16,34 +16,22 @@ class LookupTests(TestCase):
 
     def setUp(self):
         # Create a few Authors.
-        self.au1 = Author(name='Author 1')
-        self.au1.save()
-        self.au2 = Author(name='Author 2')
-        self.au2.save()
+        self.au1 = Author.objects.create(name='Author 1')
+        self.au2 = Author.objects.create(name='Author 2')
         # Create a couple of Articles.
-        self.a1 = Article(headline='Article 1', pub_date=datetime(2005, 7, 26), author=self.au1)
-        self.a1.save()
-        self.a2 = Article(headline='Article 2', pub_date=datetime(2005, 7, 27), author=self.au1)
-        self.a2.save()
-        self.a3 = Article(headline='Article 3', pub_date=datetime(2005, 7, 27), author=self.au1)
-        self.a3.save()
-        self.a4 = Article(headline='Article 4', pub_date=datetime(2005, 7, 28), author=self.au1)
-        self.a4.save()
-        self.a5 = Article(headline='Article 5', pub_date=datetime(2005, 8, 1, 9, 0), author=self.au2)
-        self.a5.save()
-        self.a6 = Article(headline='Article 6', pub_date=datetime(2005, 8, 1, 8, 0), author=self.au2)
-        self.a6.save()
-        self.a7 = Article(headline='Article 7', pub_date=datetime(2005, 7, 27), author=self.au2)
-        self.a7.save()
+        self.a1 = Article.objects.create(headline='Article 1', pub_date=datetime(2005, 7, 26), author=self.au1)
+        self.a2 = Article.objects.create(headline='Article 2', pub_date=datetime(2005, 7, 27), author=self.au1)
+        self.a3 = Article.objects.create(headline='Article 3', pub_date=datetime(2005, 7, 27), author=self.au1)
+        self.a4 = Article.objects.create(headline='Article 4', pub_date=datetime(2005, 7, 28), author=self.au1)
+        self.a5 = Article.objects.create(headline='Article 5', pub_date=datetime(2005, 8, 1, 9, 0), author=self.au2)
+        self.a6 = Article.objects.create(headline='Article 6', pub_date=datetime(2005, 8, 1, 8, 0), author=self.au2)
+        self.a7 = Article.objects.create(headline='Article 7', pub_date=datetime(2005, 7, 27), author=self.au2)
         # Create a few Tags.
-        self.t1 = Tag(name='Tag 1')
-        self.t1.save()
+        self.t1 = Tag.objects.create(name='Tag 1')
         self.t1.articles.add(self.a1, self.a2, self.a3)
-        self.t2 = Tag(name='Tag 2')
-        self.t2.save()
+        self.t2 = Tag.objects.create(name='Tag 2')
         self.t2.articles.add(self.a3, self.a4, self.a5)
-        self.t3 = Tag(name='Tag 3')
-        self.t3.save()
+        self.t3 = Tag.objects.create(name='Tag 3')
         self.t3.articles.add(self.a5, self.a6, self.a7)
 
     def test_exists(self):
@@ -62,7 +50,8 @@ class LookupTests(TestCase):
     @skipUnlessDBFeature('supports_date_lookup_using_string')
     def test_lookup_date_as_str(self):
         # A date lookup can be performed using a string search
-        self.assertQuerysetEqual(Article.objects.filter(pub_date__startswith='2005'),
+        self.assertQuerysetEqual(
+            Article.objects.filter(pub_date__startswith='2005'),
             [
                 '<Article: Article 5>',
                 '<Article: Article 6>',
@@ -71,14 +60,16 @@ class LookupTests(TestCase):
                 '<Article: Article 3>',
                 '<Article: Article 7>',
                 '<Article: Article 1>',
-            ])
+            ]
+        )
 
     def test_iterator(self):
         # Each QuerySet gets iterator(), which is a generator that "lazily"
         # returns results using database-level iteration.
         self.assertIsInstance(Article.objects.iterator(), collections.Iterator)
 
-        self.assertQuerysetEqual(Article.objects.iterator(),
+        self.assertQuerysetEqual(
+            Article.objects.iterator(),
             [
                 'Article 5',
                 'Article 6',
@@ -88,7 +79,8 @@ class LookupTests(TestCase):
                 'Article 7',
                 'Article 1',
             ],
-            transform=attrgetter('headline'))
+            transform=attrgetter('headline')
+        )
         # iterator() can be used on any QuerySet.
         self.assertQuerysetEqual(
             Article.objects.filter(headline__endswith='4').iterator(),
@@ -144,7 +136,8 @@ class LookupTests(TestCase):
         # and you can specify which fields you want to retrieve.
         def identity(x):
             return x
-        self.assertQuerysetEqual(Article.objects.values('headline'),
+        self.assertQuerysetEqual(
+            Article.objects.values('headline'),
             [
                 {'headline': 'Article 5'},
                 {'headline': 'Article 6'},
@@ -154,12 +147,15 @@ class LookupTests(TestCase):
                 {'headline': 'Article 7'},
                 {'headline': 'Article 1'},
             ],
-            transform=identity)
+            transform=identity
+        )
         self.assertQuerysetEqual(
             Article.objects.filter(pub_date__exact=datetime(2005, 7, 27)).values('id'),
             [{'id': self.a2.id}, {'id': self.a3.id}, {'id': self.a7.id}],
-            transform=identity)
-        self.assertQuerysetEqual(Article.objects.values('id', 'headline'),
+            transform=identity
+        )
+        self.assertQuerysetEqual(
+            Article.objects.values('id', 'headline'),
             [
                 {'id': self.a5.id, 'headline': 'Article 5'},
                 {'id': self.a6.id, 'headline': 'Article 6'},
@@ -169,10 +165,12 @@ class LookupTests(TestCase):
                 {'id': self.a7.id, 'headline': 'Article 7'},
                 {'id': self.a1.id, 'headline': 'Article 1'},
             ],
-            transform=identity)
+            transform=identity
+        )
         # You can use values() with iterator() for memory savings,
         # because iterator() uses database-level iteration.
-        self.assertQuerysetEqual(Article.objects.values('id', 'headline').iterator(),
+        self.assertQuerysetEqual(
+            Article.objects.values('id', 'headline').iterator(),
             [
                 {'headline': 'Article 5', 'id': self.a5.id},
                 {'headline': 'Article 6', 'id': self.a6.id},
@@ -182,7 +180,8 @@ class LookupTests(TestCase):
                 {'headline': 'Article 7', 'id': self.a7.id},
                 {'headline': 'Article 1', 'id': self.a1.id},
             ],
-            transform=identity)
+            transform=identity
+        )
         # The values() method works with "extra" fields specified in extra(select).
         self.assertQuerysetEqual(
             Article.objects.extra(select={'id_plus_one': 'id + 1'}).values('id', 'id_plus_one'),
@@ -195,7 +194,8 @@ class LookupTests(TestCase):
                 {'id': self.a7.id, 'id_plus_one': self.a7.id + 1},
                 {'id': self.a1.id, 'id_plus_one': self.a1.id + 1},
             ],
-            transform=identity)
+            transform=identity
+        )
         data = {
             'id_plus_one': 'id+1',
             'id_plus_two': 'id+2',
@@ -217,7 +217,8 @@ class LookupTests(TestCase):
                 'id_plus_six': self.a1.id + 6,
                 'id_plus_seven': self.a1.id + 7,
                 'id_plus_eight': self.a1.id + 8,
-            }], transform=identity)
+            }], transform=identity
+        )
         # You can specify fields from forward and reverse relations, just like filter().
         self.assertQuerysetEqual(
             Article.objects.values('headline', 'author__name'),
@@ -229,7 +230,8 @@ class LookupTests(TestCase):
                 {'headline': self.a3.headline, 'author__name': self.au1.name},
                 {'headline': self.a7.headline, 'author__name': self.au2.name},
                 {'headline': self.a1.headline, 'author__name': self.au1.name},
-            ], transform=identity)
+            ], transform=identity
+        )
         self.assertQuerysetEqual(
             Author.objects.values('name', 'article__headline').order_by('name', 'article__headline'),
             [
@@ -240,7 +242,8 @@ class LookupTests(TestCase):
                 {'name': self.au2.name, 'article__headline': self.a5.headline},
                 {'name': self.au2.name, 'article__headline': self.a6.headline},
                 {'name': self.au2.name, 'article__headline': self.a7.headline},
-            ], transform=identity)
+            ], transform=identity
+        )
         self.assertQuerysetEqual(
             (
                 Author.objects
@@ -257,20 +260,24 @@ class LookupTests(TestCase):
                 {'name': self.au2.name, 'article__headline': self.a5.headline, 'article__tag__name': self.t3.name},
                 {'name': self.au2.name, 'article__headline': self.a6.headline, 'article__tag__name': self.t3.name},
                 {'name': self.au2.name, 'article__headline': self.a7.headline, 'article__tag__name': self.t3.name},
-            ], transform=identity)
+            ], transform=identity
+        )
         # However, an exception FieldDoesNotExist will be thrown if you specify
         # a non-existent field name in values() (a field that is neither in the
         # model nor in extra(select)).
         with self.assertRaises(FieldError):
             Article.objects.extra(select={'id_plus_one': 'id + 1'}).values('id', 'id_plus_two')
         # If you don't specify field names to values(), all are returned.
-        self.assertQuerysetEqual(Article.objects.filter(id=self.a5.id).values(),
+        self.assertQuerysetEqual(
+            Article.objects.filter(id=self.a5.id).values(),
             [{
                 'id': self.a5.id,
                 'author_id': self.au2.id,
                 'headline': 'Article 5',
                 'pub_date': datetime(2005, 8, 1, 9, 0)
-            }], transform=identity)
+            }],
+            transform=identity
+        )
 
     def test_values_list(self):
         # values_list() is similar to values(), except that the results are
@@ -279,7 +286,8 @@ class LookupTests(TestCase):
         # of fields in the values_list() call.
         def identity(x):
             return x
-        self.assertQuerysetEqual(Article.objects.values_list('headline'),
+        self.assertQuerysetEqual(
+            Article.objects.values_list('headline'),
             [
                 ('Article 5',),
                 ('Article 6',),
@@ -288,22 +296,25 @@ class LookupTests(TestCase):
                 ('Article 3',),
                 ('Article 7',),
                 ('Article 1',),
-            ], transform=identity)
-        self.assertQuerysetEqual(Article.objects.values_list('id').order_by('id'),
+            ], transform=identity
+        )
+        self.assertQuerysetEqual(
+            Article.objects.values_list('id').order_by('id'),
             [(self.a1.id,), (self.a2.id,), (self.a3.id,), (self.a4.id,), (self.a5.id,), (self.a6.id,), (self.a7.id,)],
-            transform=identity)
+            transform=identity
+        )
         self.assertQuerysetEqual(
             Article.objects.values_list('id', flat=True).order_by('id'),
             [self.a1.id, self.a2.id, self.a3.id, self.a4.id, self.a5.id, self.a6.id, self.a7.id],
-            transform=identity)
+            transform=identity
+        )
         self.assertQuerysetEqual(
-            Article.objects.extra(select={'id_plus_one': 'id+1'})
-                           .order_by('id').values_list('id'),
+            Article.objects.extra(select={'id_plus_one': 'id+1'}).order_by('id').values_list('id'),
             [(self.a1.id,), (self.a2.id,), (self.a3.id,), (self.a4.id,), (self.a5.id,), (self.a6.id,), (self.a7.id,)],
-            transform=identity)
+            transform=identity
+        )
         self.assertQuerysetEqual(
-            Article.objects.extra(select={'id_plus_one': 'id+1'})
-                           .order_by('id').values_list('id_plus_one', 'id'),
+            Article.objects.extra(select={'id_plus_one': 'id+1'}).order_by('id').values_list('id_plus_one', 'id'),
             [
                 (self.a1.id + 1, self.a1.id),
                 (self.a2.id + 1, self.a2.id),
@@ -313,10 +324,10 @@ class LookupTests(TestCase):
                 (self.a6.id + 1, self.a6.id),
                 (self.a7.id + 1, self.a7.id)
             ],
-            transform=identity)
+            transform=identity
+        )
         self.assertQuerysetEqual(
-            Article.objects.extra(select={'id_plus_one': 'id+1'})
-                           .order_by('id').values_list('id', 'id_plus_one'),
+            Article.objects.extra(select={'id_plus_one': 'id+1'}).order_by('id').values_list('id', 'id_plus_one'),
             [
                 (self.a1.id, self.a1.id + 1),
                 (self.a2.id, self.a2.id + 1),
@@ -326,13 +337,11 @@ class LookupTests(TestCase):
                 (self.a6.id, self.a6.id + 1),
                 (self.a7.id, self.a7.id + 1)
             ],
-            transform=identity)
+            transform=identity
+        )
+        args = ('name', 'article__headline', 'article__tag__name')
         self.assertQuerysetEqual(
-            (
-                Author.objects
-                .values_list('name', 'article__headline', 'article__tag__name')
-                .order_by('name', 'article__headline', 'article__tag__name')
-            ),
+            Author.objects.values_list(*args).order_by(*args),
             [
                 (self.au1.name, self.a1.headline, self.t1.name),
                 (self.au1.name, self.a2.headline, self.t1.name),
@@ -343,7 +352,8 @@ class LookupTests(TestCase):
                 (self.au2.name, self.a5.headline, self.t3.name),
                 (self.au2.name, self.a6.headline, self.t3.name),
                 (self.au2.name, self.a7.headline, self.t3.name),
-            ], transform=identity)
+            ], transform=identity
+        )
         with self.assertRaises(TypeError):
             Article.objects.values_list('id', 'headline', flat=True)
 
@@ -352,42 +362,30 @@ class LookupTests(TestCase):
         # get_previous_by_FOO() methods. In the case of identical date values,
         # these methods will use the ID as a fallback check. This guarantees
         # that no records are skipped or duplicated.
-        self.assertEqual(repr(self.a1.get_next_by_pub_date()),
-                         '<Article: Article 2>')
-        self.assertEqual(repr(self.a2.get_next_by_pub_date()),
-                         '<Article: Article 3>')
-        self.assertEqual(repr(self.a2.get_next_by_pub_date(headline__endswith='6')),
-                         '<Article: Article 6>')
-        self.assertEqual(repr(self.a3.get_next_by_pub_date()),
-                         '<Article: Article 7>')
-        self.assertEqual(repr(self.a4.get_next_by_pub_date()),
-                         '<Article: Article 6>')
+        self.assertEqual(repr(self.a1.get_next_by_pub_date()), '<Article: Article 2>')
+        self.assertEqual(repr(self.a2.get_next_by_pub_date()), '<Article: Article 3>')
+        self.assertEqual(repr(self.a2.get_next_by_pub_date(headline__endswith='6')), '<Article: Article 6>')
+        self.assertEqual(repr(self.a3.get_next_by_pub_date()), '<Article: Article 7>')
+        self.assertEqual(repr(self.a4.get_next_by_pub_date()), '<Article: Article 6>')
         with self.assertRaises(Article.DoesNotExist):
             self.a5.get_next_by_pub_date()
-        self.assertEqual(repr(self.a6.get_next_by_pub_date()),
-                         '<Article: Article 5>')
-        self.assertEqual(repr(self.a7.get_next_by_pub_date()),
-                         '<Article: Article 4>')
-
-        self.assertEqual(repr(self.a7.get_previous_by_pub_date()),
-                         '<Article: Article 3>')
-        self.assertEqual(repr(self.a6.get_previous_by_pub_date()),
-                         '<Article: Article 4>')
-        self.assertEqual(repr(self.a5.get_previous_by_pub_date()),
-                         '<Article: Article 6>')
-        self.assertEqual(repr(self.a4.get_previous_by_pub_date()),
-                         '<Article: Article 7>')
-        self.assertEqual(repr(self.a3.get_previous_by_pub_date()),
-                         '<Article: Article 2>')
-        self.assertEqual(repr(self.a2.get_previous_by_pub_date()),
-                         '<Article: Article 1>')
+        self.assertEqual(repr(self.a6.get_next_by_pub_date()), '<Article: Article 5>')
+        self.assertEqual(repr(self.a7.get_next_by_pub_date()), '<Article: Article 4>')
+
+        self.assertEqual(repr(self.a7.get_previous_by_pub_date()), '<Article: Article 3>')
+        self.assertEqual(repr(self.a6.get_previous_by_pub_date()), '<Article: Article 4>')
+        self.assertEqual(repr(self.a5.get_previous_by_pub_date()), '<Article: Article 6>')
+        self.assertEqual(repr(self.a4.get_previous_by_pub_date()), '<Article: Article 7>')
+        self.assertEqual(repr(self.a3.get_previous_by_pub_date()), '<Article: Article 2>')
+        self.assertEqual(repr(self.a2.get_previous_by_pub_date()), '<Article: Article 1>')
 
     def test_escaping(self):
         # Underscores, percent signs and backslashes have special meaning in the
         # underlying SQL code, but Django handles the quoting of them automatically.
-        a8 = Article(headline='Article_ with underscore', pub_date=datetime(2005, 11, 20))
-        a8.save()
-        self.assertQuerysetEqual(Article.objects.filter(headline__startswith='Article'),
+        Article.objects.create(headline='Article_ with underscore', pub_date=datetime(2005, 11, 20))
+
+        self.assertQuerysetEqual(
+            Article.objects.filter(headline__startswith='Article'),
             [
                 '<Article: Article_ with underscore>',
                 '<Article: Article 5>',
@@ -397,12 +395,15 @@ class LookupTests(TestCase):
                 '<Article: Article 3>',
                 '<Article: Article 7>',
                 '<Article: Article 1>',
-            ])
-        self.assertQuerysetEqual(Article.objects.filter(headline__startswith='Article_'),
-                                 ['<Article: Article_ with underscore>'])
-        a9 = Article(headline='Article% with percent sign', pub_date=datetime(2005, 11, 21))
-        a9.save()
-        self.assertQuerysetEqual(Article.objects.filter(headline__startswith='Article'),
+            ]
+        )
+        self.assertQuerysetEqual(
+            Article.objects.filter(headline__startswith='Article_'),
+            ['<Article: Article_ with underscore>']
+        )
+        Article.objects.create(headline='Article% with percent sign', pub_date=datetime(2005, 11, 21))
+        self.assertQuerysetEqual(
+            Article.objects.filter(headline__startswith='Article'),
             [
                 '<Article: Article% with percent sign>',
                 '<Article: Article_ with underscore>',
@@ -413,13 +414,17 @@ class LookupTests(TestCase):
                 '<Article: Article 3>',
                 '<Article: Article 7>',
                 '<Article: Article 1>',
-            ])
-        self.assertQuerysetEqual(Article.objects.filter(headline__startswith='Article%'),
-                                 ['<Article: Article% with percent sign>'])
-        a10 = Article(headline='Article with \\ backslash', pub_date=datetime(2005, 11, 22))
-        a10.save()
-        self.assertQuerysetEqual(Article.objects.filter(headline__contains='\\'),
-                                 ['<Article: Article with \ backslash>'])
+            ]
+        )
+        self.assertQuerysetEqual(
+            Article.objects.filter(headline__startswith='Article%'),
+            ['<Article: Article% with percent sign>']
+        )
+        Article.objects.create(headline='Article with \\ backslash', pub_date=datetime(2005, 11, 22))
+        self.assertQuerysetEqual(
+            Article.objects.filter(headline__contains='\\'),
+            ['<Article: Article with \ backslash>']
+        )
 
     def test_exclude(self):
         Article.objects.create(headline='Article_ with underscore', pub_date=datetime(2005, 11, 20))
@@ -437,8 +442,10 @@ class LookupTests(TestCase):
                 '<Article: Article 3>',
                 '<Article: Article 7>',
                 '<Article: Article 1>',
-            ])
-        self.assertQuerysetEqual(Article.objects.exclude(headline__startswith="Article_"),
+            ]
+        )
+        self.assertQuerysetEqual(
+            Article.objects.exclude(headline__startswith="Article_"),
             [
                 '<Article: Article with \\ backslash>',
                 '<Article: Article% with percent sign>',
@@ -449,8 +456,10 @@ class LookupTests(TestCase):
                 '<Article: Article 3>',
                 '<Article: Article 7>',
                 '<Article: Article 1>',
-            ])
-        self.assertQuerysetEqual(Article.objects.exclude(headline="Article 7"),
+            ]
+        )
+        self.assertQuerysetEqual(
+            Article.objects.exclude(headline="Article 7"),
             [
                 '<Article: Article with \\ backslash>',
                 '<Article: Article% with percent sign>',
@@ -461,26 +470,23 @@ class LookupTests(TestCase):
                 '<Article: Article 2>',
                 '<Article: Article 3>',
                 '<Article: Article 1>',
-            ])
+            ]
+        )
 
     def test_none(self):
         # none() returns a QuerySet that behaves like any other QuerySet object
         self.assertQuerysetEqual(Article.objects.none(), [])
-        self.assertQuerysetEqual(
-            Article.objects.none().filter(headline__startswith='Article'), [])
-        self.assertQuerysetEqual(
-            Article.objects.filter(headline__startswith='Article').none(), [])
+        self.assertQuerysetEqual(Article.objects.none().filter(headline__startswith='Article'), [])
+        self.assertQuerysetEqual(Article.objects.filter(headline__startswith='Article').none(), [])
         self.assertEqual(Article.objects.none().count(), 0)
-        self.assertEqual(
-            Article.objects.none().update(headline="This should not take effect"), 0)
-        self.assertQuerysetEqual(
-            [article for article in Article.objects.none().iterator()],
-            [])
+        self.assertEqual(Article.objects.none().update(headline="This should not take effect"), 0)
+        self.assertQuerysetEqual([article for article in Article.objects.none().iterator()], [])
 
     def test_in(self):
         # using __in with an empty list should return an empty query set
         self.assertQuerysetEqual(Article.objects.filter(id__in=[]), [])
-        self.assertQuerysetEqual(Article.objects.exclude(id__in=[]),
+        self.assertQuerysetEqual(
+            Article.objects.exclude(id__in=[]),
             [
                 '<Article: Article 5>',
                 '<Article: Article 6>',
@@ -489,24 +495,24 @@ class LookupTests(TestCase):
                 '<Article: Article 3>',
                 '<Article: Article 7>',
                 '<Article: Article 1>',
-            ])
+            ]
+        )
 
     def test_error_messages(self):
         # Programming errors are pointed out with nice error messages
-        try:
+        with self.assertRaisesMessage(
+            FieldError,
+            "Cannot resolve keyword 'pub_date_year' into field. Choices are: "
+            "author, author_id, headline, id, pub_date, tag"
+        ):
             Article.objects.filter(pub_date_year='2005').count()
-            self.fail('FieldError not raised')
-        except FieldError as ex:
-            self.assertEqual(str(ex), "Cannot resolve keyword 'pub_date_year' "
-                             "into field. Choices are: author, author_id, headline, "
-                             "id, pub_date, tag")
-        try:
+
+        with self.assertRaisesMessage(
+            FieldError,
+            "Unsupported lookup 'starts' for CharField or join on the field "
+            "not permitted."
+        ):
             Article.objects.filter(headline__starts='Article')
-            self.fail('FieldError not raised')
-        except FieldError as ex:
-            self.assertEqual(
-                str(ex), "Unsupported lookup 'starts' for CharField "
-                "or join on the field not permitted.")
 
     def test_relation_nested_lookup_error(self):
         # An invalid nested lookup on a related field raises a useful error.
@@ -519,132 +525,134 @@ class LookupTests(TestCase):
         for a in Article.objects.all():
             a.delete()
         now = datetime.now()
-        a1 = Article(pub_date=now, headline='f')
-        a1.save()
-        a2 = Article(pub_date=now, headline='fo')
-        a2.save()
-        a3 = Article(pub_date=now, headline='foo')
-        a3.save()
-        a4 = Article(pub_date=now, headline='fooo')
-        a4.save()
-        a5 = Article(pub_date=now, headline='hey-Foo')
-        a5.save()
-        a6 = Article(pub_date=now, headline='bar')
-        a6.save()
-        a7 = Article(pub_date=now, headline='AbBa')
-        a7.save()
-        a8 = Article(pub_date=now, headline='baz')
-        a8.save()
-        a9 = Article(pub_date=now, headline='baxZ')
-        a9.save()
+        Article.objects.create(pub_date=now, headline='f')
+        Article.objects.create(pub_date=now, headline='fo')
+        Article.objects.create(pub_date=now, headline='foo')
+        Article.objects.create(pub_date=now, headline='fooo')
+        Article.objects.create(pub_date=now, headline='hey-Foo')
+        Article.objects.create(pub_date=now, headline='bar')
+        Article.objects.create(pub_date=now, headline='AbBa')
+        Article.objects.create(pub_date=now, headline='baz')
+        Article.objects.create(pub_date=now, headline='baxZ')
         # zero-or-more
-        self.assertQuerysetEqual(Article.objects.filter(headline__regex=r'fo*'),
-            ['<Article: f>', '<Article: fo>', '<Article: foo>', '<Article: fooo>'])
-        self.assertQuerysetEqual(Article.objects.filter(headline__iregex=r'fo*'),
+        self.assertQuerysetEqual(
+            Article.objects.filter(headline__regex=r'fo*'),
+            ['<Article: f>', '<Article: fo>', '<Article: foo>', '<Article: fooo>']
+        )
+        self.assertQuerysetEqual(
+            Article.objects.filter(headline__iregex=r'fo*'),
             [
                 '<Article: f>',
                 '<Article: fo>',
                 '<Article: foo>',
                 '<Article: fooo>',
                 '<Article: hey-Foo>',
-            ])
+            ]
+        )
         # one-or-more
-        self.assertQuerysetEqual(Article.objects.filter(headline__regex=r'fo+'),
-            ['<Article: fo>', '<Article: foo>', '<Article: fooo>'])
+        self.assertQuerysetEqual(
+            Article.objects.filter(headline__regex=r'fo+'),
+            ['<Article: fo>', '<Article: foo>', '<Article: fooo>']
+        )
         # wildcard
-        self.assertQuerysetEqual(Article.objects.filter(headline__regex=r'fooo?'),
-            ['<Article: foo>', '<Article: fooo>'])
+        self.assertQuerysetEqual(
+            Article.objects.filter(headline__regex=r'fooo?'),
+            ['<Article: foo>', '<Article: fooo>']
+        )
         # leading anchor
-        self.assertQuerysetEqual(Article.objects.filter(headline__regex=r'^b'),
-            ['<Article: bar>', '<Article: baxZ>', '<Article: baz>'])
-        self.assertQuerysetEqual(Article.objects.filter(headline__iregex=r'^a'),
-            ['<Article: AbBa>'])
+        self.assertQuerysetEqual(
+            Article.objects.filter(headline__regex=r'^b'),
+            ['<Article: bar>', '<Article: baxZ>', '<Article: baz>']
+        )
+        self.assertQuerysetEqual(Article.objects.filter(headline__iregex=r'^a'), ['<Article: AbBa>'])
         # trailing anchor
-        self.assertQuerysetEqual(Article.objects.filter(headline__regex=r'z$'),
-            ['<Article: baz>'])
-        self.assertQuerysetEqual(Article.objects.filter(headline__iregex=r'z$'),
-            ['<Article: baxZ>', '<Article: baz>'])
+        self.assertQuerysetEqual(Article.objects.filter(headline__regex=r'z$'), ['<Article: baz>'])
+        self.assertQuerysetEqual(
+            Article.objects.filter(headline__iregex=r'z$'),
+            ['<Article: baxZ>', '<Article: baz>']
+        )
         # character sets
-        self.assertQuerysetEqual(Article.objects.filter(headline__regex=r'ba[rz]'),
-            ['<Article: bar>', '<Article: baz>'])
-        self.assertQuerysetEqual(Article.objects.filter(headline__regex=r'ba.[RxZ]'),
-            ['<Article: baxZ>'])
-        self.assertQuerysetEqual(Article.objects.filter(headline__iregex=r'ba[RxZ]'),
-            ['<Article: bar>', '<Article: baxZ>', '<Article: baz>'])
+        self.assertQuerysetEqual(
+            Article.objects.filter(headline__regex=r'ba[rz]'),
+            ['<Article: bar>', '<Article: baz>']
+        )
+        self.assertQuerysetEqual(Article.objects.filter(headline__regex=r'ba.[RxZ]'), ['<Article: baxZ>'])
+        self.assertQuerysetEqual(
+            Article.objects.filter(headline__iregex=r'ba[RxZ]'),
+            ['<Article: bar>', '<Article: baxZ>', '<Article: baz>']
+        )
 
         # and more articles:
-        a10 = Article(pub_date=now, headline='foobar')
-        a10.save()
-        a11 = Article(pub_date=now, headline='foobaz')
-        a11.save()
-        a12 = Article(pub_date=now, headline='ooF')
-        a12.save()
-        a13 = Article(pub_date=now, headline='foobarbaz')
-        a13.save()
-        a14 = Article(pub_date=now, headline='zoocarfaz')
-        a14.save()
-        a15 = Article(pub_date=now, headline='barfoobaz')
-        a15.save()
-        a16 = Article(pub_date=now, headline='bazbaRFOO')
-        a16.save()
+        Article.objects.create(pub_date=now, headline='foobar')
+        Article.objects.create(pub_date=now, headline='foobaz')
+        Article.objects.create(pub_date=now, headline='ooF')
+        Article.objects.create(pub_date=now, headline='foobarbaz')
+        Article.objects.create(pub_date=now, headline='zoocarfaz')
+        Article.objects.create(pub_date=now, headline='barfoobaz')
+        Article.objects.create(pub_date=now, headline='bazbaRFOO')
 
         # alternation
-        self.assertQuerysetEqual(Article.objects.filter(headline__regex=r'oo(f|b)'),
+        self.assertQuerysetEqual(
+            Article.objects.filter(headline__regex=r'oo(f|b)'),
             [
                 '<Article: barfoobaz>',
                 '<Article: foobar>',
                 '<Article: foobarbaz>',
                 '<Article: foobaz>',
-            ])
-        self.assertQuerysetEqual(Article.objects.filter(headline__iregex=r'oo(f|b)'),
+            ]
+        )
+        self.assertQuerysetEqual(
+            Article.objects.filter(headline__iregex=r'oo(f|b)'),
             [
                 '<Article: barfoobaz>',
                 '<Article: foobar>',
                 '<Article: foobarbaz>',
                 '<Article: foobaz>',
                 '<Article: ooF>',
-            ])
-        self.assertQuerysetEqual(Article.objects.filter(headline__regex=r'^foo(f|b)'),
-            ['<Article: foobar>', '<Article: foobarbaz>', '<Article: foobaz>'])
+            ]
+        )
+        self.assertQuerysetEqual(
+            Article.objects.filter(headline__regex=r'^foo(f|b)'),
+            ['<Article: foobar>', '<Article: foobarbaz>', '<Article: foobaz>']
+        )
 
         # greedy matching
-        self.assertQuerysetEqual(Article.objects.filter(headline__regex=r'b.*az'),
+        self.assertQuerysetEqual(
+            Article.objects.filter(headline__regex=r'b.*az'),
             [
                 '<Article: barfoobaz>',
                 '<Article: baz>',
                 '<Article: bazbaRFOO>',
                 '<Article: foobarbaz>',
                 '<Article: foobaz>',
-            ])
-        self.assertQuerysetEqual(Article.objects.filter(headline__iregex=r'b.*ar'),
+            ]
+        )
+        self.assertQuerysetEqual(
+            Article.objects.filter(headline__iregex=r'b.*ar'),
             [
                 '<Article: bar>',
                 '<Article: barfoobaz>',
                 '<Article: bazbaRFOO>',
                 '<Article: foobar>',
                 '<Article: foobarbaz>',
-            ])
+            ]
+        )
 
     @skipUnlessDBFeature('supports_regex_backreferencing')
     def test_regex_backreferencing(self):
         # grouping and backreferences
         now = datetime.now()
-        a10 = Article(pub_date=now, headline='foobar')
-        a10.save()
-        a11 = Article(pub_date=now, headline='foobaz')
-        a11.save()
-        a12 = Article(pub_date=now, headline='ooF')
-        a12.save()
-        a13 = Article(pub_date=now, headline='foobarbaz')
-        a13.save()
-        a14 = Article(pub_date=now, headline='zoocarfaz')
-        a14.save()
-        a15 = Article(pub_date=now, headline='barfoobaz')
-        a15.save()
-        a16 = Article(pub_date=now, headline='bazbaRFOO')
-        a16.save()
-        self.assertQuerysetEqual(Article.objects.filter(headline__regex=r'b(.).*b\1'),
-            ['<Article: barfoobaz>', '<Article: bazbaRFOO>', '<Article: foobarbaz>'])
+        Article.objects.create(pub_date=now, headline='foobar')
+        Article.objects.create(pub_date=now, headline='foobaz')
+        Article.objects.create(pub_date=now, headline='ooF')
+        Article.objects.create(pub_date=now, headline='foobarbaz')
+        Article.objects.create(pub_date=now, headline='zoocarfaz')
+        Article.objects.create(pub_date=now, headline='barfoobaz')
+        Article.objects.create(pub_date=now, headline='bazbaRFOO')
+        self.assertQuerysetEqual(
+            Article.objects.filter(headline__regex=r'b(.).*b\1'),
+            ['<Article: barfoobaz>', '<Article: bazbaRFOO>', '<Article: foobarbaz>']
+        )
 
     def test_regex_null(self):
         """
@@ -658,8 +666,7 @@ class LookupTests(TestCase):
         Ensure that a regex lookup does not fail on non-string fields
         """
         Season.objects.create(year=2013, gt=444)
-        self.assertQuerysetEqual(Season.objects.filter(gt__regex=r'^444$'),
-            ['<Season: 2013>'])
+        self.assertQuerysetEqual(Season.objects.filter(gt__regex=r'^444$'), ['<Season: 2013>'])
 
     def test_regex_non_ascii(self):
         """
diff --git a/tests/many_to_many/tests.py b/tests/many_to_many/tests.py
index d7f81c5c29..67b3c9601e 100644
--- a/tests/many_to_many/tests.py
+++ b/tests/many_to_many/tests.py
@@ -2,7 +2,6 @@ from __future__ import unicode_literals
 
 from django.db import transaction
 from django.test import TestCase, ignore_warnings
-from django.utils import six
 from django.utils.deprecation import RemovedInDjango20Warning
 
 from .models import Article, InheritedArticleA, InheritedArticleB, Publication
@@ -12,15 +11,15 @@ class ManyToManyTests(TestCase):
 
     def setUp(self):
         # Create a couple of Publications.
-        self.p1 = Publication.objects.create(id=None, title='The Python Journal')
-        self.p2 = Publication.objects.create(id=None, title='Science News')
-        self.p3 = Publication.objects.create(id=None, title='Science Weekly')
+        self.p1 = Publication.objects.create(title='The Python Journal')
+        self.p2 = Publication.objects.create(title='Science News')
+        self.p3 = Publication.objects.create(title='Science Weekly')
         self.p4 = Publication.objects.create(title='Highlights for Children')
 
-        self.a1 = Article.objects.create(id=None, headline='Django lets you build Web apps easily')
+        self.a1 = Article.objects.create(headline='Django lets you build Web apps easily')
         self.a1.publications.add(self.p1)
 
-        self.a2 = Article.objects.create(id=None, headline='NASA uses Python')
+        self.a2 = Article.objects.create(headline='NASA uses Python')
         self.a2.publications.add(self.p1, self.p2, self.p3, self.p4)
 
         self.a3 = Article.objects.create(headline='NASA finds intelligent life on Earth')
@@ -31,7 +30,7 @@ class ManyToManyTests(TestCase):
 
     def test_add(self):
         # Create an Article.
-        a5 = Article(id=None, headline='Django lets you reate Web apps easily')
+        a5 = Article(headline='Django lets you reate Web apps easily')
         # You can't associate it with a Publication until it's been saved.
         with self.assertRaises(ValueError):
             getattr(a5, 'publications')
@@ -39,51 +38,55 @@ class ManyToManyTests(TestCase):
         a5.save()
         # Associate the Article with a Publication.
         a5.publications.add(self.p1)
-        self.assertQuerysetEqual(a5.publications.all(),
-                                 ['<Publication: The Python Journal>'])
+        self.assertQuerysetEqual(a5.publications.all(), ['<Publication: The Python Journal>'])
         # Create another Article, and set it to appear in both Publications.
-        a6 = Article(id=None, headline='ESA uses Python')
+        a6 = Article(headline='ESA uses Python')
         a6.save()
         a6.publications.add(self.p1, self.p2)
         a6.publications.add(self.p3)
         # Adding a second time is OK
         a6.publications.add(self.p3)
-        self.assertQuerysetEqual(a6.publications.all(),
+        self.assertQuerysetEqual(
+            a6.publications.all(),
             [
                 '<Publication: Science News>',
                 '<Publication: Science Weekly>',
                 '<Publication: The Python Journal>',
-            ])
+            ]
+        )
 
         # Adding an object of the wrong type raises TypeError
-        with six.assertRaisesRegex(self, TypeError, "'Publication' instance expected, got <Article.*"):
+        with self.assertRaisesMessage(TypeError, "'Publication' instance expected, got <Article"):
             with transaction.atomic():
                 a6.publications.add(a5)
 
         # Add a Publication directly via publications.add by using keyword arguments.
         a6.publications.create(title='Highlights for Adults')
-        self.assertQuerysetEqual(a6.publications.all(),
+        self.assertQuerysetEqual(
+            a6.publications.all(),
             [
                 '<Publication: Highlights for Adults>',
                 '<Publication: Science News>',
                 '<Publication: Science Weekly>',
                 '<Publication: The Python Journal>',
-            ])
+            ]
+        )
 
     def test_reverse_add(self):
         # Adding via the 'other' end of an m2m
         a5 = Article(headline='NASA finds intelligent life on Mars')
         a5.save()
         self.p2.article_set.add(a5)
-        self.assertQuerysetEqual(self.p2.article_set.all(),
+        self.assertQuerysetEqual(
+            self.p2.article_set.all(),
             [
                 '<Article: NASA finds intelligent life on Earth>',
                 '<Article: NASA finds intelligent life on Mars>',
                 '<Article: NASA uses Python>',
                 '<Article: Oxygen-free diet works wonders>',
-            ])
-        self.assertQuerysetEqual(a5.publications.all(),
-                                 ['<Publication: Science News>'])
+            ]
+        )
+        self.assertQuerysetEqual(a5.publications.all(), ['<Publication: Science News>'])
 
         # Adding via the other end using keywords
         self.p2.article_set.create(headline='Carbon-free diet works wonders')
@@ -97,39 +100,48 @@ class ManyToManyTests(TestCase):
                 '<Article: Oxygen-free diet works wonders>',
             ])
         a6 = self.p2.article_set.all()[3]
-        self.assertQuerysetEqual(a6.publications.all(),
+        self.assertQuerysetEqual(
+            a6.publications.all(),
             [
                 '<Publication: Highlights for Children>',
                 '<Publication: Science News>',
                 '<Publication: Science Weekly>',
                 '<Publication: The Python Journal>',
-            ])
+            ]
+        )
 
     def test_related_sets(self):
         # Article objects have access to their related Publication objects.
-        self.assertQuerysetEqual(self.a1.publications.all(),
-             ['<Publication: The Python Journal>'])
-        self.assertQuerysetEqual(self.a2.publications.all(),
+        self.assertQuerysetEqual(self.a1.publications.all(), ['<Publication: The Python Journal>'])
+        self.assertQuerysetEqual(
+            self.a2.publications.all(),
             [
                 '<Publication: Highlights for Children>',
                 '<Publication: Science News>',
                 '<Publication: Science Weekly>',
                 '<Publication: The Python Journal>',
-            ])
+            ]
+        )
         # Publication objects have access to their related Article objects.
-        self.assertQuerysetEqual(self.p2.article_set.all(),
+        self.assertQuerysetEqual(
+            self.p2.article_set.all(),
             [
                 '<Article: NASA finds intelligent life on Earth>',
                 '<Article: NASA uses Python>',
                 '<Article: Oxygen-free diet works wonders>',
-            ])
-        self.assertQuerysetEqual(self.p1.article_set.all(),
+            ]
+        )
+        self.assertQuerysetEqual(
+            self.p1.article_set.all(),
             [
                 '<Article: Django lets you build Web apps easily>',
                 '<Article: NASA uses Python>',
-            ])
-        self.assertQuerysetEqual(Publication.objects.get(id=self.p4.id).article_set.all(),
-                                 ['<Article: NASA uses Python>'])
+            ]
+        )
+        self.assertQuerysetEqual(
+            Publication.objects.get(id=self.p4.id).article_set.all(),
+            ['<Article: NASA uses Python>']
+        )
 
     def test_selects(self):
         # We can perform kwarg queries across m2m relationships
@@ -144,19 +156,22 @@ class ManyToManyTests(TestCase):
             [
                 '<Article: Django lets you build Web apps easily>',
                 '<Article: NASA uses Python>',
-            ])
+            ]
+        )
         self.assertQuerysetEqual(
             Article.objects.filter(publications=self.p1.id),
             [
                 '<Article: Django lets you build Web apps easily>',
                 '<Article: NASA uses Python>',
-            ])
+            ]
+        )
         self.assertQuerysetEqual(
             Article.objects.filter(publications=self.p1),
             [
                 '<Article: Django lets you build Web apps easily>',
                 '<Article: NASA uses Python>',
-            ])
+            ]
+        )
         self.assertQuerysetEqual(
             Article.objects.filter(publications__title__startswith="Science"),
             [
@@ -164,14 +179,16 @@ class ManyToManyTests(TestCase):
                 '<Article: NASA uses Python>',
                 '<Article: NASA uses Python>',
                 '<Article: Oxygen-free diet works wonders>',
-            ])
+            ]
+        )
         self.assertQuerysetEqual(
             Article.objects.filter(publications__title__startswith="Science").distinct(),
             [
                 '<Article: NASA finds intelligent life on Earth>',
                 '<Article: NASA uses Python>',
                 '<Article: Oxygen-free diet works wonders>',
-            ])
+            ]
+        )
 
         # The count() function respects distinct() as well.
         self.assertEqual(Article.objects.filter(publications__title__startswith="Science").count(), 4)
@@ -191,7 +208,8 @@ class ManyToManyTests(TestCase):
                 '<Article: NASA finds intelligent life on Earth>',
                 '<Article: NASA uses Python>',
                 '<Article: Oxygen-free diet works wonders>',
-            ])
+            ]
+        )
         self.assertQuerysetEqual(
             Article.objects.filter(publications__in=[self.p1, self.p2]).distinct(),
             [
@@ -199,20 +217,22 @@ class ManyToManyTests(TestCase):
                 '<Article: NASA finds intelligent life on Earth>',
                 '<Article: NASA uses Python>',
                 '<Article: Oxygen-free diet works wonders>',
-            ])
+            ]
+        )
 
         # Excluding a related item works as you would expect, too (although the SQL
         # involved is a little complex).
-        self.assertQuerysetEqual(Article.objects.exclude(publications=self.p2),
-                                 ['<Article: Django lets you build Web apps easily>'])
+        self.assertQuerysetEqual(
+            Article.objects.exclude(publications=self.p2),
+            ['<Article: Django lets you build Web apps easily>']
+        )
 
     def test_reverse_selects(self):
         # Reverse m2m queries are supported (i.e., starting at the table that
         # doesn't have a ManyToManyField).
-        self.assertQuerysetEqual(Publication.objects.filter(id__exact=self.p1.id),
-                                 ['<Publication: The Python Journal>'])
-        self.assertQuerysetEqual(Publication.objects.filter(pk=self.p1.id),
-                                 ['<Publication: The Python Journal>'])
+        python_journal = ['<Publication: The Python Journal>']
+        self.assertQuerysetEqual(Publication.objects.filter(id__exact=self.p1.id), python_journal)
+        self.assertQuerysetEqual(Publication.objects.filter(pk=self.p1.id), python_journal)
         self.assertQuerysetEqual(
             Publication.objects.filter(article__headline__startswith="NASA"),
             [
@@ -222,14 +242,11 @@ class ManyToManyTests(TestCase):
                 '<Publication: Science Weekly>',
                 '<Publication: The Python Journal>',
             ])
-        self.assertQuerysetEqual(Publication.objects.filter(article__id__exact=self.a1.id),
-                                 ['<Publication: The Python Journal>'])
-        self.assertQuerysetEqual(Publication.objects.filter(article__pk=self.a1.id),
-                                 ['<Publication: The Python Journal>'])
-        self.assertQuerysetEqual(Publication.objects.filter(article=self.a1.id),
-                                 ['<Publication: The Python Journal>'])
-        self.assertQuerysetEqual(Publication.objects.filter(article=self.a1),
-                                 ['<Publication: The Python Journal>'])
+
+        self.assertQuerysetEqual(Publication.objects.filter(article__id__exact=self.a1.id), python_journal)
+        self.assertQuerysetEqual(Publication.objects.filter(article__pk=self.a1.id), python_journal)
+        self.assertQuerysetEqual(Publication.objects.filter(article=self.a1.id), python_journal)
+        self.assertQuerysetEqual(Publication.objects.filter(article=self.a1), python_journal)
 
         self.assertQuerysetEqual(
             Publication.objects.filter(article__in=[self.a1.id, self.a2.id]).distinct(),
@@ -259,47 +276,59 @@ class ManyToManyTests(TestCase):
     def test_delete(self):
         # If we delete a Publication, its Articles won't be able to access it.
         self.p1.delete()
-        self.assertQuerysetEqual(Publication.objects.all(),
+        self.assertQuerysetEqual(
+            Publication.objects.all(),
             [
                 '<Publication: Highlights for Children>',
                 '<Publication: Science News>',
                 '<Publication: Science Weekly>',
-            ])
+            ]
+        )
         self.assertQuerysetEqual(self.a1.publications.all(), [])
         # If we delete an Article, its Publications won't be able to access it.
         self.a2.delete()
-        self.assertQuerysetEqual(Article.objects.all(),
+        self.assertQuerysetEqual(
+            Article.objects.all(),
             [
                 '<Article: Django lets you build Web apps easily>',
                 '<Article: NASA finds intelligent life on Earth>',
                 '<Article: Oxygen-free diet works wonders>',
-            ])
-        self.assertQuerysetEqual(self.p2.article_set.all(),
+            ]
+        )
+        self.assertQuerysetEqual(
+            self.p2.article_set.all(),
             [
                 '<Article: NASA finds intelligent life on Earth>',
                 '<Article: Oxygen-free diet works wonders>',
-            ])
+            ]
+        )
 
     def test_bulk_delete(self):
         # Bulk delete some Publications - references to deleted publications should go
         Publication.objects.filter(title__startswith='Science').delete()
-        self.assertQuerysetEqual(Publication.objects.all(),
+        self.assertQuerysetEqual(
+            Publication.objects.all(),
             [
                 '<Publication: Highlights for Children>',
                 '<Publication: The Python Journal>',
-            ])
-        self.assertQuerysetEqual(Article.objects.all(),
+            ]
+        )
+        self.assertQuerysetEqual(
+            Article.objects.all(),
             [
                 '<Article: Django lets you build Web apps easily>',
                 '<Article: NASA finds intelligent life on Earth>',
                 '<Article: NASA uses Python>',
                 '<Article: Oxygen-free diet works wonders>',
-            ])
-        self.assertQuerysetEqual(self.a2.publications.all(),
+            ]
+        )
+        self.assertQuerysetEqual(
+            self.a2.publications.all(),
             [
                 '<Publication: Highlights for Children>',
                 '<Publication: The Python Journal>',
-            ])
+            ]
+        )
 
         # Bulk delete some articles - references to deleted objects should go
         q = Article.objects.filter(headline__startswith='Django')
@@ -308,46 +337,45 @@ class ManyToManyTests(TestCase):
         # After the delete, the QuerySet cache needs to be cleared,
         # and the referenced objects should be gone
         self.assertQuerysetEqual(q, [])
-        self.assertQuerysetEqual(self.p1.article_set.all(),
-                                 ['<Article: NASA uses Python>'])
+        self.assertQuerysetEqual(self.p1.article_set.all(), ['<Article: NASA uses Python>'])
 
     def test_remove(self):
         # Removing publication from an article:
-        self.assertQuerysetEqual(self.p2.article_set.all(),
+        self.assertQuerysetEqual(
+            self.p2.article_set.all(),
             [
                 '<Article: NASA finds intelligent life on Earth>',
                 '<Article: NASA uses Python>',
                 '<Article: Oxygen-free diet works wonders>',
-            ])
+            ]
+        )
         self.a4.publications.remove(self.p2)
-        self.assertQuerysetEqual(self.p2.article_set.all(),
+        self.assertQuerysetEqual(
+            self.p2.article_set.all(),
             [
                 '<Article: NASA finds intelligent life on Earth>',
                 '<Article: NASA uses Python>',
-            ])
+            ]
+        )
         self.assertQuerysetEqual(self.a4.publications.all(), [])
         # And from the other end
         self.p2.article_set.remove(self.a3)
-        self.assertQuerysetEqual(self.p2.article_set.all(),
-            [
-                '<Article: NASA uses Python>',
-            ])
+        self.assertQuerysetEqual(self.p2.article_set.all(), ['<Article: NASA uses Python>'])
         self.assertQuerysetEqual(self.a3.publications.all(), [])
 
     def test_set(self):
         self.p2.article_set.set([self.a4, self.a3])
-        self.assertQuerysetEqual(self.p2.article_set.all(),
+        self.assertQuerysetEqual(
+            self.p2.article_set.all(),
             [
                 '<Article: NASA finds intelligent life on Earth>',
                 '<Article: Oxygen-free diet works wonders>',
-            ])
-        self.assertQuerysetEqual(self.a4.publications.all(),
-                                 ['<Publication: Science News>'])
+            ]
+        )
+        self.assertQuerysetEqual(self.a4.publications.all(), ['<Publication: Science News>'])
         self.a4.publications.set([self.p3.id])
-        self.assertQuerysetEqual(self.p2.article_set.all(),
-                                 ['<Article: NASA finds intelligent life on Earth>'])
-        self.assertQuerysetEqual(self.a4.publications.all(),
-                                 ['<Publication: Science Weekly>'])
+        self.assertQuerysetEqual(self.p2.article_set.all(), ['<Article: NASA finds intelligent life on Earth>'])
+        self.assertQuerysetEqual(self.a4.publications.all(), ['<Publication: Science Weekly>'])
 
         self.p2.article_set.set([])
         self.assertQuerysetEqual(self.p2.article_set.all(), [])
@@ -355,18 +383,17 @@ class ManyToManyTests(TestCase):
         self.assertQuerysetEqual(self.a4.publications.all(), [])
 
         self.p2.article_set.set([self.a4, self.a3], clear=True)
-        self.assertQuerysetEqual(self.p2.article_set.all(),
+        self.assertQuerysetEqual(
+            self.p2.article_set.all(),
             [
                 '<Article: NASA finds intelligent life on Earth>',
                 '<Article: Oxygen-free diet works wonders>',
-            ])
-        self.assertQuerysetEqual(self.a4.publications.all(),
-                                 ['<Publication: Science News>'])
+            ]
+        )
+        self.assertQuerysetEqual(self.a4.publications.all(), ['<Publication: Science News>'])
         self.a4.publications.set([self.p3.id], clear=True)
-        self.assertQuerysetEqual(self.p2.article_set.all(),
-                                 ['<Article: NASA finds intelligent life on Earth>'])
-        self.assertQuerysetEqual(self.a4.publications.all(),
-                                 ['<Publication: Science Weekly>'])
+        self.assertQuerysetEqual(self.p2.article_set.all(), ['<Article: NASA finds intelligent life on Earth>'])
+        self.assertQuerysetEqual(self.a4.publications.all(), ['<Publication: Science Weekly>'])
 
         self.p2.article_set.set([], clear=True)
         self.assertQuerysetEqual(self.p2.article_set.all(), [])
@@ -385,18 +412,17 @@ class ManyToManyTests(TestCase):
     @ignore_warnings(category=RemovedInDjango20Warning)
     def test_assign_deprecated(self):
         self.p2.article_set = [self.a4, self.a3]
-        self.assertQuerysetEqual(self.p2.article_set.all(),
+        self.assertQuerysetEqual(
+            self.p2.article_set.all(),
             [
                 '<Article: NASA finds intelligent life on Earth>',
                 '<Article: Oxygen-free diet works wonders>',
-            ])
-        self.assertQuerysetEqual(self.a4.publications.all(),
-                                 ['<Publication: Science News>'])
+            ]
+        )
+        self.assertQuerysetEqual(self.a4.publications.all(), ['<Publication: Science News>'])
         self.a4.publications = [self.p3.id]
-        self.assertQuerysetEqual(self.p2.article_set.all(),
-                                 ['<Article: NASA finds intelligent life on Earth>'])
-        self.assertQuerysetEqual(self.a4.publications.all(),
-                                 ['<Publication: Science Weekly>'])
+        self.assertQuerysetEqual(self.p2.article_set.all(), ['<Article: NASA finds intelligent life on Earth>'])
+        self.assertQuerysetEqual(self.a4.publications.all(), ['<Publication: Science Weekly>'])
 
         # An alternate to calling clear() is to assign the empty set
         self.p2.article_set = []
@@ -427,18 +453,17 @@ class ManyToManyTests(TestCase):
     def test_assign_ids(self):
         # Relation sets can also be set using primary key values
         self.p2.article_set.set([self.a4.id, self.a3.id])
-        self.assertQuerysetEqual(self.p2.article_set.all(),
+        self.assertQuerysetEqual(
+            self.p2.article_set.all(),
             [
                 '<Article: NASA finds intelligent life on Earth>',
                 '<Article: Oxygen-free diet works wonders>',
-            ])
-        self.assertQuerysetEqual(self.a4.publications.all(),
-                                 ['<Publication: Science News>'])
+            ]
+        )
+        self.assertQuerysetEqual(self.a4.publications.all(), ['<Publication: Science News>'])
         self.a4.publications.set([self.p3.id])
-        self.assertQuerysetEqual(self.p2.article_set.all(),
-                                 ['<Article: NASA finds intelligent life on Earth>'])
-        self.assertQuerysetEqual(self.a4.publications.all(),
-                                 ['<Publication: Science Weekly>'])
+        self.assertQuerysetEqual(self.p2.article_set.all(), ['<Article: NASA finds intelligent life on Earth>'])
+        self.assertQuerysetEqual(self.a4.publications.all(), ['<Publication: Science Weekly>'])
 
     def test_forward_assign_with_queryset(self):
         # Ensure that querysets used in m2m assignments are pre-evaluated
@@ -472,19 +497,17 @@ class ManyToManyTests(TestCase):
 
         # And you can clear from the other end
         self.p2.article_set.add(self.a3, self.a4)
-        self.assertQuerysetEqual(self.p2.article_set.all(),
+        self.assertQuerysetEqual(
+            self.p2.article_set.all(),
             [
                 '<Article: NASA finds intelligent life on Earth>',
                 '<Article: Oxygen-free diet works wonders>',
-            ])
-        self.assertQuerysetEqual(self.a4.publications.all(),
-            [
-                '<Publication: Science News>',
-            ])
+            ]
+        )
+        self.assertQuerysetEqual(self.a4.publications.all(), ['<Publication: Science News>'])
         self.a4.publications.clear()
         self.assertQuerysetEqual(self.a4.publications.all(), [])
-        self.assertQuerysetEqual(self.p2.article_set.all(),
-                                 ['<Article: NASA finds intelligent life on Earth>'])
+        self.assertQuerysetEqual(self.p2.article_set.all(), ['<Article: NASA finds intelligent life on Earth>'])
 
     def test_inherited_models_selects(self):
         """
@@ -494,19 +517,19 @@ class ManyToManyTests(TestCase):
         a = InheritedArticleA.objects.create()
         b = InheritedArticleB.objects.create()
         a.publications.add(self.p1, self.p2)
-        self.assertQuerysetEqual(a.publications.all(),
+        self.assertQuerysetEqual(
+            a.publications.all(),
             [
                 '<Publication: Science News>',
                 '<Publication: The Python Journal>',
             ])
         self.assertQuerysetEqual(b.publications.all(), [])
         b.publications.add(self.p3)
-        self.assertQuerysetEqual(a.publications.all(),
+        self.assertQuerysetEqual(
+            a.publications.all(),
             [
                 '<Publication: Science News>',
                 '<Publication: The Python Journal>',
-            ])
-        self.assertQuerysetEqual(b.publications.all(),
-            [
-                '<Publication: Science Weekly>',
-            ])
+            ]
+        )
+        self.assertQuerysetEqual(b.publications.all(), ['<Publication: Science Weekly>'])
diff --git a/tests/many_to_one/tests.py b/tests/many_to_one/tests.py
index b3028e00ca..e8210955ce 100644
--- a/tests/many_to_one/tests.py
+++ b/tests/many_to_one/tests.py
@@ -22,8 +22,7 @@ class ManyToOneTests(TestCase):
         self.r2 = Reporter(first_name='Paul', last_name='Jones', email='paul@example.com')
         self.r2.save()
         # Create an Article.
-        self.a = Article(id=None, headline="This is a test",
-                         pub_date=datetime.date(2005, 7, 27), reporter=self.r)
+        self.a = Article(headline="This is a test", pub_date=datetime.date(2005, 7, 27), reporter=self.r)
         self.a.save()
 
     def test_get(self):
@@ -38,21 +37,18 @@ class ManyToOneTests(TestCase):
     def test_create(self):
         # You can also instantiate an Article by passing the Reporter's ID
         # instead of a Reporter object.
-        a3 = Article(id=None, headline="Third article",
-                     pub_date=datetime.date(2005, 7, 27), reporter_id=self.r.id)
+        a3 = Article(headline="Third article", pub_date=datetime.date(2005, 7, 27), reporter_id=self.r.id)
         a3.save()
         self.assertEqual(a3.reporter.id, self.r.id)
 
         # Similarly, the reporter ID can be a string.
-        a4 = Article(id=None, headline="Fourth article",
-                     pub_date=datetime.date(2005, 7, 27), reporter_id=str(self.r.id))
+        a4 = Article(headline="Fourth article", pub_date=datetime.date(2005, 7, 27), reporter_id=str(self.r.id))
         a4.save()
         self.assertEqual(repr(a4.reporter), "<Reporter: John Smith>")
 
     def test_add(self):
         # Create an Article via the Reporter object.
-        new_article = self.r.article_set.create(headline="John's second story",
-                                                pub_date=datetime.date(2005, 7, 29))
+        new_article = self.r.article_set.create(headline="John's second story", pub_date=datetime.date(2005, 7, 29))
         self.assertEqual(repr(new_article), "<Article: John's second story>")
         self.assertEqual(new_article.reporter.id, self.r.id)
 
@@ -64,12 +60,10 @@ class ManyToOneTests(TestCase):
 
         self.r.article_set.add(new_article2, bulk=False)
         self.assertEqual(new_article2.reporter.id, self.r.id)
-        self.assertQuerysetEqual(self.r.article_set.all(),
-            [
-                "<Article: John's second story>",
-                "<Article: Paul's story>",
-                "<Article: This is a test>",
-            ])
+        self.assertQuerysetEqual(
+            self.r.article_set.all(),
+            ["<Article: John's second story>", "<Article: Paul's story>", "<Article: This is a test>"]
+        )
 
         # Add the same article to a different article set - check that it moves.
         self.r2.article_set.add(new_article2)
@@ -81,17 +75,14 @@ class ManyToOneTests(TestCase):
             with six.assertRaisesRegex(self, TypeError,
                                        "'Article' instance expected, got <Reporter.*"):
                 self.r.article_set.add(self.r2)
-        self.assertQuerysetEqual(self.r.article_set.all(),
-            [
-                "<Article: John's second story>",
-                "<Article: This is a test>",
-            ])
+        self.assertQuerysetEqual(
+            self.r.article_set.all(),
+            ["<Article: John's second story>", "<Article: This is a test>"]
+        )
 
     def test_set(self):
-        new_article = self.r.article_set.create(headline="John's second story",
-                                                pub_date=datetime.date(2005, 7, 29))
-        new_article2 = self.r2.article_set.create(headline="Paul's story",
-                                                  pub_date=datetime.date(2006, 1, 17))
+        new_article = self.r.article_set.create(headline="John's second story", pub_date=datetime.date(2005, 7, 29))
+        new_article2 = self.r2.article_set.create(headline="Paul's story", pub_date=datetime.date(2006, 1, 17))
 
         # Assign the article to the reporter.
         new_article2.reporter = self.r
@@ -108,20 +99,18 @@ class ManyToOneTests(TestCase):
         # Set the article back again.
         self.r2.article_set.set([new_article, new_article2])
         self.assertQuerysetEqual(self.r.article_set.all(), ["<Article: This is a test>"])
-        self.assertQuerysetEqual(self.r2.article_set.all(),
-            [
-                "<Article: John's second story>",
-                "<Article: Paul's story>",
-            ])
+        self.assertQuerysetEqual(
+            self.r2.article_set.all(),
+            ["<Article: John's second story>", "<Article: Paul's story>"]
+        )
 
         # Funny case - because the ForeignKey cannot be null,
         # existing members of the set must remain.
         self.r.article_set.set([new_article])
-        self.assertQuerysetEqual(self.r.article_set.all(),
-            [
-                "<Article: John's second story>",
-                "<Article: This is a test>",
-            ])
+        self.assertQuerysetEqual(
+            self.r.article_set.all(),
+            ["<Article: John's second story>", "<Article: This is a test>"]
+        )
         self.assertQuerysetEqual(self.r2.article_set.all(), ["<Article: Paul's story>"])
 
     def test_reverse_assignment_deprecation(self):
@@ -134,10 +123,8 @@ class ManyToOneTests(TestCase):
             self.r2.article_set = []
 
     def test_assign(self):
-        new_article = self.r.article_set.create(headline="John's second story",
-                                                pub_date=datetime.date(2005, 7, 29))
-        new_article2 = self.r2.article_set.create(headline="Paul's story",
-                                                  pub_date=datetime.date(2006, 1, 17))
+        new_article = self.r.article_set.create(headline="John's second story", pub_date=datetime.date(2005, 7, 29))
+        new_article2 = self.r2.article_set.create(headline="Paul's story", pub_date=datetime.date(2006, 1, 17))
 
         # Assign the article to the reporter directly using the descriptor.
         new_article2.reporter = self.r
@@ -154,73 +141,59 @@ class ManyToOneTests(TestCase):
         # Set the article back again using set() method.
         self.r2.article_set.set([new_article, new_article2])
         self.assertQuerysetEqual(self.r.article_set.all(), ["<Article: This is a test>"])
-        self.assertQuerysetEqual(self.r2.article_set.all(),
-            [
-                "<Article: John's second story>",
-                "<Article: Paul's story>",
-            ])
+        self.assertQuerysetEqual(
+            self.r2.article_set.all(),
+            ["<Article: John's second story>", "<Article: Paul's story>"]
+        )
 
         # Because the ForeignKey cannot be null, existing members of the set
         # must remain.
         self.r.article_set.set([new_article])
-        self.assertQuerysetEqual(self.r.article_set.all(),
-            [
-                "<Article: John's second story>",
-                "<Article: This is a test>",
-            ])
+        self.assertQuerysetEqual(
+            self.r.article_set.all(),
+            ["<Article: John's second story>", "<Article: This is a test>"]
+        )
         self.assertQuerysetEqual(self.r2.article_set.all(), ["<Article: Paul's story>"])
         # Reporter cannot be null - there should not be a clear or remove method
         self.assertFalse(hasattr(self.r2.article_set, 'remove'))
         self.assertFalse(hasattr(self.r2.article_set, 'clear'))
 
     def test_selects(self):
-        self.r.article_set.create(headline="John's second story",
-                                  pub_date=datetime.date(2005, 7, 29))
-        self.r2.article_set.create(headline="Paul's story",
-                                   pub_date=datetime.date(2006, 1, 17))
+        self.r.article_set.create(headline="John's second story", pub_date=datetime.date(2005, 7, 29))
+        self.r2.article_set.create(headline="Paul's story", pub_date=datetime.date(2006, 1, 17))
         # Reporter objects have access to their related Article objects.
         self.assertQuerysetEqual(self.r.article_set.all(), [
             "<Article: John's second story>",
             "<Article: This is a test>",
         ])
-        self.assertQuerysetEqual(self.r.article_set.filter(headline__startswith='This'),
-                                 ["<Article: This is a test>"])
+        self.assertQuerysetEqual(self.r.article_set.filter(headline__startswith='This'), ["<Article: This is a test>"])
         self.assertEqual(self.r.article_set.count(), 2)
         self.assertEqual(self.r2.article_set.count(), 1)
         # Get articles by id
-        self.assertQuerysetEqual(Article.objects.filter(id__exact=self.a.id),
-                                 ["<Article: This is a test>"])
-        self.assertQuerysetEqual(Article.objects.filter(pk=self.a.id),
-                                 ["<Article: This is a test>"])
+        self.assertQuerysetEqual(Article.objects.filter(id__exact=self.a.id), ["<Article: This is a test>"])
+        self.assertQuerysetEqual(Article.objects.filter(pk=self.a.id), ["<Article: This is a test>"])
         # Query on an article property
-        self.assertQuerysetEqual(Article.objects.filter(headline__startswith='This'),
-                                 ["<Article: This is a test>"])
+        self.assertQuerysetEqual(Article.objects.filter(headline__startswith='This'), ["<Article: This is a test>"])
         # The API automatically follows relationships as far as you need.
         # Use double underscores to separate relationships.
         # This works as many levels deep as you want. There's no limit.
         # Find all Articles for any Reporter whose first name is "John".
-        self.assertQuerysetEqual(Article.objects.filter(reporter__first_name__exact='John'),
-            [
-                "<Article: John's second story>",
-                "<Article: This is a test>",
-            ])
+        self.assertQuerysetEqual(
+            Article.objects.filter(reporter__first_name__exact='John'),
+            ["<Article: John's second story>", "<Article: This is a test>"]
+        )
         # Check that implied __exact also works
-        self.assertQuerysetEqual(Article.objects.filter(reporter__first_name='John'),
-            [
-                "<Article: John's second story>",
-                "<Article: This is a test>",
-            ])
+        self.assertQuerysetEqual(
+            Article.objects.filter(reporter__first_name='John'),
+            ["<Article: John's second story>", "<Article: This is a test>"]
+        )
         # Query twice over the related field.
         self.assertQuerysetEqual(
-            Article.objects.filter(reporter__first_name__exact='John',
-                                   reporter__last_name__exact='Smith'),
-            [
-                "<Article: John's second story>",
-                "<Article: This is a test>",
-            ])
+            Article.objects.filter(reporter__first_name__exact='John', reporter__last_name__exact='Smith'),
+            ["<Article: John's second story>", "<Article: This is a test>"]
+        )
         # The underlying query only makes one join when a related table is referenced twice.
-        queryset = Article.objects.filter(reporter__first_name__exact='John',
-                                       reporter__last_name__exact='Smith')
+        queryset = Article.objects.filter(reporter__first_name__exact='John', reporter__last_name__exact='Smith')
         self.assertNumQueries(1, list, queryset)
         self.assertEqual(queryset.query.get_compiler(queryset.db).as_sql()[0].count('INNER JOIN'), 1)
 
@@ -228,19 +201,15 @@ class ManyToOneTests(TestCase):
         self.assertQuerysetEqual(
             Article.objects.filter(reporter__first_name__exact='John').extra(
                 where=["many_to_one_reporter.last_name='Smith'"]),
-            [
-                "<Article: John's second story>",
-                "<Article: This is a test>",
-            ])
+            ["<Article: John's second story>", "<Article: This is a test>"]
+        )
         # ... and should work fine with the unicode that comes out of forms.Form.cleaned_data
         self.assertQuerysetEqual(
             (Article.objects
                 .filter(reporter__first_name__exact='John')
                 .extra(where=["many_to_one_reporter.last_name='%s'" % 'Smith'])),
-            [
-                "<Article: John's second story>",
-                "<Article: This is a test>",
-            ])
+            ["<Article: John's second story>", "<Article: This is a test>"]
+        )
         # Find all Articles for a Reporter.
         # Use direct ID check, pk check, and object comparison
         self.assertQuerysetEqual(
@@ -294,49 +263,39 @@ class ManyToOneTests(TestCase):
             ])
 
     def test_reverse_selects(self):
-        a3 = Article.objects.create(id=None, headline="Third article",
-                                    pub_date=datetime.date(2005, 7, 27), reporter_id=self.r.id)
-        Article.objects.create(id=None, headline="Fourth article",
-                               pub_date=datetime.date(2005, 7, 27), reporter_id=str(self.r.id))
+        a3 = Article.objects.create(
+            headline="Third article",
+            pub_date=datetime.date(2005, 7, 27),
+            reporter_id=self.r.id,
+        )
+        Article.objects.create(
+            headline="Fourth article",
+            pub_date=datetime.date(2005, 7, 27),
+            reporter_id=self.r.id,
+        )
+        john_smith = ["<Reporter: John Smith>"]
         # Reporters can be queried
-        self.assertQuerysetEqual(Reporter.objects.filter(id__exact=self.r.id),
-                                 ["<Reporter: John Smith>"])
-        self.assertQuerysetEqual(Reporter.objects.filter(pk=self.r.id),
-                                 ["<Reporter: John Smith>"])
-        self.assertQuerysetEqual(Reporter.objects.filter(first_name__startswith='John'),
-                                 ["<Reporter: John Smith>"])
+        self.assertQuerysetEqual(Reporter.objects.filter(id__exact=self.r.id), john_smith)
+        self.assertQuerysetEqual(Reporter.objects.filter(pk=self.r.id), john_smith)
+        self.assertQuerysetEqual(Reporter.objects.filter(first_name__startswith='John'), john_smith)
         # Reporters can query in opposite direction of ForeignKey definition
-        self.assertQuerysetEqual(Reporter.objects.filter(article__id__exact=self.a.id),
-                                 ["<Reporter: John Smith>"])
-        self.assertQuerysetEqual(Reporter.objects.filter(article__pk=self.a.id),
-                                 ["<Reporter: John Smith>"])
-        self.assertQuerysetEqual(Reporter.objects.filter(article=self.a.id),
-                                 ["<Reporter: John Smith>"])
-        self.assertQuerysetEqual(Reporter.objects.filter(article=self.a),
-                                 ["<Reporter: John Smith>"])
-        self.assertQuerysetEqual(
-            Reporter.objects.filter(article__in=[self.a.id, a3.id]).distinct(),
-            ["<Reporter: John Smith>"])
-        self.assertQuerysetEqual(
-            Reporter.objects.filter(article__in=[self.a.id, a3]).distinct(),
-            ["<Reporter: John Smith>"])
-        self.assertQuerysetEqual(
-            Reporter.objects.filter(article__in=[self.a, a3]).distinct(),
-            ["<Reporter: John Smith>"])
+        self.assertQuerysetEqual(Reporter.objects.filter(article__id__exact=self.a.id), john_smith)
+        self.assertQuerysetEqual(Reporter.objects.filter(article__pk=self.a.id), john_smith)
+        self.assertQuerysetEqual(Reporter.objects.filter(article=self.a.id), john_smith)
+        self.assertQuerysetEqual(Reporter.objects.filter(article=self.a), john_smith)
+        self.assertQuerysetEqual(Reporter.objects.filter(article__in=[self.a.id, a3.id]).distinct(), john_smith)
+        self.assertQuerysetEqual(Reporter.objects.filter(article__in=[self.a.id, a3]).distinct(), john_smith)
+        self.assertQuerysetEqual(Reporter.objects.filter(article__in=[self.a, a3]).distinct(), john_smith)
         self.assertQuerysetEqual(
             Reporter.objects.filter(article__headline__startswith='T'),
             ["<Reporter: John Smith>", "<Reporter: John Smith>"],
             ordered=False
         )
-        self.assertQuerysetEqual(
-            Reporter.objects.filter(article__headline__startswith='T').distinct(),
-            ["<Reporter: John Smith>"])
+        self.assertQuerysetEqual(Reporter.objects.filter(article__headline__startswith='T').distinct(), john_smith)
 
         # Counting in the opposite direction works in conjunction with distinct()
-        self.assertEqual(
-            Reporter.objects.filter(article__headline__startswith='T').count(), 2)
-        self.assertEqual(
-            Reporter.objects.filter(article__headline__startswith='T').distinct().count(), 1)
+        self.assertEqual(Reporter.objects.filter(article__headline__startswith='T').count(), 2)
+        self.assertEqual(Reporter.objects.filter(article__headline__startswith='T').distinct().count(), 1)
 
         # Queries can go round in circles.
         self.assertQuerysetEqual(
@@ -350,23 +309,21 @@ class ManyToOneTests(TestCase):
         )
         self.assertQuerysetEqual(
             Reporter.objects.filter(article__reporter__first_name__startswith='John').distinct(),
-            ["<Reporter: John Smith>"])
-        self.assertQuerysetEqual(
-            Reporter.objects.filter(article__reporter__exact=self.r).distinct(),
-            ["<Reporter: John Smith>"])
+            john_smith
+        )
+        self.assertQuerysetEqual(Reporter.objects.filter(article__reporter__exact=self.r).distinct(), john_smith)
 
         # Check that implied __exact also works.
-        self.assertQuerysetEqual(
-            Reporter.objects.filter(article__reporter=self.r).distinct(),
-            ["<Reporter: John Smith>"])
+        self.assertQuerysetEqual(Reporter.objects.filter(article__reporter=self.r).distinct(), john_smith)
 
         # It's possible to use values() calls across many-to-one relations.
         # (Note, too, that we clear the ordering here so as not to drag the
         # 'headline' field into the columns being used to determine uniqueness)
         d = {'reporter__first_name': 'John', 'reporter__last_name': 'Smith'}
-        self.assertEqual([d],
-            list(Article.objects.filter(reporter=self.r).distinct().order_by()
-                 .values('reporter__first_name', 'reporter__last_name')))
+        qs = Article.objects.filter(
+            reporter=self.r,
+        ).distinct().order_by().values('reporter__first_name', 'reporter__last_name')
+        self.assertEqual([d], list(qs))
 
     def test_select_related(self):
         # Check that Article.objects.select_related().dates() works properly when
@@ -376,55 +333,54 @@ class ManyToOneTests(TestCase):
         r2 = Reporter.objects.create(first_name='John', last_name='Kass', email='jkass@tribune.com')
         Article.objects.create(headline='First', pub_date=datetime.date(1980, 4, 23), reporter=r1)
         Article.objects.create(headline='Second', pub_date=datetime.date(1980, 4, 23), reporter=r2)
-        self.assertEqual(list(Article.objects.select_related().dates('pub_date', 'day')),
-            [
-                datetime.date(1980, 4, 23),
-                datetime.date(2005, 7, 27),
-            ])
-        self.assertEqual(list(Article.objects.select_related().dates('pub_date', 'month')),
-            [
-                datetime.date(1980, 4, 1),
-                datetime.date(2005, 7, 1),
-            ])
-        self.assertEqual(list(Article.objects.select_related().dates('pub_date', 'year')),
-            [
-                datetime.date(1980, 1, 1),
-                datetime.date(2005, 1, 1),
-            ])
+        self.assertEqual(
+            list(Article.objects.select_related().dates('pub_date', 'day')),
+            [datetime.date(1980, 4, 23), datetime.date(2005, 7, 27)]
+        )
+        self.assertEqual(
+            list(Article.objects.select_related().dates('pub_date', 'month')),
+            [datetime.date(1980, 4, 1), datetime.date(2005, 7, 1)]
+        )
+        self.assertEqual(
+            list(Article.objects.select_related().dates('pub_date', 'year')),
+            [datetime.date(1980, 1, 1), datetime.date(2005, 1, 1)]
+        )
 
     def test_delete(self):
-        self.r.article_set.create(headline="John's second story",
-                                  pub_date=datetime.date(2005, 7, 29))
-        self.r2.article_set.create(headline="Paul's story",
-                                   pub_date=datetime.date(2006, 1, 17))
-        Article.objects.create(id=None, headline="Third article",
-                               pub_date=datetime.date(2005, 7, 27), reporter_id=self.r.id)
-        Article.objects.create(id=None, headline="Fourth article",
-                               pub_date=datetime.date(2005, 7, 27), reporter_id=str(self.r.id))
+        self.r.article_set.create(headline="John's second story", pub_date=datetime.date(2005, 7, 29))
+        self.r2.article_set.create(headline="Paul's story", pub_date=datetime.date(2006, 1, 17))
+        Article.objects.create(headline="Third article", pub_date=datetime.date(2005, 7, 27), reporter_id=self.r.id)
+        Article.objects.create(
+            headline="Fourth article",
+            pub_date=datetime.date(2005, 7, 27),
+            reporter_id=str(self.r.id),
+        )
         # If you delete a reporter, his articles will be deleted.
-        self.assertQuerysetEqual(Article.objects.all(),
+        self.assertQuerysetEqual(
+            Article.objects.all(),
             [
                 "<Article: Fourth article>",
                 "<Article: John's second story>",
                 "<Article: Paul's story>",
                 "<Article: Third article>",
                 "<Article: This is a test>",
-            ])
-        self.assertQuerysetEqual(Reporter.objects.order_by('first_name'),
-            [
-                "<Reporter: John Smith>",
-                "<Reporter: Paul Jones>",
-            ])
+            ]
+        )
+        self.assertQuerysetEqual(
+            Reporter.objects.order_by('first_name'),
+            ["<Reporter: John Smith>", "<Reporter: Paul Jones>"]
+        )
         self.r2.delete()
-        self.assertQuerysetEqual(Article.objects.all(),
+        self.assertQuerysetEqual(
+            Article.objects.all(),
             [
                 "<Article: Fourth article>",
                 "<Article: John's second story>",
                 "<Article: Third article>",
                 "<Article: This is a test>",
-            ])
-        self.assertQuerysetEqual(Reporter.objects.order_by('first_name'),
-                                 ["<Reporter: John Smith>"])
+            ]
+        )
+        self.assertQuerysetEqual(Reporter.objects.order_by('first_name'), ["<Reporter: John Smith>"])
         # You can delete using a JOIN in the query.
         Reporter.objects.filter(article__headline__startswith='This').delete()
         self.assertQuerysetEqual(Reporter.objects.all(), [])
@@ -433,33 +389,35 @@ class ManyToOneTests(TestCase):
     def test_explicit_fk(self):
         # Create a new Article with get_or_create using an explicit value
         # for a ForeignKey.
-        a2, created = Article.objects.get_or_create(id=None,
-                                                    headline="John's second test",
-                                                    pub_date=datetime.date(2011, 5, 7),
-                                                    reporter_id=self.r.id)
+        a2, created = Article.objects.get_or_create(
+            headline="John's second test",
+            pub_date=datetime.date(2011, 5, 7),
+            reporter_id=self.r.id,
+        )
         self.assertTrue(created)
         self.assertEqual(a2.reporter.id, self.r.id)
 
         # You can specify filters containing the explicit FK value.
         self.assertQuerysetEqual(
             Article.objects.filter(reporter_id__exact=self.r.id),
-            [
-                "<Article: John's second test>",
-                "<Article: This is a test>",
-            ])
+            ["<Article: John's second test>", "<Article: This is a test>"]
+        )
 
         # Create an Article by Paul for the same date.
-        a3 = Article.objects.create(id=None, headline="Paul's commentary",
-                                    pub_date=datetime.date(2011, 5, 7),
-                                    reporter_id=self.r2.id)
+        a3 = Article.objects.create(
+            headline="Paul's commentary",
+            pub_date=datetime.date(2011, 5, 7),
+            reporter_id=self.r2.id,
+        )
         self.assertEqual(a3.reporter.id, self.r2.id)
 
         # Get should respect explicit foreign keys as well.
         with self.assertRaises(MultipleObjectsReturned):
             Article.objects.get(reporter_id=self.r.id)
-        self.assertEqual(repr(a3),
-                         repr(Article.objects.get(reporter_id=self.r2.id,
-                                             pub_date=datetime.date(2011, 5, 7))))
+        self.assertEqual(
+            repr(a3),
+            repr(Article.objects.get(reporter_id=self.r2.id, pub_date=datetime.date(2011, 5, 7)))
+        )
 
     def test_deepcopy_and_circular_references(self):
         # Regression for #12876 -- Model methods that include queries that
@@ -478,12 +436,9 @@ class ManyToOneTests(TestCase):
         self.assertIs(r1.article_set.__class__, r2.article_set.__class__)
 
     def test_create_relation_with_ugettext_lazy(self):
-        reporter = Reporter.objects.create(first_name='John',
-                                           last_name='Smith',
-                                           email='john.smith@example.com')
+        reporter = Reporter.objects.create(first_name='John', last_name='Smith', email='john.smith@example.com')
         lazy = ugettext_lazy('test')
-        reporter.article_set.create(headline=lazy,
-                                    pub_date=datetime.date(2011, 6, 10))
+        reporter.article_set.create(headline=lazy, pub_date=datetime.date(2011, 6, 10))
         notlazy = six.text_type(lazy)
         article = reporter.article_set.get()
         self.assertEqual(article.headline, notlazy)
@@ -632,10 +587,7 @@ class ManyToOneTests(TestCase):
         private_student = Student.objects.create(school=private_school)
 
         # Only one school is available via all() due to the custom default manager.
-        self.assertQuerysetEqual(
-            School.objects.all(),
-            ["<School: School object>"]
-        )
+        self.assertQuerysetEqual(School.objects.all(), ["<School: School object>"])
 
         self.assertEqual(public_student.school, public_school)
 
diff --git a/tests/middleware/test_security.py b/tests/middleware/test_security.py
index 3189c215b8..6a60473d57 100644
--- a/tests/middleware/test_security.py
+++ b/tests/middleware/test_security.py
@@ -86,10 +86,7 @@ class SecurityMiddlewareTest(SimpleTestCase):
         "includeSubDomains" tag to the response.
         """
         response = self.process_response(secure=True)
-        self.assertEqual(
-            response["strict-transport-security"],
-            "max-age=600; includeSubDomains",
-            )
+        self.assertEqual(response["strict-transport-security"], "max-age=600; includeSubDomains")
 
     @override_settings(
         SECURE_HSTS_SECONDS=600, SECURE_HSTS_INCLUDE_SUBDOMAINS=False)
diff --git a/tests/migrations/test_writer.py b/tests/migrations/test_writer.py
index 03dd5f7ed3..6c121e0904 100644
--- a/tests/migrations/test_writer.py
+++ b/tests/migrations/test_writer.py
@@ -625,7 +625,7 @@ class WriterTests(SimpleTestCase):
                 migrations.AlterModelOptions(
                     name='model',
                     options={'verbose_name': 'model', 'verbose_name_plural': 'models'},
-                    ),
+                ),
             ]
         })
         writer = MigrationWriter(migration)
diff --git a/tests/template_tests/test_response.py b/tests/template_tests/test_response.py
index 3e99134afb..85b5f4bf0f 100644
--- a/tests/template_tests/test_response.py
+++ b/tests/template_tests/test_response.py
@@ -270,7 +270,8 @@ class TemplateResponseTest(SimpleTestCase):
     def test_pickling(self):
         # Create a template response. The context is
         # known to be unpicklable (e.g., a function).
-        response = TemplateResponse(self.factory.get('/'),
+        response = TemplateResponse(
+            self.factory.get('/'),
             'first/test.html', {
                 'value': 123,
                 'fn': datetime.now,