diff --git a/django/test/__init__.py b/django/test/__init__.py
index 957b293..c996ed4 100644
--- a/django/test/__init__.py
+++ b/django/test/__init__.py
@@ -4,3 +4,4 @@ Django Unit Test and Doctest framework.
 
 from django.test.client import Client
 from django.test.testcases import TestCase, TransactionTestCase
+from django.test.utils import Approximate
diff --git a/django/test/utils.py b/django/test/utils.py
index b6ab399..f38c60f 100644
--- a/django/test/utils.py
+++ b/django/test/utils.py
@@ -1,4 +1,6 @@
-import sys, time, os
+import sys
+import time
+import os
 from django.conf import settings
 from django.core import mail
 from django.core.mail.backends import locmem
@@ -6,6 +8,21 @@ from django.test import signals
 from django.template import Template
 from django.utils.translation import deactivate
 
+
+class Approximate(object):
+    def __init__(self, val, places=7):
+        self.val = val
+        self.places = places
+
+    def __repr__(self):
+        return repr(self.val)
+
+    def __eq__(self, other):
+        if self.val == other:
+            return True
+        return round(abs(self.val-other), self.places) == 0
+
+
 class ContextList(list):
     """A wrapper that provides direct key access to context items contained
     in a list of context objects.
diff --git a/tests/modeltests/aggregation/tests.py b/tests/modeltests/aggregation/tests.py
index cb61143..c830368 100644
--- a/tests/modeltests/aggregation/tests.py
+++ b/tests/modeltests/aggregation/tests.py
@@ -2,24 +2,11 @@ import datetime
 from decimal import Decimal
 
 from django.db.models import Avg, Sum, Count, Max, Min
-from django.test import TestCase
+from django.test import TestCase, Approximate
 
 from models import Author, Publisher, Book, Store
 
 
-class Approximate(object):
-    def __init__(self, val, places=7):
-        self.val = val
-        self.places = places
-
-    def __repr__(self):
-        return repr(self.val)
-
-    def __eq__(self, other):
-        if self.val == other:
-            return True
-        return round(abs(self.val-other), self.places) == 0
-
 class BaseAggregateTestCase(TestCase):
     fixtures = ["initial_data.json"]
 
diff --git a/tests/regressiontests/aggregation_regress/models.py b/tests/regressiontests/aggregation_regress/models.py
index ba74357..783c219 100644
--- a/tests/regressiontests/aggregation_regress/models.py
+++ b/tests/regressiontests/aggregation_regress/models.py
@@ -4,6 +4,7 @@ import pickle
 from django.db import connection, models, DEFAULT_DB_ALIAS
 from django.conf import settings
 
+
 class Author(models.Model):
     name = models.CharField(max_length=100)
     age = models.IntegerField()
@@ -12,6 +13,7 @@ class Author(models.Model):
     def __unicode__(self):
         return self.name
 
+
 class Publisher(models.Model):
     name = models.CharField(max_length=255)
     num_awards = models.IntegerField()
@@ -19,6 +21,7 @@ class Publisher(models.Model):
     def __unicode__(self):
         return self.name
 
+
 class Book(models.Model):
     isbn = models.CharField(max_length=9)
     name = models.CharField(max_length=255)
@@ -36,6 +39,7 @@ class Book(models.Model):
     def __unicode__(self):
         return self.name
 
+
 class Store(models.Model):
     name = models.CharField(max_length=255)
     books = models.ManyToManyField(Book)
@@ -45,334 +49,21 @@ class Store(models.Model):
     def __unicode__(self):
         return self.name
 
+
 class Entries(models.Model):
     EntryID = models.AutoField(primary_key=True, db_column='Entry ID')
     Entry = models.CharField(unique=True, max_length=50)
     Exclude = models.BooleanField()
 
+
 class Clues(models.Model):
     ID = models.AutoField(primary_key=True)
     EntryID = models.ForeignKey(Entries, verbose_name='Entry', db_column = 'Entry ID')
     Clue = models.CharField(max_length=150)
 
+
 class HardbackBook(Book):
     weight = models.FloatField()
 
     def __unicode__(self):
         return "%s (hardback): %s" % (self.name, self.weight)
-
-__test__ = {'API_TESTS': """
->>> from django.core import management
->>> from django.db.models import get_app, F
-
-# Reset the database representation of this app.
-# This will return the database to a clean initial state.
->>> management.call_command('flush', verbosity=0, interactive=False)
-
->>> from django.db.models import Avg, Sum, Count, Max, Min, StdDev, Variance
-
-# Ordering requests are ignored
->>> Author.objects.all().order_by('name').aggregate(Avg('age'))
-{'age__avg': 37.4...}
-
-# Implicit ordering is also ignored
->>> Book.objects.all().aggregate(Sum('pages'))
-{'pages__sum': 3703}
-
-# Baseline results
->>> Book.objects.all().aggregate(Sum('pages'), Avg('pages'))
-{'pages__sum': 3703, 'pages__avg': 617.1...}
-
-# Empty values query doesn't affect grouping or results
->>> Book.objects.all().values().aggregate(Sum('pages'), Avg('pages'))
-{'pages__sum': 3703, 'pages__avg': 617.1...}
-
-# Aggregate overrides extra selected column
->>> Book.objects.all().extra(select={'price_per_page' : 'price / pages'}).aggregate(Sum('pages'))
-{'pages__sum': 3703}
-
-# Annotations get combined with extra select clauses
->>> sorted((k,v) for k,v in Book.objects.all().annotate(mean_auth_age=Avg('authors__age')).extra(select={'manufacture_cost' : 'price * .5'}).get(pk=2).__dict__.items() if k != '_state')
-[('contact_id', 3), ('id', 2), ('isbn', u'067232959'), ('manufacture_cost', ...11.545...), ('mean_auth_age', 45.0), ('name', u'Sams Teach Yourself Django in 24 Hours'), ('pages', 528), ('price', Decimal("23.09")), ('pubdate', datetime.date(2008, 3, 3)), ('publisher_id', 2), ('rating', 3.0)]
-
-# Order of the annotate/extra in the query doesn't matter
->>> sorted((k,v) for k,v in Book.objects.all().extra(select={'manufacture_cost' : 'price * .5'}).annotate(mean_auth_age=Avg('authors__age')).get(pk=2).__dict__.items()if k != '_state')
-[('contact_id', 3), ('id', 2), ('isbn', u'067232959'), ('manufacture_cost', ...11.545...), ('mean_auth_age', 45.0), ('name', u'Sams Teach Yourself Django in 24 Hours'), ('pages', 528), ('price', Decimal("23.09")), ('pubdate', datetime.date(2008, 3, 3)), ('publisher_id', 2), ('rating', 3.0)]
-
-# Values queries can be combined with annotate and extra
->>> sorted((k,v) for k,v in Book.objects.all().annotate(mean_auth_age=Avg('authors__age')).extra(select={'manufacture_cost' : 'price * .5'}).values().get(pk=2).items()if k != '_state')
-[('contact_id', 3), ('id', 2), ('isbn', u'067232959'), ('manufacture_cost', ...11.545...), ('mean_auth_age', 45.0), ('name', u'Sams Teach Yourself Django in 24 Hours'), ('pages', 528), ('price', Decimal("23.09")), ('pubdate', datetime.date(2008, 3, 3)), ('publisher_id', 2), ('rating', 3.0)]
-
-# The order of the (empty) values, annotate and extra clauses doesn't matter
->>> sorted((k,v) for k,v in Book.objects.all().values().annotate(mean_auth_age=Avg('authors__age')).extra(select={'manufacture_cost' : 'price * .5'}).get(pk=2).items()if k != '_state')
-[('contact_id', 3), ('id', 2), ('isbn', u'067232959'), ('manufacture_cost', ...11.545...), ('mean_auth_age', 45.0), ('name', u'Sams Teach Yourself Django in 24 Hours'), ('pages', 528), ('price', Decimal("23.09")), ('pubdate', datetime.date(2008, 3, 3)), ('publisher_id', 2), ('rating', 3.0)]
-
-# If the annotation precedes the values clause, it won't be included
-# unless it is explicitly named
->>> sorted(Book.objects.all().annotate(mean_auth_age=Avg('authors__age')).extra(select={'price_per_page' : 'price / pages'}).values('name').get(pk=1).items())
-[('name', u'The Definitive Guide to Django: Web Development Done Right')]
-
->>> sorted(Book.objects.all().annotate(mean_auth_age=Avg('authors__age')).extra(select={'price_per_page' : 'price / pages'}).values('name','mean_auth_age').get(pk=1).items())
-[('mean_auth_age', 34.5), ('name', u'The Definitive Guide to Django: Web Development Done Right')]
-
-# If an annotation isn't included in the values, it can still be used in a filter
->>> Book.objects.annotate(n_authors=Count('authors')).values('name').filter(n_authors__gt=2)
-[{'name': u'Python Web Development with Django'}]
-
-# The annotations are added to values output if values() precedes annotate()
->>> sorted(Book.objects.all().values('name').annotate(mean_auth_age=Avg('authors__age')).extra(select={'price_per_page' : 'price / pages'}).get(pk=1).items())
-[('mean_auth_age', 34.5), ('name', u'The Definitive Guide to Django: Web Development Done Right')]
-
-# Check that all of the objects are getting counted (allow_nulls) and that values respects the amount of objects
->>> len(Author.objects.all().annotate(Avg('friends__age')).values())
-9
-
-# Check that consecutive calls to annotate accumulate in the query
->>> Book.objects.values('price').annotate(oldest=Max('authors__age')).order_by('oldest', 'price').annotate(Max('publisher__num_awards'))
-[{'price': Decimal("30..."), 'oldest': 35, 'publisher__num_awards__max': 3}, {'price': Decimal("29.69"), 'oldest': 37, 'publisher__num_awards__max': 7}, {'price': Decimal("23.09"), 'oldest': 45, 'publisher__num_awards__max': 1}, {'price': Decimal("75..."), 'oldest': 57, 'publisher__num_awards__max': 9}, {'price': Decimal("82.8..."), 'oldest': 57, 'publisher__num_awards__max': 7}]
-
-# Aggregates can be composed over annotations.
-# The return type is derived from the composed aggregate
->>> Book.objects.all().annotate(num_authors=Count('authors__id')).aggregate(Max('pages'), Max('price'), Sum('num_authors'), Avg('num_authors'))
-{'num_authors__sum': 10, 'num_authors__avg': 1.66..., 'pages__max': 1132, 'price__max': Decimal("82.80")}
-
-# Bad field requests in aggregates are caught and reported
->>> Book.objects.all().aggregate(num_authors=Count('foo'))
-Traceback (most recent call last):
-...
-FieldError: Cannot resolve keyword 'foo' into field. Choices are: authors, contact, hardbackbook, id, isbn, name, pages, price, pubdate, publisher, rating, store
-
->>> Book.objects.all().annotate(num_authors=Count('foo'))
-Traceback (most recent call last):
-...
-FieldError: Cannot resolve keyword 'foo' into field. Choices are: authors, contact, hardbackbook, id, isbn, name, pages, price, pubdate, publisher, rating, store
-
->>> Book.objects.all().annotate(num_authors=Count('authors__id')).aggregate(Max('foo'))
-Traceback (most recent call last):
-...
-FieldError: Cannot resolve keyword 'foo' into field. Choices are: authors, contact, hardbackbook, id, isbn, name, pages, price, pubdate, publisher, rating, store, num_authors
-
-# Old-style count aggregations can be mixed with new-style
->>> Book.objects.annotate(num_authors=Count('authors')).count()
-6
-
-# Non-ordinal, non-computed Aggregates over annotations correctly inherit
-# the annotation's internal type if the annotation is ordinal or computed
->>> Book.objects.annotate(num_authors=Count('authors')).aggregate(Max('num_authors'))
-{'num_authors__max': 3}
-
->>> Publisher.objects.annotate(avg_price=Avg('book__price')).aggregate(Max('avg_price'))
-{'avg_price__max': 75.0...}
-
-# Aliases are quoted to protected aliases that might be reserved names
->>> Book.objects.aggregate(number=Max('pages'), select=Max('pages'))
-{'number': 1132, 'select': 1132}
-
-# Regression for #10064: select_related() plays nice with aggregates
->>> sorted(Book.objects.select_related('publisher').annotate(num_authors=Count('authors')).values()[0].iteritems())
-[('contact_id', 8), ('id', 5), ('isbn', u'013790395'), ('name', u'Artificial Intelligence: A Modern Approach'), ('num_authors', 2), ('pages', 1132), ('price', Decimal("82.8...")), ('pubdate', datetime.date(1995, 1, 15)), ('publisher_id', 3), ('rating', 4.0)]
-
-# Regression for #10010: exclude on an aggregate field is correctly negated
->>> len(Book.objects.annotate(num_authors=Count('authors')))
-6
->>> len(Book.objects.annotate(num_authors=Count('authors')).filter(num_authors__gt=2))
-1
->>> len(Book.objects.annotate(num_authors=Count('authors')).exclude(num_authors__gt=2))
-5
-
->>> len(Book.objects.annotate(num_authors=Count('authors')).filter(num_authors__lt=3).exclude(num_authors__lt=2))
-2
->>> len(Book.objects.annotate(num_authors=Count('authors')).exclude(num_authors__lt=2).filter(num_authors__lt=3))
-2
-
-# Aggregates can be used with F() expressions
-# ... where the F() is pushed into the HAVING clause
->>> Publisher.objects.annotate(num_books=Count('book')).filter(num_books__lt=F('num_awards')/2).order_by('name').values('name','num_books','num_awards')
-[{'num_books': 1, 'name': u'Morgan Kaufmann', 'num_awards': 9}, {'num_books': 2, 'name': u'Prentice Hall', 'num_awards': 7}]
-
->>> Publisher.objects.annotate(num_books=Count('book')).exclude(num_books__lt=F('num_awards')/2).order_by('name').values('name','num_books','num_awards')
-[{'num_books': 2, 'name': u'Apress', 'num_awards': 3}, {'num_books': 0, 'name': u"Jonno's House of Books", 'num_awards': 0}, {'num_books': 1, 'name': u'Sams', 'num_awards': 1}]
-
-# ... and where the F() references an aggregate
->>> Publisher.objects.annotate(num_books=Count('book')).filter(num_awards__gt=2*F('num_books')).order_by('name').values('name','num_books','num_awards')
-[{'num_books': 1, 'name': u'Morgan Kaufmann', 'num_awards': 9}, {'num_books': 2, 'name': u'Prentice Hall', 'num_awards': 7}]
-
->>> Publisher.objects.annotate(num_books=Count('book')).exclude(num_books__lt=F('num_awards')/2).order_by('name').values('name','num_books','num_awards')
-[{'num_books': 2, 'name': u'Apress', 'num_awards': 3}, {'num_books': 0, 'name': u"Jonno's House of Books", 'num_awards': 0}, {'num_books': 1, 'name': u'Sams', 'num_awards': 1}]
-
-# Tests on fields with non-default table and column names.
->>> Clues.objects.values('EntryID__Entry').annotate(Appearances=Count('EntryID'), Distinct_Clues=Count('Clue', distinct=True))
-[]
-
->>> Entries.objects.annotate(clue_count=Count('clues__ID'))
-[]
-
-# Regression for #10089: Check handling of empty result sets with aggregates
->>> Book.objects.filter(id__in=[]).count()
-0
-
->>> Book.objects.filter(id__in=[]).aggregate(num_authors=Count('authors'), avg_authors=Avg('authors'), max_authors=Max('authors'), max_price=Max('price'), max_rating=Max('rating'))
-{'max_authors': None, 'max_rating': None, 'num_authors': 0, 'avg_authors': None, 'max_price': None}
-
->>> list(Publisher.objects.filter(pk=5).annotate(num_authors=Count('book__authors'), avg_authors=Avg('book__authors'), max_authors=Max('book__authors'), max_price=Max('book__price'), max_rating=Max('book__rating')).values()) == [{'max_authors': None, 'name': u"Jonno's House of Books", 'num_awards': 0, 'max_price': None, 'num_authors': 0, 'max_rating': None, 'id': 5, 'avg_authors': None}]
-True
-
-# Regression for #10113 - Fields mentioned in order_by() must be included in the GROUP BY.
-# This only becomes a problem when the order_by introduces a new join.
->>> Book.objects.annotate(num_authors=Count('authors')).order_by('publisher__name', 'name')
-[<Book: Practical Django Projects>, <Book: The Definitive Guide to Django: Web Development Done Right>, <Book: Paradigms of Artificial Intelligence Programming: Case Studies in Common Lisp>, <Book: Artificial Intelligence: A Modern Approach>, <Book: Python Web Development with Django>, <Book: Sams Teach Yourself Django in 24 Hours>]
-
-# Regression for #10127 - Empty select_related() works with annotate
->>> books = Book.objects.all().filter(rating__lt=4.5).select_related().annotate(Avg('authors__age'))
->>> sorted([(b.name, b.authors__age__avg, b.publisher.name, b.contact.name) for b in books])
-[(u'Artificial Intelligence: A Modern Approach', 51.5, u'Prentice Hall', u'Peter Norvig'), (u'Practical Django Projects', 29.0, u'Apress', u'James Bennett'), (u'Python Web Development with Django', 30.3..., u'Prentice Hall', u'Jeffrey Forcier'), (u'Sams Teach Yourself Django in 24 Hours', 45.0, u'Sams', u'Brad Dayley')]
-
-# Regression for #10132 - If the values() clause only mentioned extra(select=) columns, those columns are used for grouping
->>> Book.objects.extra(select={'pub':'publisher_id'}).values('pub').annotate(Count('id')).order_by('pub')
-[{'pub': 1, 'id__count': 2}, {'pub': 2, 'id__count': 1}, {'pub': 3, 'id__count': 2}, {'pub': 4, 'id__count': 1}]
-
->>> Book.objects.extra(select={'pub':'publisher_id','foo':'pages'}).values('pub').annotate(Count('id')).order_by('pub')
-[{'pub': 1, 'id__count': 2}, {'pub': 2, 'id__count': 1}, {'pub': 3, 'id__count': 2}, {'pub': 4, 'id__count': 1}]
-
-# Regression for #10182 - Queries with aggregate calls are correctly realiased when used in a subquery
->>> ids = Book.objects.filter(pages__gt=100).annotate(n_authors=Count('authors')).filter(n_authors__gt=2).order_by('n_authors')
->>> Book.objects.filter(id__in=ids)
-[<Book: Python Web Development with Django>]
-
-# Regression for #10197 -- Queries with aggregates can be pickled.
-# First check that pickling is possible at all. No crash = success
->>> qs = Book.objects.annotate(num_authors=Count('authors'))
->>> out = pickle.dumps(qs)
-
-# Then check that the round trip works.
->>> query = qs.query.get_compiler(qs.db).as_sql()[0]
->>> select_fields = qs.query.select_fields
->>> query2 = pickle.loads(pickle.dumps(qs))
->>> query2.query.get_compiler(query2.db).as_sql()[0] == query
-True
->>> query2.query.select_fields = select_fields
-
-# Regression for #10199 - Aggregate calls clone the original query so the original query can still be used
->>> books = Book.objects.all()
->>> _ = books.aggregate(Avg('authors__age'))
->>> books.all()
-[<Book: Artificial Intelligence: A Modern Approach>, <Book: Paradigms of Artificial Intelligence Programming: Case Studies in Common Lisp>, <Book: Practical Django Projects>, <Book: Python Web Development with Django>, <Book: Sams Teach Yourself Django in 24 Hours>, <Book: The Definitive Guide to Django: Web Development Done Right>]
-
-# Regression for #10248 - Annotations work with DateQuerySets
->>> Book.objects.annotate(num_authors=Count('authors')).filter(num_authors=2).dates('pubdate', 'day')
-[datetime.datetime(1995, 1, 15, 0, 0), datetime.datetime(2007, 12, 6, 0, 0)]
-
-# Regression for #10290 - extra selects with parameters can be used for
-# grouping.
->>> qs = Book.objects.all().annotate(mean_auth_age=Avg('authors__age')).extra(select={'sheets' : '(pages + %s) / %s'}, select_params=[1, 2]).order_by('sheets').values('sheets')
->>> [int(x['sheets']) for x in qs]
-[150, 175, 224, 264, 473, 566]
-
-# Regression for 10425 - annotations don't get in the way of a count() clause
->>> Book.objects.values('publisher').annotate(Count('publisher')).count()
-4
-
->>> Book.objects.annotate(Count('publisher')).values('publisher').count()
-6
-
->>> publishers = Publisher.objects.filter(id__in=(1,2))
->>> publishers
-[<Publisher: Apress>, <Publisher: Sams>]
-
->>> publishers = publishers.annotate(n_books=models.Count('book'))
->>> publishers[0].n_books
-2
-
->>> publishers
-[<Publisher: Apress>, <Publisher: Sams>]
-
->>> books = Book.objects.filter(publisher__in=publishers)
->>> books
-[<Book: Practical Django Projects>, <Book: Sams Teach Yourself Django in 24 Hours>, <Book: The Definitive Guide to Django: Web Development Done Right>]
-
->>> publishers
-[<Publisher: Apress>, <Publisher: Sams>]
-
-
-# Regression for 10666 - inherited fields work with annotations and aggregations
->>> HardbackBook.objects.aggregate(n_pages=Sum('book_ptr__pages'))
-{'n_pages': 2078}
-
->>> HardbackBook.objects.aggregate(n_pages=Sum('pages'))
-{'n_pages': 2078}
-
->>> HardbackBook.objects.annotate(n_authors=Count('book_ptr__authors')).values('name','n_authors')
-[{'n_authors': 2, 'name': u'Artificial Intelligence: A Modern Approach'}, {'n_authors': 1, 'name': u'Paradigms of Artificial Intelligence Programming: Case Studies in Common Lisp'}]
-
->>> HardbackBook.objects.annotate(n_authors=Count('authors')).values('name','n_authors')
-[{'n_authors': 2, 'name': u'Artificial Intelligence: A Modern Approach'}, {'n_authors': 1, 'name': u'Paradigms of Artificial Intelligence Programming: Case Studies in Common Lisp'}]
-
-# Regression for #10766 - Shouldn't be able to reference an aggregate fields in an an aggregate() call.
->>> Book.objects.all().annotate(mean_age=Avg('authors__age')).annotate(Avg('mean_age'))
-Traceback (most recent call last):
-...
-FieldError: Cannot compute Avg('mean_age'): 'mean_age' is an aggregate
-
-"""
-}
-
-def run_stddev_tests():
-    """Check to see if StdDev/Variance tests should be run.
-
-    Stddev and Variance are not guaranteed to be available for SQLite, and
-    are not available for PostgreSQL before 8.2.
-    """
-    if settings.DATABASES[DEFAULT_DB_ALIAS]['ENGINE'] == 'django.db.backends.sqlite3':
-        return False
-
-    class StdDevPop(object):
-        sql_function = 'STDDEV_POP'
-
-    try:
-        connection.ops.check_aggregate_support(StdDevPop())
-    except:
-        return False
-    return True
-
-if run_stddev_tests():
-    __test__['API_TESTS'] += """
->>> Book.objects.aggregate(StdDev('pages'))
-{'pages__stddev': 311.46...}
-
->>> Book.objects.aggregate(StdDev('rating'))
-{'rating__stddev': 0.60...}
-
->>> Book.objects.aggregate(StdDev('price'))
-{'price__stddev': 24.16...}
-
-
->>> Book.objects.aggregate(StdDev('pages', sample=True))
-{'pages__stddev': 341.19...}
-
->>> Book.objects.aggregate(StdDev('rating', sample=True))
-{'rating__stddev': 0.66...}
-
->>> Book.objects.aggregate(StdDev('price', sample=True))
-{'price__stddev': 26.46...}
-
-
->>> Book.objects.aggregate(Variance('pages'))
-{'pages__variance': 97010.80...}
-
->>> Book.objects.aggregate(Variance('rating'))
-{'rating__variance': 0.36...}
-
->>> Book.objects.aggregate(Variance('price'))
-{'price__variance': 583.77...}
-
-
->>> Book.objects.aggregate(Variance('pages', sample=True))
-{'pages__variance': 116412.96...}
-
->>> Book.objects.aggregate(Variance('rating', sample=True))
-{'rating__variance': 0.44...}
-
->>> Book.objects.aggregate(Variance('price', sample=True))
-{'price__variance': 700.53...}
-
-"""
diff --git a/tests/regressiontests/aggregation_regress/tests.py b/tests/regressiontests/aggregation_regress/tests.py
index 3c4bdfa..6f33481 100644
--- a/tests/regressiontests/aggregation_regress/tests.py
+++ b/tests/regressiontests/aggregation_regress/tests.py
@@ -1,13 +1,39 @@
+import datetime
+from decimal import Decimal
+
+from django.core.exceptions import FieldError
 from django.conf import settings
-from django.test import TestCase
+from django.test import TestCase, Approximate
 from django.db import DEFAULT_DB_ALIAS
-from django.db.models import Count, Max
+from django.db.models import Count, Max, Avg, Sum, F
 
 from regressiontests.aggregation_regress.models import *
 
 
-class AggregationTests(TestCase):
+def run_stddev_tests():
+    """Check to see if StdDev/Variance tests should be run.
+
+    Stddev and Variance are not guaranteed to be available for SQLite, and
+    are not available for PostgreSQL before 8.2.
+    """
+    if settings.DATABASES[DEFAULT_DB_ALIAS]['ENGINE'] == 'django.db.backends.sqlite3':
+        return False
+
+    class StdDevPop(object):
+        sql_function = 'STDDEV_POP'
 
+    try:
+        connection.ops.check_aggregate_support(StdDevPop())
+    except:
+        return False
+    return True
+
+
+class AggregationTests(TestCase):
+    def assertObjectAttrs(self, obj, **kwargs):
+        for attr, value in kwargs.iteritems():
+            self.assertEqual(getattr(obj, attr), value)
+    
     def test_aggregates_in_where_clause(self):
         """
         Regression test for #12822: DatabaseError: aggregates not allowed in
