diff --git a/docs/ref/models/expressions.txt b/docs/ref/models/expressions.txt
index 208b810048..60c4c87dcd 100644
--- a/docs/ref/models/expressions.txt
+++ b/docs/ref/models/expressions.txt
@@ -156,7 +156,7 @@ the field value on multiple objects - which could be very much faster than
 pulling them all into Python from the database, looping over them, incrementing
 the field value of each one, and saving each one back to the database::
 
-    Reporter.objects.all().update(stories_filed=F('stories_filed') + 1)
+    Reporter.objects.update(stories_filed=F('stories_filed') + 1)
 
 ``F()`` therefore can offer performance advantages by:
 
diff --git a/docs/ref/models/querysets.txt b/docs/ref/models/querysets.txt
index 25252b9cec..44950ecf52 100644
--- a/docs/ref/models/querysets.txt
+++ b/docs/ref/models/querysets.txt
@@ -1110,7 +1110,7 @@ item in the Pizza ``QuerySet``.
 
 We can reduce to just two queries using ``prefetch_related``:
 
-    >>> Pizza.objects.all().prefetch_related('toppings')
+    >>> Pizza.objects.prefetch_related('toppings')
 
 This implies a ``self.toppings.all()`` for each ``Pizza``; now each time
 ``self.toppings.all()`` is called, instead of having to go to the database for
@@ -1648,7 +1648,7 @@ one, doing so will result in an error.
 
         # Two equivalent QuerySets:
         CommonlyUsedModel.objects.all()
-        ManagedModel.objects.all().defer('f2')
+        ManagedModel.objects.defer('f2')
 
     If many fields need to be duplicated in the unmanaged model, it may be best
     to create an abstract model with the shared fields and then have the
@@ -3771,7 +3771,7 @@ as the string based lookups passed to
     <QuerySet [<Choice: Not much>, <Choice: The sky>, <Choice: Just hacking again>]>
     # This will only execute two queries regardless of the number of Question
     # and Choice objects.
-    >>> Question.objects.prefetch_related(Prefetch('choice_set')).all()
+    >>> Question.objects.prefetch_related(Prefetch('choice_set'))
     <QuerySet [<Question: What's up?>]>
 
 The ``queryset`` argument supplies a base ``QuerySet`` for the given lookup.
diff --git a/docs/topics/db/aggregation.txt b/docs/topics/db/aggregation.txt
index 772de0abdb..42be569cb4 100644
--- a/docs/topics/db/aggregation.txt
+++ b/docs/topics/db/aggregation.txt
@@ -56,12 +56,12 @@ above::
 
     # Average price across all books.
     >>> from django.db.models import Avg
-    >>> Book.objects.all().aggregate(Avg('price'))
+    >>> Book.objects.aggregate(Avg('price'))
     {'price__avg': 34.35}
 
     # Max price across all books.
     >>> from django.db.models import Max
-    >>> Book.objects.all().aggregate(Max('price'))
+    >>> Book.objects.aggregate(Max('price'))
     {'price__max': Decimal('81.20')}
 
     # Difference between the highest priced book and the average price of all books.
@@ -111,7 +111,7 @@ belong to this ``QuerySet``. This is done by appending an ``aggregate()``
 clause onto the ``QuerySet``::
 
     >>> from django.db.models import Avg
-    >>> Book.objects.all().aggregate(Avg('price'))
+    >>> Book.objects.aggregate(Avg('price'))
     {'price__avg': 34.35}
 
 The ``all()`` is redundant in this example, so this could be simplified to::
diff --git a/docs/topics/db/multi-db.txt b/docs/topics/db/multi-db.txt
index d74972b0e0..cf7d6fef4f 100644
--- a/docs/topics/db/multi-db.txt
+++ b/docs/topics/db/multi-db.txt
@@ -459,10 +459,10 @@ which you want to run the query. For example::
     >>> Author.objects.all()
 
     >>> # So will this.
-    >>> Author.objects.using('default').all()
+    >>> Author.objects.using('default')
 
     >>> # This will run on the 'other' database.
-    >>> Author.objects.using('other').all()
+    >>> Author.objects.using('other')
 
 Selecting a database for ``save()``
 -----------------------------------
diff --git a/docs/topics/db/queries.txt b/docs/topics/db/queries.txt
index 23326fb778..9e45f66bb5 100644
--- a/docs/topics/db/queries.txt
+++ b/docs/topics/db/queries.txt
@@ -1327,7 +1327,7 @@ new value to be the new model instance you want to point to. For example::
     >>> b = Blog.objects.get(pk=1)
 
     # Change every Entry so that it belongs to this Blog.
-    >>> Entry.objects.all().update(blog=b)
+    >>> Entry.objects.update(blog=b)
 
 The ``update()`` method is applied instantly and returns the number of rows
 matched by the query (which may not be equal to the number of rows updated if
@@ -1361,7 +1361,7 @@ update one field based on the value of another field in the model. This is
 especially useful for incrementing counters based upon their current value. For
 example, to increment the pingback count for every entry in the blog::
 
-    >>> Entry.objects.all().update(number_of_pingbacks=F('number_of_pingbacks') + 1)
+    >>> Entry.objects.update(number_of_pingbacks=F('number_of_pingbacks') + 1)
 
 However, unlike ``F()`` objects in filter and exclude clauses, you can't
 introduce joins when you use ``F()`` objects in an update -- you can only
diff --git a/tests/admin_filters/tests.py b/tests/admin_filters/tests.py
index ffce914d23..45801503f1 100644
--- a/tests/admin_filters/tests.py
+++ b/tests/admin_filters/tests.py
@@ -113,7 +113,7 @@ class DepartmentListFilterLookupWithNonStringValue(SimpleListFilter):
                     employee.department.id,  # Intentionally not a string (Refs #19318)
                     employee.department.code,
                 )
-                for employee in model_admin.get_queryset(request).all()
+                for employee in model_admin.get_queryset(request)
             }
         )
 
@@ -1150,7 +1150,7 @@ class ListFiltersTests(TestCase):
 
         # Make sure the correct queryset is returned
         queryset = changelist.get_queryset(request)
-        self.assertEqual(list(queryset), list(Book.objects.all().order_by("-id")))
+        self.assertEqual(list(queryset), list(Book.objects.order_by("-id")))
 
         # Make sure the correct choice is selected
         filterspec = changelist.get_filters(request)[0][1]
diff --git a/tests/admin_inlines/tests.py b/tests/admin_inlines/tests.py
index 91d69c8d17..b84faee190 100644
--- a/tests/admin_inlines/tests.py
+++ b/tests/admin_inlines/tests.py
@@ -1595,7 +1595,7 @@ class SeleniumTests(AdminSeleniumTestCase):
             self.selenium.find_element(By.XPATH, '//input[@value="Save"]').click()
 
         # The objects have been created in the database.
-        self.assertEqual(Inner4Stacked.objects.all().count(), 4)
+        self.assertEqual(Inner4Stacked.objects.count(), 4)
 
     def test_delete_invalid_tabular_inlines(self):
         from selenium.common.exceptions import NoSuchElementException
@@ -1664,7 +1664,7 @@ class SeleniumTests(AdminSeleniumTestCase):
             self.selenium.find_element(By.XPATH, '//input[@value="Save"]').click()
 
         # The objects have been created in the database.
-        self.assertEqual(Inner4Tabular.objects.all().count(), 4)
+        self.assertEqual(Inner4Tabular.objects.count(), 4)
 
     def test_add_inlines(self):
         """
@@ -1750,8 +1750,8 @@ class SeleniumTests(AdminSeleniumTestCase):
             self.selenium.find_element(By.XPATH, '//input[@value="Save"]').click()
 
         # The objects have been created in the database
-        self.assertEqual(ProfileCollection.objects.all().count(), 1)
-        self.assertEqual(Profile.objects.all().count(), 3)
+        self.assertEqual(ProfileCollection.objects.count(), 1)
+        self.assertEqual(Profile.objects.count(), 3)
 
     def test_add_inline_link_absent_for_view_only_parent_model(self):
         from selenium.common.exceptions import NoSuchElementException
diff --git a/tests/admin_views/test_actions.py b/tests/admin_views/test_actions.py
index ec690f5692..0c209019f3 100644
--- a/tests/admin_views/test_actions.py
+++ b/tests/admin_views/test_actions.py
@@ -190,7 +190,7 @@ class AdminActionsTest(TestCase):
         )
         # SubscriberAdmin.delete_queryset() sets overridden to True.
         self.assertIs(SubscriberAdmin.overridden, True)
-        self.assertEqual(Subscriber.objects.all().count(), 0)
+        self.assertEqual(Subscriber.objects.count(), 0)
 
     def test_delete_selected_uses_get_deleted_objects(self):
         """The delete_selected action uses ModelAdmin.get_deleted_objects()."""
diff --git a/tests/admin_views/tests.py b/tests/admin_views/tests.py
index 4d26ad7023..0e4a6b10be 100644
--- a/tests/admin_views/tests.py
+++ b/tests/admin_views/tests.py
@@ -1478,7 +1478,7 @@ class AdminCustomTemplateTests(AdminViewBasicTestCase):
         self.assertRedirects(
             post, reverse("admin:admin_views_customarticle_changelist")
         )
-        self.assertEqual(CustomArticle.objects.all().count(), 1)
+        self.assertEqual(CustomArticle.objects.count(), 1)
         article_pk = CustomArticle.objects.all()[0].pk
 
         # Test custom delete, change, and object history templates
@@ -5668,7 +5668,7 @@ class SeleniumTests(AdminSeleniumTestCase):
         # Save and check that everything is properly stored in the database
         with self.wait_page_loaded():
             self.selenium.find_element(By.XPATH, '//input[@value="Save"]').click()
-        self.assertEqual(MainPrepopulated.objects.all().count(), 1)
+        self.assertEqual(MainPrepopulated.objects.count(), 1)
         MainPrepopulated.objects.get(
             name=" the mAin nÀMë and it's awεšomeıııİ",
             pubdate="2012-02-18",
@@ -5677,7 +5677,7 @@ class SeleniumTests(AdminSeleniumTestCase):
             slug2="option-two-the-main-name-and-its-awesomeiiii",
             slug3="the-main-nàmë-and-its-awεšomeıııi",
         )
-        self.assertEqual(RelatedPrepopulated.objects.all().count(), 6)
+        self.assertEqual(RelatedPrepopulated.objects.count(), 6)
         RelatedPrepopulated.objects.get(
             name=" here is a sŤāÇkeð   inline !  ",
             pubdate="2011-12-17",
diff --git a/tests/aggregation/tests.py b/tests/aggregation/tests.py
index c71fedec1b..4ca8729a4b 100644
--- a/tests/aggregation/tests.py
+++ b/tests/aggregation/tests.py
@@ -178,7 +178,7 @@ class AggregateTestCase(TestCase):
         s3.books.add(cls.b3, cls.b4, cls.b6)
 
     def test_empty_aggregate(self):
-        self.assertEqual(Author.objects.all().aggregate(), {})
+        self.assertEqual(Author.objects.aggregate(), {})
 
     def test_aggregate_in_order_by(self):
         msg = (
@@ -209,11 +209,7 @@ class AggregateTestCase(TestCase):
         vals = Book.objects.filter(rating__lt=4.5).aggregate(Avg("authors__age"))
         self.assertEqual(vals, {"authors__age__avg": Approximate(38.2857, places=2)})
 
-        vals = (
-            Author.objects.all()
-            .filter(name__contains="a")
-            .aggregate(Avg("book__rating"))
-        )
+        vals = Author.objects.filter(name__contains="a").aggregate(Avg("book__rating"))
         self.assertEqual(vals, {"book__rating__avg": 4.0})
 
         vals = Book.objects.aggregate(Sum("publisher__num_awards"))
@@ -1016,7 +1012,7 @@ class AggregateTestCase(TestCase):
         """
         Aggregation over sliced queryset works correctly.
         """
-        qs = Book.objects.all().order_by("-rating")[0:3]
+        qs = Book.objects.order_by("-rating")[0:3]
         vals = qs.aggregate(average_top3_rating=Avg("rating"))["average_top3_rating"]
         self.assertAlmostEqual(vals, 4.5, places=2)
 
@@ -1026,8 +1022,7 @@ class AggregateTestCase(TestCase):
         select_related() stuff.
         """
         qs = (
-            Book.objects.all()
-            .select_for_update()
+            Book.objects.select_for_update()
             .order_by("pk")
             .select_related("publisher")
             .annotate(max_pk=Max("pk"))
@@ -2047,14 +2042,14 @@ class AggregateTestCase(TestCase):
         self.assertEqual(result["num_awards__sum"], 20)
 
     def test_exists_none_with_aggregate(self):
-        qs = Book.objects.all().annotate(
+        qs = Book.objects.annotate(
             count=Count("id"),
             exists=Exists(Author.objects.none()),
         )
         self.assertEqual(len(qs), 6)
 
     def test_exists_extra_where_with_aggregate(self):
-        qs = Book.objects.all().annotate(
+        qs = Book.objects.annotate(
             count=Count("id"),
             exists=Exists(Author.objects.extra(where=["1=0"])),
         )
diff --git a/tests/aggregation_regress/tests.py b/tests/aggregation_regress/tests.py
index 7b92b6d271..9582d90a96 100644
--- a/tests/aggregation_regress/tests.py
+++ b/tests/aggregation_regress/tests.py
@@ -471,12 +471,8 @@ class AggregationTests(TestCase):
     def test_aggregate_annotation(self):
         # Aggregates can be composed over annotations.
         # The return type is derived from the composed aggregate
-        vals = (
-            Book.objects.all()
-            .annotate(num_authors=Count("authors__id"))
-            .aggregate(
-                Max("pages"), Max("price"), Sum("num_authors"), Avg("num_authors")
-            )
+        vals = Book.objects.annotate(num_authors=Count("authors__id")).aggregate(
+            Max("pages"), Max("price"), Sum("num_authors"), Avg("num_authors")
         )
         self.assertEqual(
             vals,
@@ -588,10 +584,10 @@ class AggregationTests(TestCase):
             "pubdate, publisher, publisher_id, rating, store, tags"
         )
         with self.assertRaisesMessage(FieldError, msg):
-            Book.objects.all().aggregate(num_authors=Count("foo"))
+            Book.objects.aggregate(num_authors=Count("foo"))
 
         with self.assertRaisesMessage(FieldError, msg):
-            Book.objects.all().annotate(num_authors=Count("foo"))
+            Book.objects.annotate(num_authors=Count("foo"))
 
         msg = (
             "Cannot resolve keyword 'foo' into field. Choices are: authors, "
@@ -599,7 +595,7 @@ class AggregationTests(TestCase):
             "pages, price, pubdate, publisher, publisher_id, rating, store, tags"
         )
         with self.assertRaisesMessage(FieldError, msg):
-            Book.objects.all().annotate(num_authors=Count("authors__id")).aggregate(
+            Book.objects.annotate(num_authors=Count("authors__id")).aggregate(
                 Max("foo")
             )
 
@@ -932,7 +928,7 @@ class AggregationTests(TestCase):
             "the default name for another annotation."
         )
         with self.assertRaisesMessage(ValueError, msg):
-            Book.objects.all().annotate(
+            Book.objects.annotate(
                 Avg("authors__age"), authors__age__avg=Avg("authors__age")
             )
 
diff --git a/tests/auth_tests/test_models.py b/tests/auth_tests/test_models.py
index f3fe553c66..2d75b607bf 100644
--- a/tests/auth_tests/test_models.py
+++ b/tests/auth_tests/test_models.py
@@ -529,8 +529,8 @@ class AnonymousUserTests(SimpleTestCase):
         self.assertIs(self.user.is_staff, False)
         self.assertIs(self.user.is_active, False)
         self.assertIs(self.user.is_superuser, False)
-        self.assertEqual(self.user.groups.all().count(), 0)
-        self.assertEqual(self.user.user_permissions.all().count(), 0)
+        self.assertEqual(self.user.groups.count(), 0)
+        self.assertEqual(self.user.user_permissions.count(), 0)
         self.assertEqual(self.user.get_user_permissions(), set())
         self.assertEqual(self.user.get_group_permissions(), set())
 
diff --git a/tests/backends/sqlite/tests.py b/tests/backends/sqlite/tests.py
index 97505eaa36..0669d26191 100644
--- a/tests/backends/sqlite/tests.py
+++ b/tests/backends/sqlite/tests.py
@@ -28,13 +28,13 @@ class Tests(TestCase):
         """Raise NotSupportedError when aggregating on date/time fields."""
         for aggregate in (Sum, Avg, Variance, StdDev):
             with self.assertRaises(NotSupportedError):
-                Item.objects.all().aggregate(aggregate("time"))
+                Item.objects.aggregate(aggregate("time"))
             with self.assertRaises(NotSupportedError):
-                Item.objects.all().aggregate(aggregate("date"))
+                Item.objects.aggregate(aggregate("date"))
             with self.assertRaises(NotSupportedError):
-                Item.objects.all().aggregate(aggregate("last_modified"))
+                Item.objects.aggregate(aggregate("last_modified"))
             with self.assertRaises(NotSupportedError):
-                Item.objects.all().aggregate(
+                Item.objects.aggregate(
                     **{
                         "complex": aggregate("last_modified")
                         + aggregate("last_modified")
diff --git a/tests/basic/tests.py b/tests/basic/tests.py
index 403a761492..7be1595be5 100644
--- a/tests/basic/tests.py
+++ b/tests/basic/tests.py
@@ -32,12 +32,12 @@ class ModelInstanceCreationTests(TestCase):
             pub_date=datetime(2005, 7, 28),
         )
         self.assertIsNone(a.id)
-        self.assertEqual(Article.objects.all().count(), 0)
+        self.assertEqual(Article.objects.count(), 0)
 
         # Save it into the database. You have to call save() explicitly.
         a.save()
         self.assertIsNotNone(a.id)
-        self.assertEqual(Article.objects.all().count(), 1)
+        self.assertEqual(Article.objects.count(), 1)
 
     def test_can_initialize_model_instance_using_positional_arguments(self):
         """
@@ -199,7 +199,7 @@ class ModelTest(TestCase):
         for headline in headlines:
             Article(headline=headline, pub_date=some_pub_date).save()
         self.assertQuerysetEqual(
-            Article.objects.all().order_by("headline"),
+            Article.objects.order_by("headline"),
             sorted(headlines),
             transform=lambda a: a.headline,
         )
diff --git a/tests/cache/tests.py b/tests/cache/tests.py
index 40ba275eb7..460e8141d2 100644
--- a/tests/cache/tests.py
+++ b/tests/cache/tests.py
@@ -454,7 +454,7 @@ class BaseCacheTests:
         Poll.objects.all().delete()
         Poll.objects.create(question="What?")
         self.assertEqual(expensive_calculation.num_runs, 1)
-        defer_qs = Poll.objects.all().defer("question")
+        defer_qs = Poll.objects.defer("question")
         self.assertEqual(defer_qs.count(), 1)
         self.assertEqual(expensive_calculation.num_runs, 1)
         cache.set("deferred_queryset", defer_qs)
@@ -467,7 +467,7 @@ class BaseCacheTests:
         Poll.objects.all().delete()
         Poll.objects.create(question="What?")
         self.assertEqual(expensive_calculation.num_runs, 1)
-        defer_qs = Poll.objects.all().defer("question")
+        defer_qs = Poll.objects.defer("question")
         self.assertEqual(defer_qs.count(), 1)
         cache.set("deferred_queryset", defer_qs)
         self.assertEqual(expensive_calculation.num_runs, 1)
diff --git a/tests/custom_columns/tests.py b/tests/custom_columns/tests.py
index 32a48b4840..c6b775a3ef 100644
--- a/tests/custom_columns/tests.py
+++ b/tests/custom_columns/tests.py
@@ -82,7 +82,7 @@ class CustomColumnsTests(TestCase):
 
     def test_author_querying(self):
         self.assertSequenceEqual(
-            Author.objects.all().order_by("last_name"),
+            Author.objects.order_by("last_name"),
             [self.a2, self.a1],
         )
 
@@ -119,7 +119,7 @@ class CustomColumnsTests(TestCase):
 
     def test_m2m_table(self):
         self.assertSequenceEqual(
-            self.article.authors.all().order_by("last_name"),
+            self.article.authors.order_by("last_name"),
             [self.a2, self.a1],
         )
         self.assertSequenceEqual(self.a1.article_set.all(), [self.article])
diff --git a/tests/defer/tests.py b/tests/defer/tests.py
index 244564bf69..d2cff258b4 100644
--- a/tests/defer/tests.py
+++ b/tests/defer/tests.py
@@ -48,7 +48,7 @@ class DeferTests(AssertionMixin, TestCase):
         # You can use 'pk' with reverse foreign key lookups.
         # The related_id is always set even if it's not fetched from the DB,
         # so pk and related_id are not deferred.
-        self.assert_delayed(self.s1.primary_set.all().only("pk")[0], 2)
+        self.assert_delayed(self.s1.primary_set.only("pk")[0], 2)
 
     def test_defer_only_chaining(self):
         qs = Primary.objects.all()
@@ -248,7 +248,7 @@ class TestDefer2(AssertionMixin, TestCase):
         """
         related = Secondary.objects.create(first="x1", second="x2")
         ChildProxy.objects.create(name="p1", value="xx", related=related)
-        children = ChildProxy.objects.all().select_related().only("id", "name")
+        children = ChildProxy.objects.select_related().only("id", "name")
         self.assertEqual(len(children), 1)
         child = children[0]
         self.assert_delayed(child, 2)
diff --git a/tests/defer_regress/tests.py b/tests/defer_regress/tests.py
index db2c360c6e..c7a61f53a3 100644
--- a/tests/defer_regress/tests.py
+++ b/tests/defer_regress/tests.py
@@ -226,7 +226,7 @@ class DeferRegressionTest(TestCase):
         item = Item.objects.create(name="first", value=47)
         RelatedItem.objects.create(item=item)
         # Defer fields with only()
-        obj = ProxyRelated.objects.all().select_related().only("item__name")[0]
+        obj = ProxyRelated.objects.select_related().only("item__name")[0]
         with self.assertNumQueries(0):
             self.assertEqual(obj.item.name, "first")
         with self.assertNumQueries(1):
diff --git a/tests/expressions_case/tests.py b/tests/expressions_case/tests.py
index 92923687e3..9bad0b8747 100644
--- a/tests/expressions_case/tests.py
+++ b/tests/expressions_case/tests.py
@@ -721,7 +721,7 @@ class CaseExpressionTests(TestCase):
             ),
         )
         self.assertQuerysetEqual(
-            CaseTestModel.objects.all().order_by("pk"),
+            CaseTestModel.objects.order_by("pk"),
             [
                 (1, "one"),
                 (2, "two"),
@@ -742,7 +742,7 @@ class CaseExpressionTests(TestCase):
             ),
         )
         self.assertQuerysetEqual(
-            CaseTestModel.objects.all().order_by("pk"),
+            CaseTestModel.objects.order_by("pk"),
             [(1, 1), (2, 2), (3, None), (2, 2), (3, None), (3, None), (4, None)],
             transform=attrgetter("integer", "integer2"),
         )
@@ -756,7 +756,7 @@ class CaseExpressionTests(TestCase):
             ),
         )
         self.assertQuerysetEqual(
-            CaseTestModel.objects.all().order_by("pk"),
+            CaseTestModel.objects.order_by("pk"),
             [("1", 2), ("2", 5), ("3", 3), ("2", 5), ("3", 3), ("3", 3), ("4", 4)],
             transform=attrgetter("string", "integer"),
         )
@@ -769,7 +769,7 @@ class CaseExpressionTests(TestCase):
             ),
         )
         self.assertQuerysetEqual(
-            CaseTestModel.objects.all().order_by("pk"),
+            CaseTestModel.objects.order_by("pk"),
             [
                 (1, "equal"),
                 (2, "+1"),
@@ -814,7 +814,7 @@ class CaseExpressionTests(TestCase):
             ),
         )
         self.assertQuerysetEqual(
-            CaseTestModel.objects.all().order_by("pk"),
+            CaseTestModel.objects.order_by("pk"),
             [(1, 1), (2, 2), (3, None), (2, 2), (3, None), (3, None), (4, None)],
             transform=attrgetter("integer", "big_integer"),
         )
@@ -828,7 +828,7 @@ class CaseExpressionTests(TestCase):
             ),
         )
         self.assertQuerysetEqual(
-            CaseTestModel.objects.all().order_by("pk"),
+            CaseTestModel.objects.order_by("pk"),
             [
                 (1, b"one"),
                 (2, b"two"),
@@ -850,7 +850,7 @@ class CaseExpressionTests(TestCase):
             ),
         )
         self.assertQuerysetEqual(
-            CaseTestModel.objects.all().order_by("pk"),
+            CaseTestModel.objects.order_by("pk"),
             [
                 (1, True),
                 (2, True),
@@ -871,7 +871,7 @@ class CaseExpressionTests(TestCase):
             ),
         )
         self.assertQuerysetEqual(
-            CaseTestModel.objects.all().order_by("pk"),
+            CaseTestModel.objects.order_by("pk"),
             [
                 (1, date(2015, 1, 1)),
                 (2, date(2015, 1, 2)),
@@ -892,7 +892,7 @@ class CaseExpressionTests(TestCase):
             ),
         )
         self.assertQuerysetEqual(
-            CaseTestModel.objects.all().order_by("pk"),
+            CaseTestModel.objects.order_by("pk"),
             [
                 (1, datetime(2015, 1, 1)),
                 (2, datetime(2015, 1, 2)),
@@ -915,7 +915,7 @@ class CaseExpressionTests(TestCase):
             ),
         )
         self.assertQuerysetEqual(
-            CaseTestModel.objects.all().order_by("pk"),
+            CaseTestModel.objects.order_by("pk"),
             [
                 (1, Decimal("1.1")),
                 (2, Decimal("2.2")),
@@ -936,7 +936,7 @@ class CaseExpressionTests(TestCase):
             ),
         )
         self.assertQuerysetEqual(
-            CaseTestModel.objects.all().order_by("pk"),
+            CaseTestModel.objects.order_by("pk"),
             [
                 (1, timedelta(1)),
                 (2, timedelta(2)),
@@ -958,7 +958,7 @@ class CaseExpressionTests(TestCase):
             ),
         )
         self.assertQuerysetEqual(
-            CaseTestModel.objects.all().order_by("pk"),
+            CaseTestModel.objects.order_by("pk"),
             [
                 (1, "1@example.com"),
                 (2, "2@example.com"),
@@ -979,7 +979,7 @@ class CaseExpressionTests(TestCase):
             ),
         )
         self.assertQuerysetEqual(
-            CaseTestModel.objects.all().order_by("pk"),
+            CaseTestModel.objects.order_by("pk"),
             [(1, "~/1"), (2, "~/2"), (3, ""), (2, "~/2"), (3, ""), (3, ""), (4, "")],
             transform=lambda o: (o.integer, str(o.file)),
         )