@@ -70,3 +96,587 @@ class AggregationTests(TestCase):
             }).annotate(total_books=Count('book'))
             # force execution of the query
             list(qs)
+    
+    def test_aggregate(self):
+        # Ordering requests are ignored
+        self.assertEqual(
+            Author.objects.order_by("name").aggregate(Avg("age")),
+            {"age__avg": Approximate(37.444, places=1)}
+        )
+        
+        # Implicit ordering is also ignored
+        self.assertEqual(
+            Book.objects.aggregate(Sum("pages")),
+            {"pages__sum": 3703},
+        )
+        
+        # Baseline results
+        self.assertEqual(
+            Book.objects.aggregate(Sum('pages'), Avg('pages')),
+            {'pages__sum': 3703, 'pages__avg': Approximate(617.166, places=2)}        
+        )
+        
+        # Empty values query doesn't affect grouping or results
+        self.assertEqual(
+            Book.objects.values().aggregate(Sum('pages'), Avg('pages')),
+            {'pages__sum': 3703, 'pages__avg': Approximate(617.166, places=2)}
+        )
+
+        # Aggregate overrides extra selected column
+        self.assertEqual(
+            Book.objects.extra(select={'price_per_page' : 'price / pages'}).aggregate(Sum('pages')),
+            {'pages__sum': 3703}
+        )
+    
+    def test_annotation(self):
+        # Annotations get combined with extra select clauses
+        obj = Book.objects.annotate(mean_auth_age=Avg("authors__age")).extra(select={"manufacture_cost": "price * .5"}).get(pk=2)
+        self.assertObjectAttrs(obj,
+            contact_id=3,
+            id=2,
+            isbn=u'067232959',
+            manufacture_cost=11.545,
+            mean_auth_age=45.0,
+            name='Sams Teach Yourself Django in 24 Hours',
+            pages=528,
+            price=Decimal("23.09"),
+            pubdate=datetime.date(2008, 3, 3),
+            publisher_id=2,
+            rating=3.0
+        )
+
+        # Order of the annotate/extra in the query doesn't matter
+        obj = Book.objects.extra(select={'manufacture_cost' : 'price * .5'}).annotate(mean_auth_age=Avg('authors__age')).get(pk=2)
+        self.assertObjectAttrs(obj,
+            contact_id=3,
+            id=2,
+            isbn=u'067232959',
+            manufacture_cost=11.545,
+            mean_auth_age=45.0,
+            name=u'Sams Teach Yourself Django in 24 Hours',
+            pages=528,
+            price=Decimal("23.09"),
+            pubdate=datetime.date(2008, 3, 3),
+            publisher_id=2,
+            rating=3.0
+        )
+
+        # Values queries can be combined with annotate and extra
+        obj = Book.objects.annotate(mean_auth_age=Avg('authors__age')).extra(select={'manufacture_cost' : 'price * .5'}).values().get(pk=2)
+        self.assertEqual(obj, {
+            "contact_id": 3,
+            "id": 2,
+            "isbn": u"067232959",
+            "manufacture_cost": 11.545,
+            "mean_auth_age": 45.0,
+            "name": u"Sams Teach Yourself Django in 24 Hours",
+            "pages": 528,
+            "price": Decimal("23.09"),
+            "pubdate": datetime.date(2008, 3, 3),
+            "publisher_id": 2,
+            "rating": 3.0,
+        })
+        
+        # The order of the (empty) values, annotate and extra clauses doesn't
+        # matter
+        obj = Book.objects.values().annotate(mean_auth_age=Avg('authors__age')).extra(select={'manufacture_cost' : 'price * .5'}).get(pk=2)
+        self.assertEqual(obj, {
+            'contact_id': 3,
+            'id': 2,
+            'isbn': u'067232959',
+            'manufacture_cost': 11.545,
+            'mean_auth_age': 45.0,
+            'name': u'Sams Teach Yourself Django in 24 Hours',
+            'pages': 528,
+            'price': Decimal("23.09"),
+            'pubdate': datetime.date(2008, 3, 3),
+            'publisher_id': 2,
+            'rating': 3.0
+        })
+
+        # If the annotation precedes the values clause, it won't be included
+        # unless it is explicitly named
+        obj = Book.objects.annotate(mean_auth_age=Avg('authors__age')).extra(select={'price_per_page' : 'price / pages'}).values('name').get(pk=1)
+        self.assertEqual(obj, {
+            "name": u'The Definitive Guide to Django: Web Development Done Right',
+        })
+
+        obj = Book.objects.annotate(mean_auth_age=Avg('authors__age')).extra(select={'price_per_page' : 'price / pages'}).values('name','mean_auth_age').get(pk=1)
+        self.assertEqual(obj, {
+            'mean_auth_age': 34.5,
+            'name': u'The Definitive Guide to Django: Web Development Done Right',
+        })
+
+        # If an annotation isn't included in the values, it can still be used
+        # in a filter
+        qs = Book.objects.annotate(n_authors=Count('authors')).values('name').filter(n_authors__gt=2)
+        self.assertQuerysetEqual(
+            qs, [
+                {"name": u'Python Web Development with Django'}
+            ],
+            lambda b: b,
+        )
+        
+        # The annotations are added to values output if values() precedes
+        # annotate()
+        obj = Book.objects.values('name').annotate(mean_auth_age=Avg('authors__age')).extra(select={'price_per_page' : 'price / pages'}).get(pk=1)
+        self.assertEqual(obj, {
+            'mean_auth_age': 34.5,
+            'name': u'The Definitive Guide to Django: Web Development Done Right',
+        })
+        
+        # Check that all of the objects are getting counted (allow_nulls) and
+        # that values respects the amount of objects
+        self.assertEqual(
+            len(Author.objects.annotate(Avg('friends__age')).values()),
+            9
+        )
+        
+        # Check that consecutive calls to annotate accumulate in the query
+        qs = Book.objects.values('price').annotate(oldest=Max('authors__age')).order_by('oldest', 'price').annotate(Max('publisher__num_awards'))
+        self.assertQuerysetEqual(
+            qs, [
+                {'price': Decimal("30"), 'oldest': 35, 'publisher__num_awards__max': 3},
+                {'price': Decimal("29.69"), 'oldest': 37, 'publisher__num_awards__max': 7},
+                {'price': Decimal("23.09"), 'oldest': 45, 'publisher__num_awards__max': 1},
+                {'price': Decimal("75"), 'oldest': 57, 'publisher__num_awards__max': 9},
+                {'price': Decimal("82.8"), 'oldest': 57, 'publisher__num_awards__max': 7}
+            ],
+            lambda b: b,
+        )
+    
+    def test_aggrate_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'))
+        self.assertEqual(vals, {
+            'num_authors__sum': 10,
+            'num_authors__avg': Approximate(1.666, places=2),
+            'pages__max': 1132,
+            'price__max': Decimal("82.80")
+        })
+    
+    def test_field_error(self):
+        # Bad field requests in aggregates are caught and reported
+        self.assertRaises(
+            FieldError,
+            lambda: Book.objects.all().aggregate(num_authors=Count('foo'))
+        )
+        
+        self.assertRaises(
+            FieldError,
+            lambda: Book.objects.all().annotate(num_authors=Count('foo'))
+        )
+        
+        self.assertRaises(
+            FieldError,
+            lambda: Book.objects.all().annotate(num_authors=Count('authors__id')).aggregate(Max('foo'))
+        )
+    
+    def test_more(self):
+        # Old-style count aggregations can be mixed with new-style
+        self.assertEqual(
+            Book.objects.annotate(num_authors=Count('authors')).count(),
+            6
+        )
+
+        # Non-ordinal, non-computed Aggregates over annotations correctly
+        # inherit the annotation's internal type if the annotation is ordinal
+        # or computed
+        vals = Book.objects.annotate(num_authors=Count('authors')).aggregate(Max('num_authors'))
+        self.assertEqual(
+            vals,
+            {'num_authors__max': 3}
+        )
+        
+        vals = Publisher.objects.annotate(avg_price=Avg('book__price')).aggregate(Max('avg_price'))
+        self.assertEqual(
+            vals,
+            {'avg_price__max': 75.0}
+        )
+        
+        # Aliases are quoted to protected aliases that might be reserved names
+        vals = Book.objects.aggregate(number=Max('pages'), select=Max('pages'))
+        self.assertEqual(
+            vals,
+            {'number': 1132, 'select': 1132}
+        )
+        
+        # Regression for #10064: select_related() plays nice with aggregates
+        obj = Book.objects.select_related('publisher').annotate(num_authors=Count('authors')).values()[0]
+        self.assertEqual(obj, {
+            'contact_id': 8,
+            'id': 5,
+            'isbn': u'013790395',
+            'name': u'Artificial Intelligence: A Modern Approach',
+            'num_authors': 2,
+            'pages': 1132,
+            'price': Decimal("82.8"),
+            'pubdate': datetime.date(1995, 1, 15),
+            'publisher_id': 3,
+            'rating': 4.0,
+        })
+        
+        # Regression for #10010: exclude on an aggregate field is correctly
+        # negated
+        self.assertEqual(
+            len(Book.objects.annotate(num_authors=Count('authors'))),
+            6
+        )
+        self.assertEqual(
+            len(Book.objects.annotate(num_authors=Count('authors')).filter(num_authors__gt=2)),
+            1
+        )
+        self.assertEqual(
+            len(Book.objects.annotate(num_authors=Count('authors')).exclude(num_authors__gt=2)),
+            5
+        )
+        
+        self.assertEqual(
+            len(Book.objects.annotate(num_authors=Count('authors')).filter(num_authors__lt=3).exclude(num_authors__lt=2)),
+            2
+        )
+        self.assertEqual(
+            len(Book.objects.annotate(num_authors=Count('authors')).exclude(num_authors__lt=2).filter(num_authors__lt=3)),
+            2
+        )
+    
+    def test_aggregate_fexpr(self):
+        # Aggregates can be used with F() expressions
+        # ... where the F() is pushed into the HAVING clause
+        qs = Publisher.objects.annotate(num_books=Count('book')).filter(num_books__lt=F('num_awards')/2).order_by('name').values('name','num_books','num_awards')
+        self.assertQuerysetEqual(
+            qs, [
+                {'num_books': 1, 'name': u'Morgan Kaufmann', 'num_awards': 9}, 
+                {'num_books': 2, 'name': u'Prentice Hall', 'num_awards': 7}
+            ],
+            lambda p: p,
+        )
+        
+        qs = Publisher.objects.annotate(num_books=Count('book')).exclude(num_books__lt=F('num_awards')/2).order_by('name').values('name','num_books','num_awards')
+        self.assertQuerysetEqual(
+            qs, [
+                {'num_books': 2, 'name': u'Apress', 'num_awards': 3}, 
+                {'num_books': 0, 'name': u"Jonno's House of Books", 'num_awards': 0},
+                {'num_books': 1, 'name': u'Sams', 'num_awards': 1}
+            ],
+            lambda p: p,
+        )
+        
+        # ... and where the F() references an aggregate
+        qs = Publisher.objects.annotate(num_books=Count('book')).filter(num_awards__gt=2*F('num_books')).order_by('name').values('name','num_books','num_awards')
+        self.assertQuerysetEqual(
+            qs, [
+                {'num_books': 1, 'name': u'Morgan Kaufmann', 'num_awards': 9},
+                {'num_books': 2, 'name': u'Prentice Hall', 'num_awards': 7}
+            ],
+            lambda p: p,
+        )
+        
+        qs = Publisher.objects.annotate(num_books=Count('book')).exclude(num_books__lt=F('num_awards')/2).order_by('name').values('name','num_books','num_awards')
+        self.assertQuerysetEqual(
+            qs, [
+                {'num_books': 2, 'name': u'Apress', 'num_awards': 3}, 
+                {'num_books': 0, 'name': u"Jonno's House of Books", 'num_awards': 0},
+                {'num_books': 1, 'name': u'Sams', 'num_awards': 1}
+            ],
+            lambda p: p,
+        )
+    
+    def test_db_col_table(self):
+        # Tests on fields with non-default table and column names.
+        qs = Clues.objects.values('EntryID__Entry').annotate(Appearances=Count('EntryID'), Distinct_Clues=Count('Clue', distinct=True))
+        self.assertQuerysetEqual(qs, [])
+        
+        qs = Entries.objects.annotate(clue_count=Count('clues__ID'))
+        self.assertQuerysetEqual(qs, [])
+    
+    def test_empty(self):
+        # Regression for #10089: Check handling of empty result sets with
+        # aggregates
+        self.assertEqual(
+            Book.objects.filter(id__in=[]).count(),
+            0
+        )
+        
+        vals = Book.objects.filter(id__in=[]).aggregate(num_authors=Count('authors'), avg_authors=Avg('authors'), max_authors=Max('authors'), max_price=Max('price'), max_rating=Max('rating'))
+        self.assertEqual(
+            vals,
+            {'max_authors': None, 'max_rating': None, 'num_authors': 0, 'avg_authors': None, 'max_price': None}
+        )
+        
+        qs = Publisher.objects.filter(pk=5).annotate(num_authors=Count('book__authors'), avg_authors=Avg('book__authors'), max_authors=Max('book__authors'), max_price=Max('book__price'), max_rating=Max('book__rating')).values()
+        self.assertQuerysetEqual(
+            qs, [
+                {'max_authors': None, 'name': u"Jonno's House of Books", 'num_awards': 0, 'max_price': None, 'num_authors': 0, 'max_rating': None, 'id': 5, 'avg_authors': None}
+            ],
+            lambda p: p
+        )
+    
+    def test_more_more(self):
+        # Regression for #10113 - Fields mentioned in order_by() must be
+        # included in the GROUP BY. This only becomes a problem when the
+        # order_by introduces a new join.
+        self.assertQuerysetEqual(
+            Book.objects.annotate(num_authors=Count('authors')).order_by('publisher__name', 'name'), [
+                "Practical Django Projects",
+                "The Definitive Guide to Django: Web Development Done Right",
+                "Paradigms of Artificial Intelligence Programming: Case Studies in Common Lisp",
+                "Artificial Intelligence: A Modern Approach",
+                "Python Web Development with Django",
+                "Sams Teach Yourself Django in 24 Hours",
+            ],
+            lambda b: b.name
+        )
+        
+        # Regression for #10127 - Empty select_related() works with annotate
+        qs = Book.objects.filter(rating__lt=4.5).select_related().annotate(Avg('authors__age'))
+        self.assertQuerysetEqual(
+            qs, [
+                (u'Artificial Intelligence: A Modern Approach', 51.5, u'Prentice Hall', u'Peter Norvig'),
+                (u'Practical Django Projects', 29.0, u'Apress', u'James Bennett'),
+                (u'Python Web Development with Django', Approximate(30.333, places=2), u'Prentice Hall', u'Jeffrey Forcier'),
+                (u'Sams Teach Yourself Django in 24 Hours', 45.0, u'Sams', u'Brad Dayley')
+            ],
+            lambda b: (b.name, b.authors__age__avg, b.publisher.name, b.contact.name)
+        )
+        
+        # Regression for #10132 - If the values() clause only mentioned extra
+        # (select=) columns, those columns are used for grouping
+        qs = Book.objects.extra(select={'pub':'publisher_id'}).values('pub').annotate(Count('id')).order_by('pub')
+        self.assertQuerysetEqual(
+            qs, [
+                {'pub': 1, 'id__count': 2},
+                {'pub': 2, 'id__count': 1},
+                {'pub': 3, 'id__count': 2},
+                {'pub': 4, 'id__count': 1}
+            ],
+            lambda b: b
+        )
+        
+        qs = Book.objects.extra(select={'pub':'publisher_id', 'foo':'pages'}).values('pub').annotate(Count('id')).order_by('pub')
+        self.assertQuerysetEqual(
+            qs, [
+                {'pub': 1, 'id__count': 2},
+                {'pub': 2, 'id__count': 1},
+                {'pub': 3, 'id__count': 2},
+                {'pub': 4, 'id__count': 1}
+            ],
+            lambda b: b
+        )
+        
+        # Regression for #10182 - Queries with aggregate calls are correctly
+        # realiased when used in a subquery
+        ids = Book.objects.filter(pages__gt=100).annotate(n_authors=Count('authors')).filter(n_authors__gt=2).order_by('n_authors')
+        self.assertQuerysetEqual(
+            Book.objects.filter(id__in=ids), [
+                "Python Web Development with Django",
+            ],
+            lambda b: b.name
+        )
+    
+    def test_pickle(self):
+        # Regression for #10197 -- Queries with aggregates can be pickled.
+        # First check that pickling is possible at all. No crash = success
+        qs = Book.objects.annotate(num_authors=Count('authors'))
+        out = pickle.dumps(qs)
+
+        # Then check that the round trip works.
+        query = qs.query.get_compiler(qs.db).as_sql()[0]
+        qs2 = pickle.loads(pickle.dumps(qs))
+        self.assertEqual(
+            qs2.query.get_compiler(qs2.db).as_sql()[0],
+            query,
+        )
+    
+    def test_more_more_more(self):
+        # Regression for #10199 - Aggregate calls clone the original query so
+        # the original query can still be used
+        books = Book.objects.all()
+        books.aggregate(Avg("authors__age"))
+        self.assertQuerysetEqual(
+            books.all(), [
+                u'Artificial Intelligence: A Modern Approach',
+                u'Paradigms of Artificial Intelligence Programming: Case Studies in Common Lisp',
+                u'Practical Django Projects',
+                u'Python Web Development with Django',
+                u'Sams Teach Yourself Django in 24 Hours',
+                u'The Definitive Guide to Django: Web Development Done Right'
+            ],
+            lambda b: b.name
+        )
+        
+        # Regression for #10248 - Annotations work with DateQuerySets
+        qs = Book.objects.annotate(num_authors=Count('authors')).filter(num_authors=2).dates('pubdate', 'day')
+        self.assertQuerysetEqual(
+            qs, [
+                datetime.datetime(1995, 1, 15, 0, 0),
+                datetime.datetime(2007, 12, 6, 0, 0)
+            ],
+            lambda b: b
+        )
+        
+        # Regression for #10290 - extra selects with parameters can be used for
+        # grouping.
+        qs = Book.objects.annotate(mean_auth_age=Avg('authors__age')).extra(select={'sheets' : '(pages + %s) / %s'}, select_params=[1, 2]).order_by('sheets').values('sheets')
+        self.assertQuerysetEqual(
+            qs, [
+                150,
+                175,
+                224,
+                264,
+                473,
+                566
+            ],
+            lambda b: int(b["sheets"])
+        )
+        
+        # Regression for 10425 - annotations don't get in the way of a count() 
+        # clause
+        self.assertEqual(
+            Book.objects.values('publisher').annotate(Count('publisher')).count(),
+            4
+        )
+        self.assertEqual(
+            Book.objects.annotate(Count('publisher')).values('publisher').count(),
+            6
+        )
+        
+        publishers = Publisher.objects.filter(id__in=[1, 2])
+        self.assertQuerysetEqual(
+            publishers, [
+                "Apress",
+                "Sams"
+            ],
+            lambda p: p.name
+        )
+        
+        publishers = publishers.annotate(n_books=Count("book"))
+        self.assertEqual(
+            publishers[0].n_books,
+            2
+        )
+        
+        self.assertQuerysetEqual(
+            publishers, [
+                "Apress",
+                "Sams",
+            ],
+            lambda p: p.name
+        )
+        
+        books = Book.objects.filter(publisher__in=publishers)
+        self.assertQuerysetEqual(
+            books, [
+                "Practical Django Projects",
+                "Sams Teach Yourself Django in 24 Hours",
+                "The Definitive Guide to Django: Web Development Done Right",
+            ],
+            lambda b: b.name
+        )
+        self.assertQuerysetEqual(
+            publishers, [
+                "Apress",
+                "Sams",
+            ],
+            lambda p: p.name
+        )
+        
+        # Regression for 10666 - inherited fields work with annotations and 
+        # aggregations
+        self.assertEqual(
+            HardbackBook.objects.aggregate(n_pages=Sum('book_ptr__pages')),
+            {'n_pages': 2078}
+        )
+        
+        self.assertEqual(
+            HardbackBook.objects.aggregate(n_pages=Sum('pages')),
+            {'n_pages': 2078},
+        )
+        
+        qs = HardbackBook.objects.annotate(n_authors=Count('book_ptr__authors')).values('name', 'n_authors')
+        self.assertQuerysetEqual(
+            qs, [
+                {'n_authors': 2, 'name': u'Artificial Intelligence: A Modern Approach'},
+                {'n_authors': 1, 'name': u'Paradigms of Artificial Intelligence Programming: Case Studies in Common Lisp'}
+            ],
+            lambda h: h
+        )
+        
+        qs = HardbackBook.objects.annotate(n_authors=Count('authors')).values('name', 'n_authors')
+        self.assertQuerysetEqual(
+            qs, [
+                {'n_authors': 2, 'name': u'Artificial Intelligence: A Modern Approach'},
+                {'n_authors': 1, 'name': u'Paradigms of Artificial Intelligence Programming: Case Studies in Common Lisp'}
+            ],
+            lambda h: h,
+        )
+        
+        # Regression for #10766 - Shouldn't be able to reference an aggregate
+        # fields in an an aggregate() call.
+        self.assertRaises(
+            FieldError,
+            lambda: Book.objects.annotate(mean_age=Avg('authors__age')).annotate(Avg('mean_age'))
+        )
+    
+    if run_stddev_tests():
+        def test_stddev(self):
+            self.assertEqual(
+                Book.objects.aggregate(StdDev('pages')),
+                {'pages__stddev': 311.46}
+            )
+            
+            self.assertEqual(
+                Book.objects.aggregate(StdDev('rating')),
+                {'rating__stddev': 0.60}
+            )
+            
+            self.assertEqual(
+                Book.objects.aggregate(StdDev('price')),
+                {'price__stddev': 24.16}
+            )
+            
+            self.assertEqual(
+                Book.objects.aggregate(StdDev('pages', sample=True)),
+                {'pages__stddev': 341.19}
+            )
+            
+            self.assertEqual(
+                Book.objects.aggregate(StdDev('rating', sample=True)),
+                {'rating__stddev': 0.66}
+            )
+            
+            self.assertEqual(
+                Book.objects.aggregate(StdDev('price', sample=True)),
+                {'price__stddev': 26.46}
+            )
+            
+            self.assertEqual(
+                Book.objects.aggregate(Variance('pages')),
+                {'pages__variance': 97010.80}
+            )
+            
+            self.assertEqual(
+                Book.objects.aggregate(Variance('rating')),
+                {'rating__variance': 0.36}
+            )
+            
+            self.assertEqual(
+                Book.objects.aggregate(Variance('price')),
+                {'price__variance': 583.77}
+            )
+            
+            self.assertEqual(
+                Book.objects.aggregate(Variance('pages', sample=True)),
+                {'pages__variance': 116412.96}
+            )
+            
+            self.assertEqual(
+                Book.objects.aggregate(Variance('rating', sample=True)),
+                {'rating__variance': 0.44}
+            )
+            
+            self.assertEqual(
+                Book.objects.aggregate(Variance('price', sample=True)),
+                {'price__variance': 700.53}
+            )