@@ -993,7 +993,7 @@ class CaseExpressionTests(TestCase):
             ),
         )
         self.assertQuerysetEqual(
-            CaseTestModel.objects.all().order_by("pk"),
+            CaseTestModel.objects.order_by("pk"),
             [(1, "~/1"), (2, "~/2"), (3, ""), (2, "~/2"), (3, ""), (3, ""), (4, "")],
             transform=attrgetter("integer", "file_path"),
         )
@@ -1006,7 +1006,7 @@ class CaseExpressionTests(TestCase):
             ),
         )
         self.assertQuerysetEqual(
-            CaseTestModel.objects.all().order_by("pk"),
+            CaseTestModel.objects.order_by("pk"),
             [(1, 1.1), (2, 2.2), (3, None), (2, 2.2), (3, None), (3, None), (4, None)],
             transform=attrgetter("integer", "float"),
         )
@@ -1020,7 +1020,7 @@ class CaseExpressionTests(TestCase):
             ),
         )
         self.assertQuerysetEqual(
-            CaseTestModel.objects.all().order_by("pk"),
+            CaseTestModel.objects.order_by("pk"),
             [(1, "~/1"), (2, "~/2"), (3, ""), (2, "~/2"), (3, ""), (3, ""), (4, "")],
             transform=lambda o: (o.integer, str(o.image)),
         )
@@ -1034,7 +1034,7 @@ class CaseExpressionTests(TestCase):
             ),
         )
         self.assertQuerysetEqual(
-            CaseTestModel.objects.all().order_by("pk"),
+            CaseTestModel.objects.order_by("pk"),
             [
                 (1, "1.1.1.1"),
                 (2, "2.2.2.2"),
@@ -1055,7 +1055,7 @@ class CaseExpressionTests(TestCase):
             ),
         )
         self.assertQuerysetEqual(
-            CaseTestModel.objects.all().order_by("pk"),
+            CaseTestModel.objects.order_by("pk"),
             [
                 (1, True),
                 (2, False),
@@ -1076,7 +1076,7 @@ class CaseExpressionTests(TestCase):
             ),
         )
         self.assertQuerysetEqual(
-            CaseTestModel.objects.all().order_by("pk"),
+            CaseTestModel.objects.order_by("pk"),
             [(1, 1), (2, 2), (3, None), (2, 2), (3, None), (3, None), (4, None)],
             transform=attrgetter("integer", "positive_big_integer"),
         )
@@ -1089,7 +1089,7 @@ class CaseExpressionTests(TestCase):
             ),
         )
         self.assertQuerysetEqual(
-            CaseTestModel.objects.all().order_by("pk"),
+            CaseTestModel.objects.order_by("pk"),
             [(1, 1), (2, 2), (3, None), (2, 2), (3, None), (3, None), (4, None)],
             transform=attrgetter("integer", "positive_integer"),
         )
@@ -1102,7 +1102,7 @@ class CaseExpressionTests(TestCase):
             ),
         )
         self.assertQuerysetEqual(
-            CaseTestModel.objects.all().order_by("pk"),
+            CaseTestModel.objects.order_by("pk"),
             [(1, 1), (2, 2), (3, None), (2, 2), (3, None), (3, None), (4, None)],
             transform=attrgetter("integer", "positive_small_integer"),
         )
@@ -1116,7 +1116,7 @@ class CaseExpressionTests(TestCase):
             ),
         )
         self.assertQuerysetEqual(
-            CaseTestModel.objects.all().order_by("pk"),
+            CaseTestModel.objects.order_by("pk"),
             [(1, "1"), (2, "2"), (3, ""), (2, "2"), (3, ""), (3, ""), (4, "")],
             transform=attrgetter("integer", "slug"),
         )
@@ -1129,7 +1129,7 @@ class CaseExpressionTests(TestCase):
             ),
         )
         self.assertQuerysetEqual(
-            CaseTestModel.objects.all().order_by("pk"),
+            CaseTestModel.objects.order_by("pk"),
             [(1, 1), (2, 2), (3, None), (2, 2), (3, None), (3, None), (4, None)],
             transform=attrgetter("integer", "small_integer"),
         )
@@ -1156,7 +1156,7 @@ class CaseExpressionTests(TestCase):
             ),
         )
         self.assertQuerysetEqual(
-            CaseTestModel.objects.all().order_by("pk"),
+            CaseTestModel.objects.order_by("pk"),
             [(1, "1"), (2, "2"), (3, ""), (2, "2"), (3, ""), (3, ""), (4, "")],
             transform=attrgetter("integer", "text"),
         )
@@ -1169,7 +1169,7 @@ class CaseExpressionTests(TestCase):
             ),
         )
         self.assertQuerysetEqual(
-            CaseTestModel.objects.all().order_by("pk"),
+            CaseTestModel.objects.order_by("pk"),
             [
                 (1, time(1)),
                 (2, time(2)),
@@ -1191,7 +1191,7 @@ class CaseExpressionTests(TestCase):
             ),
         )
         self.assertQuerysetEqual(
-            CaseTestModel.objects.all().order_by("pk"),
+            CaseTestModel.objects.order_by("pk"),
             [
                 (1, "http://1.example.com/"),
                 (2, "http://2.example.com/"),
@@ -1212,7 +1212,7 @@ class CaseExpressionTests(TestCase):
             ),
         )
         self.assertQuerysetEqual(
-            CaseTestModel.objects.all().order_by("pk"),
+            CaseTestModel.objects.order_by("pk"),
             [
                 (1, UUID("11111111111111111111111111111111")),
                 (2, UUID("22222222222222222222222222222222")),
@@ -1235,7 +1235,7 @@ class CaseExpressionTests(TestCase):
             ),
         )
         self.assertQuerysetEqual(
-            CaseTestModel.objects.all().order_by("pk"),
+            CaseTestModel.objects.order_by("pk"),
             [
                 (1, obj1.pk),
                 (2, obj2.pk),
@@ -1550,7 +1550,7 @@ class CaseDocumentationExamples(TestCase):
             ),
         )
         self.assertQuerysetEqual(
-            Client.objects.all().order_by("pk"),
+            Client.objects.order_by("pk"),
             [("Jane Doe", "G"), ("James Smith", "R"), ("Jack Black", "P")],
             transform=attrgetter("name", "account_type"),
         )
diff --git a/tests/extra_regress/tests.py b/tests/extra_regress/tests.py
index da403df98c..0287eeb193 100644
--- a/tests/extra_regress/tests.py
+++ b/tests/extra_regress/tests.py
@@ -128,7 +128,7 @@ class ExtraRegressTests(TestCase):
         Regression test for #8063: limiting a query shouldn't discard any
         extra() bits.
         """
-        qs = User.objects.all().extra(where=["id=%s"], params=[self.u.id])
+        qs = User.objects.extra(where=["id=%s"], params=[self.u.id])
         self.assertSequenceEqual(qs, [self.u])
         self.assertSequenceEqual(qs[:1], [self.u])
 
diff --git a/tests/foreign_object/tests.py b/tests/foreign_object/tests.py
index f63abf82bd..fc41c043f5 100644
--- a/tests/foreign_object/tests.py
+++ b/tests/foreign_object/tests.py
@@ -238,7 +238,7 @@ class MultiColumnFKTests(TestCase):
                 for m in Membership.objects.select_related("person").order_by("pk")
             ]
 
-        normal_people = [m.person for m in Membership.objects.all().order_by("pk")]
+        normal_people = [m.person for m in Membership.objects.order_by("pk")]
         self.assertEqual(people, normal_people)
 
     def test_prefetch_foreignkey_forward_works(self):
diff --git a/tests/get_earliest_or_latest/tests.py b/tests/get_earliest_or_latest/tests.py
index 59ee21aef7..cd63adb75d 100644
--- a/tests/get_earliest_or_latest/tests.py
+++ b/tests/get_earliest_or_latest/tests.py
@@ -232,9 +232,9 @@ class TestFirstLast(TestCase):
             with self.assertRaises(IndexError):
                 IndexErrorArticle.objects.all()[:10:2]
             with self.assertRaises(IndexError):
-                IndexErrorArticle.objects.all().first()
+                IndexErrorArticle.objects.first()
             with self.assertRaises(IndexError):
-                IndexErrorArticle.objects.all().last()
+                IndexErrorArticle.objects.last()
 
         check()
 
diff --git a/tests/gis_tests/geoapp/test_functions.py b/tests/gis_tests/geoapp/test_functions.py
index b632d2cf61..e1a66d573e 100644
--- a/tests/gis_tests/geoapp/test_functions.py
+++ b/tests/gis_tests/geoapp/test_functions.py
@@ -690,7 +690,7 @@ class GISFunctionsTests(FuncTestMixin, TestCase):
     )
     def test_diff_intersection_union(self):
         geom = Point(5, 23, srid=4326)
-        qs = Country.objects.all().annotate(
+        qs = Country.objects.annotate(
             difference=functions.Difference("mpoly", geom),
             sym_difference=functions.SymDifference("mpoly", geom),
             union=functions.Union("mpoly", geom),
diff --git a/tests/gis_tests/geoapp/test_serializers.py b/tests/gis_tests/geoapp/test_serializers.py
index a67a4f16db..44066daee9 100644
--- a/tests/gis_tests/geoapp/test_serializers.py
+++ b/tests/gis_tests/geoapp/test_serializers.py
@@ -21,12 +21,12 @@ class GeoJSONSerializerTests(TestCase):
         self.assertIn("geojson", public_formats)
 
     def test_serialization_base(self):
-        geojson = serializers.serialize("geojson", City.objects.all().order_by("name"))
+        geojson = serializers.serialize("geojson", City.objects.order_by("name"))
         geodata = json.loads(geojson)
         self.assertEqual(len(geodata["features"]), len(City.objects.all()))
         self.assertEqual(geodata["features"][0]["geometry"]["type"], "Point")
         self.assertEqual(geodata["features"][0]["properties"]["name"], "Chicago")
-        first_city = City.objects.all().order_by("name").first()
+        first_city = City.objects.order_by("name").first()
         self.assertEqual(geodata["features"][0]["properties"]["pk"], str(first_city.pk))
 
     def test_geometry_field_option(self):
@@ -81,7 +81,7 @@ class GeoJSONSerializerTests(TestCase):
 
     def test_srid_option(self):
         geojson = serializers.serialize(
-            "geojson", City.objects.all().order_by("name"), srid=2847
+            "geojson", City.objects.order_by("name"), srid=2847
         )
         geodata = json.loads(geojson)
         coordinates = geodata["features"][0]["geometry"]["coordinates"]
diff --git a/tests/gis_tests/geoapp/tests.py b/tests/gis_tests/geoapp/tests.py
index 6acf6e150b..0a71639c84 100644
--- a/tests/gis_tests/geoapp/tests.py
+++ b/tests/gis_tests/geoapp/tests.py
@@ -217,7 +217,7 @@ class GeoModelTest(TestCase):
         Test a dumpdata/loaddata cycle with geographic data.
         """
         out = StringIO()
-        original_data = list(City.objects.all().order_by("name"))
+        original_data = list(City.objects.order_by("name"))
         call_command("dumpdata", "geoapp.City", stdout=out)
         result = out.getvalue()
         houston = City.objects.get(name="Houston")
@@ -228,7 +228,7 @@ class GeoModelTest(TestCase):
             tmp.write(result)
             tmp.seek(0)
             call_command("loaddata", tmp.name, verbosity=0)
-        self.assertEqual(original_data, list(City.objects.all().order_by("name")))
+        self.assertEqual(original_data, list(City.objects.order_by("name")))
 
     @skipUnlessDBFeature("supports_empty_geometries")
     def test_empty_geometries(self):
@@ -623,7 +623,7 @@ class GeoQuerySetTest(TestCase):
         """
         Testing if extent supports limit.
         """
-        extent1 = City.objects.all().aggregate(Extent("point"))["point__extent"]
+        extent1 = City.objects.aggregate(Extent("point"))["point__extent"]
         extent2 = City.objects.all()[:3].aggregate(Extent("point"))["point__extent"]
         self.assertNotEqual(extent1, extent2)
 
@@ -633,7 +633,7 @@ class GeoQuerySetTest(TestCase):
         """
         if not connection.features.supports_make_line_aggr:
             with self.assertRaises(NotSupportedError):
-                City.objects.all().aggregate(MakeLine("point"))
+                City.objects.aggregate(MakeLine("point"))
             return
 
         # MakeLine on an inappropriate field returns simply None
diff --git a/tests/gis_tests/relatedapp/tests.py b/tests/gis_tests/relatedapp/tests.py
index d93fe3b76b..52abf7ba4b 100644
--- a/tests/gis_tests/relatedapp/tests.py
+++ b/tests/gis_tests/relatedapp/tests.py
@@ -108,7 +108,7 @@ class RelatedGeoModelTest(TestCase):
         select_related on a query over a model with an FK to a model subclass.
         """
         # Regression test for #9752.
-        list(DirectoryEntry.objects.all().select_related())
+        list(DirectoryEntry.objects.select_related())
 
     def test06_f_expressions(self):
         "Testing F() expressions on GeometryFields."
diff --git a/tests/model_fields/test_booleanfield.py b/tests/model_fields/test_booleanfield.py
index 91357b9b20..7e92d99fab 100644
--- a/tests/model_fields/test_booleanfield.py
+++ b/tests/model_fields/test_booleanfield.py
@@ -73,7 +73,7 @@ class BooleanFieldTests(TestCase):
 
         # When an extra clause exists, the boolean conversions are applied with
         # an offset (#13293).
-        b5 = BooleanModel.objects.all().extra(select={"string_col": "string"})[0]
+        b5 = BooleanModel.objects.extra(select={"string_col": "string"})[0]
         self.assertNotIsInstance(b5.pk, bool)
 
     def test_select_related(self):
diff --git a/tests/model_forms/tests.py b/tests/model_forms/tests.py
index 592bc693af..13b871372e 100644
--- a/tests/model_forms/tests.py
+++ b/tests/model_forms/tests.py
@@ -1617,7 +1617,7 @@ class ModelFormBasicTests(TestCase):
         # Set up a callable initial value
         def formfield_for_dbfield(db_field, **kwargs):
             if db_field.name == "categories":
-                kwargs["initial"] = lambda: Category.objects.all().order_by("name")[:2]
+                kwargs["initial"] = lambda: Category.objects.order_by("name")[:2]
             return db_field.formfield(**kwargs)
 
         # Create a ModelForm, instantiate it, and check that the output is as expected
diff --git a/tests/model_formsets_regress/tests.py b/tests/model_formsets_regress/tests.py
index 7767ec48a2..e2ba34d6bf 100644
--- a/tests/model_formsets_regress/tests.py
+++ b/tests/model_formsets_regress/tests.py
@@ -55,7 +55,7 @@ class InlineFormsetTests(TestCase):
         form_set = FormSet(data, instance=user)
         if form_set.is_valid():
             form_set.save()
-            usersite = UserSite.objects.all().values()
+            usersite = UserSite.objects.values()
             self.assertEqual(usersite[0]["data"], 10)
             self.assertEqual(usersite[0]["user_id"], "apollo13")
         else:
@@ -73,7 +73,7 @@ class InlineFormsetTests(TestCase):
         form_set = FormSet(data, instance=user)
         if form_set.is_valid():
             form_set.save()
-            usersite = UserSite.objects.all().values()
+            usersite = UserSite.objects.values()
             self.assertEqual(usersite[0]["data"], 11)
             self.assertEqual(usersite[0]["user_id"], "apollo13")
         else:
@@ -93,7 +93,7 @@ class InlineFormsetTests(TestCase):
         form_set = FormSet(data, instance=user)
         if form_set.is_valid():
             form_set.save()
-            usersite = UserSite.objects.all().values().order_by("data")
+            usersite = UserSite.objects.values().order_by("data")
             self.assertEqual(usersite[0]["data"], 11)
             self.assertEqual(usersite[0]["user_id"], "apollo13")
             self.assertEqual(usersite[1]["data"], 42)
@@ -131,7 +131,7 @@ class InlineFormsetTests(TestCase):
         form_set = FormSet(data, instance=restaurant)
         if form_set.is_valid():
             form_set.save()
-            manager = Manager.objects.all().values()
+            manager = Manager.objects.values()
             self.assertEqual(manager[0]["name"], "Guido Van Rossum")
         else:
             self.fail("Errors found on formset:%s" % form_set.errors)
@@ -147,7 +147,7 @@ class InlineFormsetTests(TestCase):
         form_set = FormSet(data, instance=restaurant)
         if form_set.is_valid():
             form_set.save()
-            manager = Manager.objects.all().values()
+            manager = Manager.objects.values()
             self.assertEqual(manager[0]["name"], "Terry Gilliam")
         else:
             self.fail("Errors found on formset:%s" % form_set.errors)
@@ -164,7 +164,7 @@ class InlineFormsetTests(TestCase):
         form_set = FormSet(data, instance=restaurant)
         if form_set.is_valid():
             form_set.save()
-            manager = Manager.objects.all().values().order_by("name")
+            manager = Manager.objects.values().order_by("name")
             self.assertEqual(manager[0]["name"], "John Cleese")
             self.assertEqual(manager[1]["name"], "Terry Gilliam")
         else:
diff --git a/tests/model_inheritance_regress/tests.py b/tests/model_inheritance_regress/tests.py
index d1d007f277..e9288db345 100644
--- a/tests/model_inheritance_regress/tests.py
+++ b/tests/model_inheritance_regress/tests.py
@@ -260,7 +260,7 @@ class ModelInheritanceTest(TestCase):
         """
         Regression test for #11764
         """
-        wholesalers = list(Wholesaler.objects.all().select_related())
+        wholesalers = list(Wholesaler.objects.select_related())
         self.assertEqual(wholesalers, [])
 
     def test_issue_7853(self):
@@ -525,7 +525,7 @@ class ModelInheritanceTest(TestCase):
             serves_pizza=True,
             serves_hot_dogs=True,
         )
-        p = Place.objects.all().select_related("restaurant")[0]
+        p = Place.objects.select_related("restaurant")[0]
         self.assertIsInstance(p.restaurant.serves_pizza, bool)
 
     def test_inheritance_select_related(self):
diff --git a/tests/multiple_database/tests.py b/tests/multiple_database/tests.py
index 2dc894b858..7a9ff4da4e 100644
--- a/tests/multiple_database/tests.py
+++ b/tests/multiple_database/tests.py
@@ -219,11 +219,11 @@ class QueryTestCase(TestCase):
         # Retrieve related object by descriptor. Related objects should be
         # database-bound.
         self.assertEqual(
-            list(dive.authors.all().values_list("name", flat=True)), ["Mark Pilgrim"]
+            list(dive.authors.values_list("name", flat=True)), ["Mark Pilgrim"]
         )
 
         self.assertEqual(
-            list(mark.book_set.all().values_list("title", flat=True)),
+            list(mark.book_set.values_list("title", flat=True)),
             ["Dive into Python"],
         )
 
@@ -985,7 +985,7 @@ class QueryTestCase(TestCase):
         # Retrieve related object by descriptor. Related objects should be
         # database-bound.
         self.assertEqual(
-            list(dive.reviews.all().values_list("source", flat=True)), ["Python Weekly"]
+            list(dive.reviews.values_list("source", flat=True)), ["Python Weekly"]
         )
 
     def test_generic_key_reverse_operations(self):
@@ -2415,7 +2415,7 @@ class RouteForWriteTestCase(TestCase):
         book.authors.add(auth)
         with self.assertRaises(RouterUsed) as cm:
             with self.override_router():
-                book.authors.all().update(name="Different")
+                book.authors.update(name="Different")
         e = cm.exception
         self.assertEqual(e.mode, RouterUsed.WRITE)
         self.assertEqual(e.model, Person)
@@ -2497,7 +2497,7 @@ class RouteForWriteTestCase(TestCase):
         book.authors.add(auth)
         with self.assertRaises(RouterUsed) as cm:
             with self.override_router():
-                auth.book_set.all().update(title="Different")
+                auth.book_set.update(title="Different")
         e = cm.exception
         self.assertEqual(e.mode, RouterUsed.WRITE)
         self.assertEqual(e.model, Book)
diff --git a/tests/one_to_one/tests.py b/tests/one_to_one/tests.py
index 40dcd45a77..3c92445af6 100644
--- a/tests/one_to_one/tests.py
+++ b/tests/one_to_one/tests.py
@@ -185,8 +185,8 @@ class OneToOneTests(TestCase):
         bar.save()
         self.p1.delete()
 
-        self.assertEqual(Place.objects.all().count(), 1)
-        self.assertEqual(UndergroundBar.objects.all().count(), 1)
+        self.assertEqual(Place.objects.count(), 1)
+        self.assertEqual(UndergroundBar.objects.count(), 1)
 
     def test_create_models_m2m(self):
         """
diff --git a/tests/ordering/tests.py b/tests/ordering/tests.py
index 83f3cc7993..37106aa5dd 100644
--- a/tests/ordering/tests.py
+++ b/tests/ordering/tests.py
@@ -236,7 +236,7 @@ class OrderingTests(TestCase):
         and then take the first two).
         """
         self.assertQuerysetEqual(
-            Article.objects.all().reverse()[:2],
+            Article.objects.reverse()[:2],
             [
                 "Article 1",
                 "Article 3",
diff --git a/tests/postgres_tests/test_array.py b/tests/postgres_tests/test_array.py
index 28d5924b9d..7243ab6a5a 100644
--- a/tests/postgres_tests/test_array.py
+++ b/tests/postgres_tests/test_array.py
@@ -278,9 +278,7 @@ class TestQuerying(PostgreSQLTestCase):
         IntegerArrayModel.objects.create(field=[2, 3])
         self.assertSequenceEqual(
             NullableIntegerArrayModel.objects.filter(
-                field__in=IntegerArrayModel.objects.all().values_list(
-                    "field", flat=True
-                )
+                field__in=IntegerArrayModel.objects.values_list("field", flat=True)
             ),
             self.objs[2:3],
         )
diff --git a/tests/prefetch_related/tests.py b/tests/prefetch_related/tests.py
index 584e6d5475..f485f26a80 100644
--- a/tests/prefetch_related/tests.py
+++ b/tests/prefetch_related/tests.py
@@ -269,7 +269,7 @@ class PrefetchRelatedTests(TestDataMixin, TestCase):
             list(qs.all())
 
     def test_attribute_error(self):
-        qs = Reader.objects.all().prefetch_related("books_read__xyz")
+        qs = Reader.objects.prefetch_related("books_read__xyz")
         msg = (
             "Cannot find 'xyz' on Book object, 'books_read__xyz' "
             "is an invalid parameter to prefetch_related()"
@@ -872,43 +872,33 @@ class CustomPrefetchTests(TestCase):
         # Test ForwardManyToOneDescriptor.
         houses = House.objects.select_related("owner")
         with self.assertNumQueries(6):
-            rooms = Room.objects.all().prefetch_related("house")
+            rooms = Room.objects.prefetch_related("house")
             lst1 = self.traverse_qs(rooms, [["house", "owner"]])
         with self.assertNumQueries(2):
-            rooms = Room.objects.all().prefetch_related(
-                Prefetch("house", queryset=houses.all())
-            )
+            rooms = Room.objects.prefetch_related(Prefetch("house", queryset=houses))
             lst2 = self.traverse_qs(rooms, [["house", "owner"]])
         self.assertEqual(lst1, lst2)
         with self.assertNumQueries(2):
             houses = House.objects.select_related("owner")
-            rooms = Room.objects.all().prefetch_related(
-                Prefetch("house", queryset=houses.all(), to_attr="house_attr")
+            rooms = Room.objects.prefetch_related(
+                Prefetch("house", queryset=houses, to_attr="house_attr")
             )
             lst2 = self.traverse_qs(rooms, [["house_attr", "owner"]])
         self.assertEqual(lst1, lst2)
-        room = (
-            Room.objects.all()
-            .prefetch_related(
-                Prefetch("house", queryset=houses.filter(address="DoesNotExist"))
-            )
-            .first()
-        )
+        room = Room.objects.prefetch_related(
+            Prefetch("house", queryset=houses.filter(address="DoesNotExist"))
+        ).first()
         with self.assertRaises(ObjectDoesNotExist):
             getattr(room, "house")
-        room = (
-            Room.objects.all()
-            .prefetch_related(
-                Prefetch(
-                    "house",
-                    queryset=houses.filter(address="DoesNotExist"),
-                    to_attr="house_attr",
-                )
+        room = Room.objects.prefetch_related(
+            Prefetch(
+                "house",
+                queryset=houses.filter(address="DoesNotExist"),
+                to_attr="house_attr",
             )
-            .first()
-        )
+        ).first()
         self.assertIsNone(room.house_attr)
-        rooms = Room.objects.all().prefetch_related(
+        rooms = Room.objects.prefetch_related(
             Prefetch("house", queryset=House.objects.only("name"))
         )
         with self.assertNumQueries(2):
@@ -919,20 +909,20 @@ class CustomPrefetchTests(TestCase):
         # Test ReverseOneToOneDescriptor.
         houses = House.objects.select_related("owner")
         with self.assertNumQueries(6):
-            rooms = Room.objects.all().prefetch_related("main_room_of")
+            rooms = Room.objects.prefetch_related("main_room_of")
             lst1 = self.traverse_qs(rooms, [["main_room_of", "owner"]])
         with self.assertNumQueries(2):
-            rooms = Room.objects.all().prefetch_related(
-                Prefetch("main_room_of", queryset=houses.all())
+            rooms = Room.objects.prefetch_related(
+                Prefetch("main_room_of", queryset=houses)
             )
             lst2 = self.traverse_qs(rooms, [["main_room_of", "owner"]])
         self.assertEqual(lst1, lst2)
         with self.assertNumQueries(2):
             rooms = list(
-                Room.objects.all().prefetch_related(
+                Room.objects.prefetch_related(
                     Prefetch(
                         "main_room_of",
-                        queryset=houses.all(),
+                        queryset=houses,
                         to_attr="main_room_of_attr",
                     )
                 )
@@ -1346,7 +1336,7 @@ class ForeignKeyToFieldTest(TestCase):
 
     def test_m2m(self):
         with self.assertNumQueries(3):
-            qs = Author.objects.all().prefetch_related("favorite_authors", "favors_me")
+            qs = Author.objects.prefetch_related("favorite_authors", "favors_me")
             favorites = [
                 (
                     [str(i_like) for i_like in author.favorite_authors.all()],
diff --git a/tests/proxy_model_inheritance/tests.py b/tests/proxy_model_inheritance/tests.py
index 06756f7869..5e2d1f2d8e 100644
--- a/tests/proxy_model_inheritance/tests.py
+++ b/tests/proxy_model_inheritance/tests.py
@@ -28,8 +28,8 @@ class ProxyModelInheritanceTests(TransactionTestCase):
                 from app1.models import ProxyModel
                 from app2.models import NiceModel
 
-                self.assertEqual(NiceModel.objects.all().count(), 0)
-                self.assertEqual(ProxyModel.objects.all().count(), 0)
+                self.assertEqual(NiceModel.objects.count(), 0)
+                self.assertEqual(ProxyModel.objects.count(), 0)
 
 
 class MultiTableInheritanceProxyTest(TestCase):
diff --git a/tests/queries/test_explain.py b/tests/queries/test_explain.py
index 2acd6a685c..ab845f992a 100644
--- a/tests/queries/test_explain.py
+++ b/tests/queries/test_explain.py
@@ -20,7 +20,7 @@ class ExplainTests(TestCase):
             Tag.objects.filter(name="test").annotate(Count("children")),
             Tag.objects.filter(name="test").values_list("name"),
             Tag.objects.order_by().union(Tag.objects.order_by().filter(name="test")),
-            Tag.objects.all().select_for_update().filter(name="test"),
+            Tag.objects.select_for_update().filter(name="test"),
         ]
         supported_formats = connection.features.supported_explain_formats
         all_formats = (
@@ -60,7 +60,7 @@ class ExplainTests(TestCase):
     @skipUnlessDBFeature("validates_explain_options")
     def test_unknown_options(self):
         with self.assertRaisesMessage(ValueError, "Unknown options: test, test2"):
-            Tag.objects.all().explain(test=1, test2=1)
+            Tag.objects.explain(test=1, test2=1)
 
     def test_unknown_format(self):
         msg = "DOES NOT EXIST is not a recognized format."
@@ -69,7 +69,7 @@ class ExplainTests(TestCase):
                 sorted(connection.features.supported_explain_formats)
             )
         with self.assertRaisesMessage(ValueError, msg):
-            Tag.objects.all().explain(format="does not exist")
+            Tag.objects.explain(format="does not exist")
 
     @unittest.skipUnless(connection.vendor == "postgresql", "PostgreSQL specific")
     def test_postgres_options(self):
diff --git a/tests/queries/test_qs_combinators.py b/tests/queries/test_qs_combinators.py
index 000185bbe6..5aa5f6c8d1 100644
--- a/tests/queries/test_qs_combinators.py
+++ b/tests/queries/test_qs_combinators.py
@@ -110,7 +110,7 @@ class QuerySetSetOperationTests(TestCase):
         self.assertEqual(len(qs3.union(qs3)), 0)
 
     def test_empty_qs_union_with_ordered_qs(self):
-        qs1 = Number.objects.all().order_by("num")
+        qs1 = Number.objects.order_by("num")
         qs2 = Number.objects.none().union(qs1).order_by("num")
         self.assertEqual(list(qs1), list(qs2))
 
diff --git a/tests/queries/tests.py b/tests/queries/tests.py
index 5fc3fe0096..594afe25b6 100644
--- a/tests/queries/tests.py
+++ b/tests/queries/tests.py
@@ -1787,7 +1787,7 @@ class Queries5Tests(TestCase):
             [self.rank3, self.rank2, self.rank1],
         )
         self.assertSequenceEqual(
-            Ranking.objects.all().order_by("rank"),
+            Ranking.objects.order_by("rank"),
             [self.rank1, self.rank2, self.rank3],
         )
 
@@ -1944,9 +1944,9 @@ class NullableRelOrderingTests(TestCase):
         s = SingleObject.objects.create(name="s")
         r = RelatedObject.objects.create(single=s, f=1)
         p2 = Plaything.objects.create(name="p2", others=r)
-        qs = Plaything.objects.all().filter(others__isnull=False).order_by("pk")
+        qs = Plaything.objects.filter(others__isnull=False).order_by("pk")
         self.assertNotIn("JOIN", str(qs.query))
-        qs = Plaything.objects.all().filter(others__f__isnull=False).order_by("pk")
+        qs = Plaything.objects.filter(others__f__isnull=False).order_by("pk")
         self.assertIn("INNER", str(qs.query))
         qs = qs.order_by("others__single__name")
         # The ordering by others__single__pk will add one new join (to single)
@@ -2219,16 +2219,16 @@ class QuerysetOrderedTests(unittest.TestCase):
 
     def test_cleared_default_ordering(self):
         self.assertIs(Tag.objects.all().ordered, True)
-        self.assertIs(Tag.objects.all().order_by().ordered, False)
+        self.assertIs(Tag.objects.order_by().ordered, False)
 
     def test_explicit_ordering(self):
-        self.assertIs(Annotation.objects.all().order_by("id").ordered, True)
+        self.assertIs(Annotation.objects.order_by("id").ordered, True)
 
     def test_empty_queryset(self):
         self.assertIs(Annotation.objects.none().ordered, True)
 
     def test_order_by_extra(self):
-        self.assertIs(Annotation.objects.all().extra(order_by=["id"]).ordered, True)
+        self.assertIs(Annotation.objects.extra(order_by=["id"]).ordered, True)
 
     def test_annotated_ordering(self):
         qs = Annotation.objects.annotate(num_notes=Count("notes"))
@@ -2685,7 +2685,7 @@ class QuerySetSupportsPythonIdioms(TestCase):
         ]
 
     def get_ordered_articles(self):
-        return Article.objects.all().order_by("name")
+        return Article.objects.order_by("name")
 
     def test_can_get_items_using_index_and_slice_notation(self):
         self.assertEqual(self.get_ordered_articles()[0].name, "Article 1")
@@ -2839,7 +2839,7 @@ class EscapingTests(TestCase):
         r_a = ReservedName.objects.create(name="a", order=42)
         r_b = ReservedName.objects.create(name="b", order=37)
         self.assertSequenceEqual(
-            ReservedName.objects.all().order_by("order"),
+            ReservedName.objects.order_by("order"),
             [r_b, r_a],
         )
         self.assertSequenceEqual(
@@ -2983,7 +2983,7 @@ class ConditionalTests(TestCase):
         # ... but you can still order in a non-recursive fashion among linked
         # fields (the previous test failed because the default ordering was
         # recursive).
-        self.assertQuerysetEqual(LoopX.objects.all().order_by("y__x__y__x__id"), [])
+        self.assertQuerysetEqual(LoopX.objects.order_by("y__x__y__x__id"), [])
 
     # When grouping without specifying ordering, we add an explicit "ORDER BY NULL"
     # portion in MySQL to prevent unnecessary sorting.
@@ -4175,7 +4175,7 @@ class RelatedLookupTypeTests(TestCase):
         pob.save()
         self.assertSequenceEqual(
             ObjectB.objects.filter(
-                objecta__in=ObjectB.objects.all().values_list("num")
+                objecta__in=ObjectB.objects.values_list("num")
             ).order_by("pk"),
             [ob, pob],
         )
diff --git a/tests/select_for_update/tests.py b/tests/select_for_update/tests.py
index 58b4b04263..1612a66064 100644
--- a/tests/select_for_update/tests.py
+++ b/tests/select_for_update/tests.py
@@ -90,7 +90,7 @@ class SelectForUpdateTests(TransactionTestCase):
         generated SQL when select_for_update is invoked.
         """
         with transaction.atomic(), CaptureQueriesContext(connection) as ctx:
-            list(Person.objects.all().select_for_update())
+            list(Person.objects.select_for_update())
         self.assertTrue(self.has_for_update_sql(ctx.captured_queries))
 
     @skipUnlessDBFeature("has_select_for_update_nowait")
@@ -100,7 +100,7 @@ class SelectForUpdateTests(TransactionTestCase):
         generated SQL when select_for_update is invoked.
         """
         with transaction.atomic(), CaptureQueriesContext(connection) as ctx:
-            list(Person.objects.all().select_for_update(nowait=True))
+            list(Person.objects.select_for_update(nowait=True))
         self.assertTrue(self.has_for_update_sql(ctx.captured_queries, nowait=True))
 
     @skipUnlessDBFeature("has_select_for_update_skip_locked")
@@ -110,7 +110,7 @@ class SelectForUpdateTests(TransactionTestCase):
         generated SQL when select_for_update is invoked.
         """
         with transaction.atomic(), CaptureQueriesContext(connection) as ctx:
-            list(Person.objects.all().select_for_update(skip_locked=True))
+            list(Person.objects.select_for_update(skip_locked=True))
         self.assertTrue(self.has_for_update_sql(ctx.captured_queries, skip_locked=True))
 
     @skipUnlessDBFeature("has_select_for_no_key_update")
@@ -120,7 +120,7 @@ class SelectForUpdateTests(TransactionTestCase):
         select_for_update() is invoked.
         """
         with transaction.atomic(), CaptureQueriesContext(connection) as ctx:
-            list(Person.objects.all().select_for_update(no_key=True))
+            list(Person.objects.select_for_update(no_key=True))
         self.assertIs(self.has_for_update_sql(ctx.captured_queries, no_key=True), True)
 
     @skipUnlessDBFeature("has_select_for_update_of")
@@ -499,7 +499,7 @@ class SelectForUpdateTests(TransactionTestCase):
         """
         msg = "select_for_update cannot be used outside of a transaction."
         with self.assertRaisesMessage(transaction.TransactionManagementError, msg):
-            list(Person.objects.all().select_for_update())
+            list(Person.objects.select_for_update())
 
     @skipUnlessDBFeature("has_select_for_update")
     def test_for_update_requires_transaction_only_in_execution(self):
@@ -508,7 +508,7 @@ class SelectForUpdateTests(TransactionTestCase):
         when select_for_update is invoked outside of a transaction -
         only when the query is executed.
         """
-        people = Person.objects.all().select_for_update()
+        people = Person.objects.select_for_update()
         msg = "select_for_update cannot be used outside of a transaction."
         with self.assertRaisesMessage(transaction.TransactionManagementError, msg):
             list(people)
@@ -517,7 +517,7 @@ class SelectForUpdateTests(TransactionTestCase):
     def test_select_for_update_with_limit(self):
         other = Person.objects.create(name="Grappeli", born=self.city1, died=self.city2)
         with transaction.atomic():
-            qs = list(Person.objects.all().order_by("pk").select_for_update()[1:2])
+            qs = list(Person.objects.order_by("pk").select_for_update()[1:2])
             self.assertEqual(qs[0], other)
 
     @skipIfDBFeature("supports_select_for_update_with_limit")
@@ -528,7 +528,7 @@ class SelectForUpdateTests(TransactionTestCase):
         )
         with self.assertRaisesMessage(NotSupportedError, msg):
             with transaction.atomic():
-                list(Person.objects.all().order_by("pk").select_for_update()[1:2])
+                list(Person.objects.order_by("pk").select_for_update()[1:2])
 
     def run_select_for_update(self, status, **kwargs):
         """
diff --git a/tests/select_related/tests.py b/tests/select_related/tests.py
index 7d35edfcbd..68fe7a906f 100644
--- a/tests/select_related/tests.py
+++ b/tests/select_related/tests.py
@@ -94,7 +94,7 @@ class SelectRelatedTests(TestCase):
     def test_list_with_select_related(self):
         """select_related() applies to entire lists, not just items."""
         with self.assertNumQueries(1):
-            world = Species.objects.all().select_related()
+            world = Species.objects.select_related()
             families = [o.genus.family.name for o in world]
             self.assertEqual(
                 sorted(families),
@@ -113,7 +113,7 @@ class SelectRelatedTests(TestCase):
         well.
         """
         with self.assertNumQueries(5):
-            world = Species.objects.all().select_related("genus__family")
+            world = Species.objects.select_related("genus__family")
             orders = [o.genus.family.order.name for o in world]
             self.assertEqual(
                 sorted(orders), ["Agaricales", "Diptera", "Fabales", "Primates"]
diff --git a/tests/select_related_regress/tests.py b/tests/select_related_regress/tests.py
index 5ce331d332..94a15bde24 100644
--- a/tests/select_related_regress/tests.py
+++ b/tests/select_related_regress/tests.py
@@ -92,7 +92,7 @@ class SelectRelatedRegressTests(TestCase):
         c = Class.objects.create(org=o)
         Enrollment.objects.create(std=s, cls=c)
 
-        e_related = Enrollment.objects.all().select_related()[0]
+        e_related = Enrollment.objects.select_related()[0]
         self.assertEqual(e_related.std.person.user.name, "std")
         self.assertEqual(e_related.cls.org.person.user.name, "org")
 
@@ -228,19 +228,15 @@ class SelectRelatedRegressTests(TestCase):
         c = C.objects.create(
             name="c", lots_of_text="lots_of_text_c", is_published=True, c_a=a, c_b=b
         )
-        results = (
-            C.objects.all()
-            .only(
-                "name",
-                "lots_of_text",
-                "c_a",
-                "c_b",
-                "c_b__lots_of_text",
-                "c_a__name",
-                "c_b__name",
-            )
-            .select_related()
-        )
+        results = C.objects.only(
+            "name",
+            "lots_of_text",
+            "c_a",
+            "c_b",
+            "c_b__lots_of_text",
+            "c_a__name",
+            "c_b__name",
+        ).select_related()
         self.assertSequenceEqual(results, [c])
         with self.assertNumQueries(0):
             qs_c = results[0]
diff --git a/tests/serializers/tests.py b/tests/serializers/tests.py
index d995b36e04..48899cb3fb 100644
--- a/tests/serializers/tests.py
+++ b/tests/serializers/tests.py
@@ -282,7 +282,7 @@ class SerializersTestBase:
         with self.assertNumQueries(3):
             serializers.serialize(
                 self.serializer_name,
-                Article.objects.all().prefetch_related("categories", "meta_data"),
+                Article.objects.prefetch_related("categories", "meta_data"),
             )
         # One query for the Article table, and two m2m queries for each
         # article.
@@ -361,7 +361,7 @@ class SerializersTestBase:
         for obj in deserial_objs:
             self.assertFalse(obj.object.id)
             obj.save()
-        self.assertEqual(Category.objects.all().count(), 5)
+        self.assertEqual(Category.objects.count(), 5)
 
     def test_deterministic_mapping_ordering(self):
         """Mapping such as fields should be deterministically ordered. (#24558)"""
@@ -454,9 +454,9 @@ class SerializersTransactionTestBase:
                     obj.save()
 
         for model_cls in (Category, Author, Article):
-            self.assertEqual(model_cls.objects.all().count(), 1)
+            self.assertEqual(model_cls.objects.count(), 1)
         art_obj = Article.objects.all()[0]
-        self.assertEqual(art_obj.categories.all().count(), 1)
+        self.assertEqual(art_obj.categories.count(), 1)
         self.assertEqual(art_obj.author.name, "Agnes")
 
 
diff --git a/tests/servers/tests.py b/tests/servers/tests.py
index 0601e1b837..6aaa8dbada 100644
--- a/tests/servers/tests.py
+++ b/tests/servers/tests.py
@@ -329,7 +329,7 @@ class LiveServerDatabase(LiveServerBase):
         with self.urlopen("/create_model_instance/"):
             pass
         self.assertQuerysetEqual(
-            Person.objects.all().order_by("pk"),
+            Person.objects.order_by("pk"),
             ["jane", "robert", "emily"],
             lambda b: b.name,
         )
diff --git a/tests/sites_framework/tests.py b/tests/sites_framework/tests.py
index bb0f79e5fe..4a297a9243 100644
--- a/tests/sites_framework/tests.py
+++ b/tests/sites_framework/tests.py
@@ -23,7 +23,7 @@ class SitesFrameworkTestCase(TestCase):
         article = ExclusiveArticle.objects.create(
             title="Breaking News!", site_id=settings.SITE_ID
         )
-        self.assertEqual(ExclusiveArticle.on_site.all().get(), article)
+        self.assertEqual(ExclusiveArticle.on_site.get(), article)
 
     def test_sites_m2m(self):
         article = SyndicatedArticle.objects.create(title="Fresh News!")
@@ -31,14 +31,14 @@ class SitesFrameworkTestCase(TestCase):
         article.sites.add(Site.objects.get(id=settings.SITE_ID + 1))
         article2 = SyndicatedArticle.objects.create(title="More News!")
         article2.sites.add(Site.objects.get(id=settings.SITE_ID + 1))
-        self.assertEqual(SyndicatedArticle.on_site.all().get(), article)
+        self.assertEqual(SyndicatedArticle.on_site.get(), article)
 
     def test_custom_named_field(self):
         article = CustomArticle.objects.create(
             title="Tantalizing News!",
             places_this_article_should_appear_id=settings.SITE_ID,
         )
-        self.assertEqual(CustomArticle.on_site.all().get(), article)
+        self.assertEqual(CustomArticle.on_site.get(), article)
 
 
 @isolate_apps("sites_framework")
diff --git a/tests/test_utils/tests.py b/tests/test_utils/tests.py
index f62a473357..caaf13ddd0 100644
--- a/tests/test_utils/tests.py
+++ b/tests/test_utils/tests.py
@@ -270,37 +270,37 @@ class AssertQuerysetEqualTests(TestCase):
 
     def test_ordered(self):
         self.assertQuerysetEqual(
-            Person.objects.all().order_by("name"),
+            Person.objects.order_by("name"),
             [self.p1, self.p2],
         )
 
     def test_unordered(self):
         self.assertQuerysetEqual(
-            Person.objects.all().order_by("name"), [self.p2, self.p1], ordered=False
+            Person.objects.order_by("name"), [self.p2, self.p1], ordered=False
         )
 
     def test_queryset(self):
         self.assertQuerysetEqual(
-            Person.objects.all().order_by("name"),
-            Person.objects.all().order_by("name"),
+            Person.objects.order_by("name"),
+            Person.objects.order_by("name"),
         )
 
     def test_flat_values_list(self):
         self.assertQuerysetEqual(
-            Person.objects.all().order_by("name").values_list("name", flat=True),
+            Person.objects.order_by("name").values_list("name", flat=True),
             ["p1", "p2"],
         )
 
     def test_transform(self):
         self.assertQuerysetEqual(
-            Person.objects.all().order_by("name"),
+            Person.objects.order_by("name"),
             [self.p1.pk, self.p2.pk],
             transform=lambda x: x.pk,
         )
 
     def test_repr_transform(self):
         self.assertQuerysetEqual(
-            Person.objects.all().order_by("name"),
+            Person.objects.order_by("name"),
             [repr(self.p1), repr(self.p2)],
             transform=repr,
         )
diff --git a/tests/timezones/tests.py b/tests/timezones/tests.py
index 4ebd704f23..75c79ecfdd 100644
--- a/tests/timezones/tests.py
+++ b/tests/timezones/tests.py
@@ -203,7 +203,7 @@ class LegacyDatabaseTests(TestCase):
         Event.objects.create(dt=datetime.datetime(2011, 9, 1, 23, 20, 20))
         Event.objects.create(dt=datetime.datetime(2011, 9, 1, 13, 20, 30))
         Event.objects.create(dt=datetime.datetime(2011, 9, 1, 3, 20, 40))
-        result = Event.objects.all().aggregate(Min("dt"), Max("dt"))
+        result = Event.objects.aggregate(Min("dt"), Max("dt"))
         self.assertEqual(
             result,
             {
@@ -499,7 +499,7 @@ class NewDatabaseTests(TestCase):
         Event.objects.create(dt=datetime.datetime(2011, 9, 1, 23, 20, 20, tzinfo=EAT))
         Event.objects.create(dt=datetime.datetime(2011, 9, 1, 13, 20, 30, tzinfo=EAT))
         Event.objects.create(dt=datetime.datetime(2011, 9, 1, 3, 20, 40, tzinfo=EAT))
-        result = Event.objects.all().aggregate(Min("dt"), Max("dt"))
+        result = Event.objects.aggregate(Min("dt"), Max("dt"))
         self.assertEqual(
             result,
             {