diff --git a/CONTRIBUTING.rst b/CONTRIBUTING.rst
index 1563c25043..4a5887b117 100644
--- a/CONTRIBUTING.rst
+++ b/CONTRIBUTING.rst
@@ -15,7 +15,8 @@ Extensive contribution guidelines are available in the repository at
 
 https://docs.djangoproject.com/en/dev/internals/contributing/
 
-**Warning: pull requests are ignored!** `File a ticket`__ to suggest changes.
+**Warning: non-trivial pull requests (anything more than fixing a typo) without
+Trac tickets will be closed!** `Please file a ticket`__ to suggest changes.
 
 __ https://code.djangoproject.com/newticket
 
diff --git a/README.rst b/README.rst
index ca2cd5e5a9..95029a6fce 100644
--- a/README.rst
+++ b/README.rst
@@ -2,8 +2,8 @@ Django is a high-level Python Web framework that encourages rapid development
 and clean, pragmatic design. Thanks for checking it out.
 
 All documentation is in the "docs" directory and online at
-http://docs.djangoproject.com/en/dev/. If you're just getting started, here's
-how we recommend you read the docs:
+https://docs.djangoproject.com/en/stable/. If you're just getting started,
+here's how we recommend you read the docs:
 
 * First, read docs/intro/install.txt for instructions on installing Django.
 
@@ -19,11 +19,9 @@ how we recommend you read the docs:
 
 * See docs/README for instructions on building an HTML version of the docs.
 
-Docs are updated rigorously. If you find any problems in the docs, or think they
-should be clarified in any way, please take 30 seconds to fill out a ticket
-here:
-
-http://code.djangoproject.com/newticket
+Docs are updated rigorously. If you find any problems in the docs, or think
+they should be clarified in any way, please take 30 seconds to fill out a
+ticket here: https://code.djangoproject.com/newticket
 
 To get more help:
 
@@ -31,11 +29,11 @@ To get more help:
   there. Read the archives at http://django-irc-logs.com/.
 
 * Join the django-users mailing list, or read the archives, at
-  http://groups.google.com/group/django-users.
+  https://groups.google.com/group/django-users.
 
 To contribute to Django:
 
-* Check out http://www.djangoproject.com/community/ for information about
+* Check out https://www.djangoproject.com/community/ for information about
   getting involved.
 
 To run Django's test suite:
diff --git a/django/__init__.py b/django/__init__.py
index 5b4034bfed..14c941601a 100644
--- a/django/__init__.py
+++ b/django/__init__.py
@@ -6,3 +6,16 @@ def get_version(*args, **kwargs):
     # Only import if it's actually called.
     from django.utils.version import get_version
     return get_version(*args, **kwargs)
+
+
+def setup():
+    """
+    Configure the settings (this happens as a side effect of accessing the
+    first setting), configure logging and populate the app registry.
+    """
+    from django.apps import apps
+    from django.conf import settings
+    from django.utils.log import configure_logging
+
+    configure_logging(settings.LOGGING_CONFIG, settings.LOGGING)
+    apps.populate(settings.INSTALLED_APPS)
diff --git a/django/apps/__init__.py b/django/apps/__init__.py
new file mode 100644
index 0000000000..074a448660
--- /dev/null
+++ b/django/apps/__init__.py
@@ -0,0 +1,2 @@
+from .base import AppConfig     # NOQA
+from .registry import apps      # NOQA
diff --git a/django/apps/base.py b/django/apps/base.py
new file mode 100644
index 0000000000..47f0a57711
--- /dev/null
+++ b/django/apps/base.py
@@ -0,0 +1,165 @@
+from importlib import import_module
+
+from django.core.exceptions import ImproperlyConfigured
+from django.utils.module_loading import module_has_submodule
+from django.utils._os import upath
+
+
+MODELS_MODULE_NAME = 'models'
+
+
+class AppConfig(object):
+    """
+    Class representing a Django application and its configuration.
+    """
+
+    def __init__(self, app_name, app_module):
+        # Full Python path to the application eg. 'django.contrib.admin'.
+        self.name = app_name
+
+        # Root module for the application eg. <module 'django.contrib.admin'
+        # from 'django/contrib/admin/__init__.pyc'>.
+        self.module = app_module
+
+        # The following attributes could be defined at the class level in a
+        # subclass, hence the test-and-set pattern.
+
+        # Last component of the Python path to the application eg. 'admin'.
+        # This value must be unique across a Django project.
+        if not hasattr(self, 'label'):
+            self.label = app_name.rpartition(".")[2]
+
+        # Human-readable name for the application eg. "Admin".
+        if not hasattr(self, 'verbose_name'):
+            self.verbose_name = self.label.title()
+
+        # Filesystem path to the application directory eg.
+        # u'/usr/lib/python2.7/dist-packages/django/contrib/admin'. May be
+        # None if the application isn't a bona fide package eg. if it's an
+        # egg. Otherwise it's a unicode on Python 2 and a str on Python 3.
+        if not hasattr(self, 'path'):
+            try:
+                self.path = upath(app_module.__path__[0])
+            except AttributeError:
+                self.path = None
+
+        # Module containing models eg. <module 'django.contrib.admin.models'
+        # from 'django/contrib/admin/models.pyc'>. Set by import_models().
+        # None if the application doesn't have a models module.
+        self.models_module = None
+
+        # Mapping of lower case model names to model classes. Initally set to
+        # None to prevent accidental access before import_models() runs.
+        self.models = None
+
+    def __repr__(self):
+        return '<%s: %s>' % (self.__class__.__name__, self.label)
+
+    @classmethod
+    def create(cls, entry):
+        """
+        Factory that creates an app config from an entry in INSTALLED_APPS.
+        """
+        try:
+            # If import_module succeeds, entry is a path to an app module.
+            # Otherwise, entry is a path to an app config class or an error.
+            module = import_module(entry)
+
+        except ImportError:
+            # Avoid django.utils.module_loading.import_by_path because it
+            # masks errors -- it reraises ImportError as ImproperlyConfigured.
+            mod_path, _, cls_name = entry.rpartition('.')
+
+            # Raise the original exception when entry cannot be a path to an
+            # app config class.
+            if not mod_path:
+                raise
+
+            mod = import_module(mod_path)
+            try:
+                cls = getattr(mod, cls_name)
+            except AttributeError:
+                # Emulate the error that "from <mod_path> import <cls_name>"
+                # would raise when <mod_path> exists but not <cls_name>, with
+                # more context (Python just says "cannot import name ...").
+                raise ImportError(
+                    "cannot import name '%s' from '%s'" % (cls_name, mod_path))
+
+            # Check for obvious errors. (This check prevents duck typing, but
+            # it could be removed if it became a problem in practice.)
+            if not issubclass(cls, AppConfig):
+                raise ImproperlyConfigured(
+                    "'%s' isn't a subclass of AppConfig." % entry)
+
+            # Obtain app name here rather than in AppClass.__init__ to keep
+            # all error checking for entries in INSTALLED_APPS in one place.
+            try:
+                app_name = cls.name
+            except AttributeError:
+                raise ImproperlyConfigured(
+                    "'%s' must supply a name attribute." % entry)
+
+            # Ensure app_names points to a valid module.
+            app_module = import_module(app_name)
+
+            # Entry is a path to an app config class.
+            return cls(app_name, app_module)
+
+        else:
+            # Entry is a path to an app module.
+            return cls(entry, module)
+
+    def get_model(self, model_name):
+        """
+        Returns the model with the given case-insensitive model_name.
+
+        Raises LookupError if no model exists with this name.
+        """
+        if self.models is None:
+            raise LookupError(
+                "App '%s' doesn't have any models." % self.label)
+        try:
+            return self.models[model_name.lower()]
+        except KeyError:
+            raise LookupError(
+                "App '%s' doesn't have a '%s' model." % (self.label, model_name))
+
+    def get_models(self, include_auto_created=False,
+                   include_deferred=False, include_swapped=False):
+        """
+        Returns an iterable of models.
+
+        By default, the following models aren't included:
+
+        - auto-created models for many-to-many relations without
+          an explicit intermediate table,
+        - models created to satisfy deferred attribute queries,
+        - models that have been swapped out.
+
+        Set the corresponding keyword argument to True to include such models.
+        Keyword arguments aren't documented; they're a private API.
+        """
+        for model in self.models.values():
+            if model._deferred and not include_deferred:
+                continue
+            if model._meta.auto_created and not include_auto_created:
+                continue
+            if model._meta.swapped and not include_swapped:
+                continue
+            yield model
+
+    def import_models(self, all_models):
+        # Dictionary of models for this app, primarily maintained in the
+        # 'all_models' attribute of the Apps this AppConfig is attached to.
+        # Injected as a parameter because it gets populated when models are
+        # imported, which might happen before populate() imports models.
+        self.models = all_models
+
+        if module_has_submodule(self.module, MODELS_MODULE_NAME):
+            models_module_name = '%s.%s' % (self.name, MODELS_MODULE_NAME)
+            self.models_module = import_module(models_module_name)
+
+    def ready(self):
+        """
+        Override this method in subclasses to run code when Django starts.
+        """
diff --git a/django/apps/registry.py b/django/apps/registry.py
new file mode 100644
index 0000000000..a0cd5e0abf
--- /dev/null
+++ b/django/apps/registry.py
@@ -0,0 +1,413 @@
+from collections import Counter, defaultdict, OrderedDict
+import os
+import sys
+import warnings
+
+from django.core.exceptions import ImproperlyConfigured
+from django.utils import lru_cache
+from django.utils.module_loading import import_lock
+from django.utils._os import upath
+
+from .base import AppConfig
+
+
+class Apps(object):
+    """
+    A registry that stores the configuration of installed applications.
+
+    It also keeps track of models eg. to provide reverse-relations.
+    """
+
+    def __init__(self, installed_apps=()):
+        # installed_apps is set to None when creating the master registry
+        # because it cannot be populated at that point. Other registries must
+        # provide a list of installed apps and are populated immediately.
+        if installed_apps is None and hasattr(sys.modules[__name__], 'apps'):
+            raise RuntimeError("You must supply an installed_apps argument.")
+
+        # Mapping of app labels => model names => model classes. Every time a
+        # model is imported, ModelBase.__new__ calls apps.register_model which
+        # creates an entry in all_models. All imported models are registered,
+        # regardless of whether they're defined in an installed application
+        # and whether the registry has been populated. Since it isn't possible
+        # to reimport a module safely (it could reexecute initialization code)
+        # all_models is never overridden or reset.
+        self.all_models = defaultdict(OrderedDict)
+
+        # Mapping of labels to AppConfig instances for installed apps.
+        self.app_configs = OrderedDict()
+
+        # Stack of app_configs. Used to store the current state in
+        # set_available_apps and set_installed_apps.
+        self.stored_app_configs = []
+
+        # Whether the registry is populated.
+        self.ready = False
+
+        # Pending lookups for lazy relations.
+        self._pending_lookups = {}
+
+        # Populate apps and models, unless it's the master registry.
+        if installed_apps is not None:
+            self.populate(installed_apps)
+
+    def populate(self, installed_apps=None):
+        """
+        Loads application configurations and models.
+
+        This method imports each application module and then each model module.
+
+        It is thread safe and idempotent, but not reentrant.
+        """
+        if self.ready:
+            return
+        # Since populate() may be a side effect of imports, and since it will
+        # itself import modules, an ABBA deadlock between threads would be
+        # possible if we didn't take the import lock. See #18251.
+        with import_lock():
+            if self.ready:
+                return
+
+            # app_config should be pristine, otherwise the code below won't
+            # guarantee that the order matches the order in INSTALLED_APPS.
+            if self.app_configs:
+                raise RuntimeError("populate() isn't reentrant")
+
+            # Load app configs and app modules.
+            for entry in installed_apps:
+                if isinstance(entry, AppConfig):
+                    app_config = entry
+                else:
+                    app_config = AppConfig.create(entry)
+                if app_config.label in self.app_configs:
+                    raise ImproperlyConfigured(
+                        "Application labels aren't unique, "
+                        "duplicates: %s" % app_config.label)
+
+                self.app_configs[app_config.label] = app_config
+
+            # Check for duplicate app names.
+            counts = Counter(
+                app_config.name for app_config in self.app_configs.values())
+            duplicates = [
+                name for name, count in counts.most_common() if count > 1]
+            if duplicates:
+                raise ImproperlyConfigured(
+                    "Application names aren't unique, "
+                    "duplicates: %s" % ", ".join(duplicates))
+
+            # Load models.
+            for app_config in self.app_configs.values():
+                all_models = self.all_models[app_config.label]
+                app_config.import_models(all_models)
+
+            self.clear_cache()
+            self.ready = True
+
+            for app_config in self.get_app_configs():
+                app_config.ready()
+
+    def check_ready(self):
+        """
+        Raises an exception if the registry isn't ready.
+        """
+        if not self.ready:
+            raise RuntimeError("App registry isn't ready yet.")
+
+    def get_app_configs(self):
+        """
+        Imports applications and returns an iterable of app configs.
+        """
+        self.check_ready()
+        return self.app_configs.values()
+
+    def get_app_config(self, app_label):
+        """
+        Imports applications and returns an app config for the given label.
+
+        Raises LookupError if no application exists with this label.
+        """
+        self.check_ready()
+        try:
+            return self.app_configs[app_label]
+        except KeyError:
+            raise LookupError("No installed app with label '%s'." % app_label)
+
+    # This method is performance-critical at least for Django's test suite.
+    @lru_cache.lru_cache(maxsize=None)
+    def get_models(self, app_mod=None, include_auto_created=False,
+                   include_deferred=False, include_swapped=False):
+        """
+        Returns a list of all installed models.
+
+        By default, the following models aren't included:
+
+        - auto-created models for many-to-many relations without
+          an explicit intermediate table,
+        - models created to satisfy deferred attribute queries,
+        - models that have been swapped out.
+
+        Set the corresponding keyword argument to True to include such models.
+        """
+        self.check_ready()
+        if app_mod:
+            warnings.warn(
+                "The app_mod argument of get_models is deprecated.",
+                PendingDeprecationWarning, stacklevel=2)
+            app_label = app_mod.__name__.split('.')[-2]
+            try:
+                return list(self.get_app_config(app_label).get_models(
+                    include_auto_created, include_deferred, include_swapped))
+            except LookupError:
+                return []
+
+        result = []
+        for app_config in self.app_configs.values():
+            result.extend(list(app_config.get_models(
+                include_auto_created, include_deferred, include_swapped)))
+        return result
+
+    def get_model(self, app_label, model_name):
+        """
+        Returns the model matching the given app_label and model_name.
+
+        model_name is case-insensitive.
+
+        Raises LookupError if no application exists with this label, or no
+        model exists with this name in the application.
+        """
+        self.check_ready()
+        return self.get_app_config(app_label).get_model(model_name.lower())
+
+    def register_model(self, app_label, model):
+        # Since this method is called when models are imported, it cannot
+        # perform imports because of the risk of import loops. It mustn't
+        # call get_app_config().
+        model_name = model._meta.model_name
+        app_models = self.all_models[app_label]
+        if model_name in app_models:
+            raise RuntimeError(
+                "Conflicting '%s' models in application '%s': %s and %s." %
+                (model_name, app_label, app_models[model_name], model))
+        app_models[model_name] = model
+        self.clear_cache()
+
+    def is_installed(self, app_name):
+        """
+        Checks whether an application with this name exists in the registry.
+
+        app_name is the full name of the app eg. 'django.contrib.admin'.
+
+        It's safe to call this method at import time, even while the registry
+        is being populated. It returns False for apps that aren't loaded yet.
+        """
+        app_config = self.app_configs.get(app_name.rpartition(".")[2])
+        return app_config is not None and app_config.name == app_name
+
+    def get_containing_app_config(self, object_name):
+        """
+        Look for an app config containing a given object.
+
+        object_name is the dotted Python path to the object.
+
+        Returns the app config for the inner application in case of nesting.
+        Returns None if the object isn't in any registered app config.
+
+        It's safe to call this method at import time, even while the registry
+        is being populated.
+        """
+        candidates = []
+        for app_config in self.app_configs.values():
+            if object_name.startswith(app_config.name):
+                subpath = object_name[len(app_config.name):]
+                if subpath == '' or subpath[0] == '.':
+                    candidates.append(app_config)
+        if candidates:
+            return sorted(candidates, key=lambda ac: -len(ac.name))[0]
+
+    def get_registered_model(self, app_label, model_name):
+        """
+        Similar to get_model(), but doesn't require that an app exists with
+        the given app_label.
+
+        It's safe to call this method at import time, even while the registry
+        is being populated.
+        """
+        model = self.all_models[app_label].get(model_name.lower())
+        if model is None:
+            raise LookupError(
+                "Model '%s.%s' not registered." % (app_label, model_name))
+        return model
+
+    def set_available_apps(self, available):
+        """
+        Restricts the set of installed apps used by get_app_config[s].
+
+        available must be an iterable of application names.
+
+        set_available_apps() must be balanced with unset_available_apps().
+
+        Primarily used for performance optimization in TransactionTestCase.
+
+        This method is safe is the sense that it doesn't trigger any imports.
+        """
+        available = set(available)
+        installed = set(app_config.name for app_config in self.get_app_configs())
+        if not available.issubset(installed):
+            raise ValueError("Available apps isn't a subset of installed "
+                "apps, extra apps: %s" % ", ".join(available - installed))
+
+        self.stored_app_configs.append(self.app_configs)
+        self.app_configs = OrderedDict(
+            (label, app_config)
+            for label, app_config in self.app_configs.items()
+            if app_config.name in available)
+        self.clear_cache()
+
+    def unset_available_apps(self):
+        """
+        Cancels a previous call to set_available_apps().
+        """
+        self.app_configs = self.stored_app_configs.pop()
+        self.clear_cache()
+
+    def set_installed_apps(self, installed):
+        """
+        Enables a different set of installed apps for get_app_config[s].
+
+        installed must be an iterable in the same format as INSTALLED_APPS.
+
+        set_installed_apps() must be balanced with unset_installed_apps(),
+        even if it exits with an exception.
+
+        Primarily used as a receiver of the setting_changed signal in tests.
+
+        This method may trigger new imports, which may add new models to the
+        registry of all imported models. They will stay in the registry even
+        after unset_installed_apps(). Since it isn't possible to replay
+        imports safely (eg. that could lead to registering listeners twice),
+        models are registered when they're imported and never removed.
+        """
+        self.check_ready()
+        self.stored_app_configs.append(self.app_configs)
+        self.app_configs = OrderedDict()
+        self.ready = False
+        self.clear_cache()
+        self.populate(installed)
+
+    def unset_installed_apps(self):
+        """
+        Cancels a previous call to set_installed_apps().
+        """
+        self.app_configs = self.stored_app_configs.pop()
+        self.ready = True
+        self.clear_cache()
+
+    def clear_cache(self):
+        """
+        Clears all internal caches, for methods that alter the app registry.
+
+        This is mostly used in tests.
+        """
+        self.get_models.cache_clear()
+
+    ### DEPRECATED METHODS GO BELOW THIS LINE ###
+
+    def load_app(self, app_name):
+        """
+        Loads the app with the provided fully qualified name, and returns the
+        model module.
+        """
+        warnings.warn(
+            "load_app(app_name) is deprecated.",
+            PendingDeprecationWarning, stacklevel=2)
+        app_config = AppConfig.create(app_name)
+        app_config.import_models(self.all_models[app_config.label])
+        self.app_configs[app_config.label] = app_config
+        self.clear_cache()
+        return app_config.models_module
+
+    def app_cache_ready(self):
+        warnings.warn(
+            "app_cache_ready() is deprecated in favor of the ready property.",
+            PendingDeprecationWarning, stacklevel=2)
+        return self.ready
+
+    def get_app(self, app_label):
+        """
+        Returns the module containing the models for the given app_label.
+        """
+        warnings.warn(
+            "get_app_config(app_label).models_module supersedes get_app(app_label).",
+            PendingDeprecationWarning, stacklevel=2)
+        try:
+            models_module = self.get_app_config(app_label).models_module
+        except LookupError as exc:
+            # Change the exception type for backwards compatibility.
+            raise ImproperlyConfigured(*exc.args)
+        if models_module is None:
+            raise ImproperlyConfigured(
+                "App '%s' doesn't have a models module." % app_label)
+        return models_module
+
+    def get_apps(self):
+        """
+        Returns a list of all installed modules that contain models.
+        """
+        warnings.warn(
+            "[a.models_module for a in get_app_configs()] supersedes get_apps().",
+            PendingDeprecationWarning, stacklevel=2)
+        app_configs = self.get_app_configs()
+        return [app_config.models_module for app_config in app_configs
+                if app_config.models_module is not None]
+
+    def _get_app_package(self, app):
+        return '.'.join(app.__name__.split('.')[:-1])
+
+    def get_app_package(self, app_label):
+        warnings.warn(
+            "get_app_config(label).name supersedes get_app_package(label).",
+            PendingDeprecationWarning, stacklevel=2)
+        return self._get_app_package(self.get_app(app_label))
+
+    def _get_app_path(self, app):
+        if hasattr(app, '__path__'):        # models/__init__.py package
+            app_path = app.__path__[0]
+        else:                               # models.py module
+            app_path = app.__file__
+        return os.path.dirname(upath(app_path))
+
+    def get_app_path(self, app_label):
+        warnings.warn(
+            "get_app_config(label).path supersedes get_app_path(label).",
+            PendingDeprecationWarning, stacklevel=2)
+        return self._get_app_path(self.get_app(app_label))
+
+    def get_app_paths(self):
+        """
+        Returns a list of paths to all installed apps.
+
+        Useful for discovering files at conventional locations inside apps
+        (static files, templates, etc.)
+        """
+        warnings.warn(
+            "[a.path for a in get_app_configs()] supersedes get_app_paths().",
+            PendingDeprecationWarning, stacklevel=2)
+        self.check_ready()
+        app_paths = []
+        for app in self.get_apps():
+            app_paths.append(self._get_app_path(app))
+        return app_paths
+
+    def register_models(self, app_label, *models):
+        """
+        Register a set of models as belonging to an app.
+        """
+        warnings.warn(
+            "register_models(app_label, *models) is deprecated.",
+            PendingDeprecationWarning, stacklevel=2)
+        for model in models:
+            self.register_model(app_label, model)
+
+
+apps = Apps(installed_apps=None)
diff --git a/django/conf/__init__.py b/django/conf/__init__.py
index ac074d5166..e10d4b1afb 100644
--- a/django/conf/__init__.py
+++ b/django/conf/__init__.py
@@ -7,16 +7,12 @@ a list of all possible variables.
 """
 
 import importlib
-import logging
 import os
-import sys
 import time     # Needed for Windows
-import warnings
 
 from django.conf import global_settings
 from django.core.exceptions import ImproperlyConfigured
 from django.utils.functional import LazyObject, empty
-from django.utils.module_loading import import_by_path
 from django.utils import six
 
 ENVIRONMENT_VARIABLE = "DJANGO_SETTINGS_MODULE"
@@ -44,34 +40,12 @@ class LazySettings(LazyObject):
                 % (desc, ENVIRONMENT_VARIABLE))
 
         self._wrapped = Settings(settings_module)
-        self._configure_logging()
 
     def __getattr__(self, name):
         if self._wrapped is empty:
             self._setup(name)
         return getattr(self._wrapped, name)
 
-    def _configure_logging(self):
-        """
-        Setup logging from LOGGING_CONFIG and LOGGING settings.
-        """
-        if not sys.warnoptions:
-            # Route warnings through python logging
-            logging.captureWarnings(True)
-            # Allow DeprecationWarnings through the warnings filters
-            warnings.simplefilter("default", DeprecationWarning)
-
-        if self.LOGGING_CONFIG:
-            from django.utils.log import DEFAULT_LOGGING
-            # First find the logging configuration function ...
-            logging_config_func = import_by_path(self.LOGGING_CONFIG)
-
-            logging_config_func(DEFAULT_LOGGING)
-
-            # ... then invoke it with the logging settings
-            if self.LOGGING:
-                logging_config_func(self.LOGGING)
-
     def configure(self, default_settings=global_settings, **options):
         """
         Called to manually configure the settings. The 'default_settings'
@@ -84,7 +58,6 @@ class LazySettings(LazyObject):
         for name, value in options.items():
             setattr(holder, name, value)
         self._wrapped = holder
-        self._configure_logging()
 
     @property
     def configured(self):
@@ -104,11 +77,6 @@ class BaseSettings(object):
         elif name == "ALLOWED_INCLUDE_ROOTS" and isinstance(value, six.string_types):
             raise ValueError("The ALLOWED_INCLUDE_ROOTS setting must be set "
                 "to a tuple, not a string.")
-        elif name == "INSTALLED_APPS":
-            value = list(value)  # force evaluation of generators on Python 3
-            if len(value) != len(set(value)):
-                raise ImproperlyConfigured("The INSTALLED_APPS setting must contain unique values.")
-
         object.__setattr__(self, name, value)
 
 
diff --git a/django/conf/global_settings.py b/django/conf/global_settings.py
index d29dd5ec34..d86a4272cd 100644
--- a/django/conf/global_settings.py
+++ b/django/conf/global_settings.py
@@ -290,7 +290,7 @@ MEDIA_URL = ''
 
 # Absolute path to the directory static files should be collected to.
 # Example: "/var/www/example.com/static/"
-STATIC_ROOT = ''
+STATIC_ROOT = None
 
 # URL that handles the static files served from STATIC_ROOT.
 # Example: "http://example.com/static/", "http://static.example.com/"
diff --git a/django/contrib/admin/actions.py b/django/contrib/admin/actions.py
index d215aa6259..158c436c71 100644
--- a/django/contrib/admin/actions.py
+++ b/django/contrib/admin/actions.py
@@ -71,7 +71,6 @@ def delete_selected(modeladmin, request, queryset):
         "perms_lacking": perms_needed,
         "protected": protected,
         "opts": opts,
-        "app_label": app_label,
         'action_checkbox_name': helpers.ACTION_CHECKBOX_NAME,
     }
 
diff --git a/django/contrib/admin/apps.py b/django/contrib/admin/apps.py
new file mode 100644
index 0000000000..980ff0c369
--- /dev/null
+++ b/django/contrib/admin/apps.py
@@ -0,0 +1,8 @@
+from django.apps import AppConfig
+
+from django.utils.translation import ugettext_lazy as _
+
+
+class AdminConfig(AppConfig):
+    name = 'django.contrib.admin'
+    verbose_name = _("administration")
diff --git a/django/contrib/admin/options.py b/django/contrib/admin/options.py
index 4c5adaf0f8..263d1f4a87 100644
--- a/django/contrib/admin/options.py
+++ b/django/contrib/admin/options.py
@@ -46,9 +46,12 @@ from django.views.decorators.csrf import csrf_protect
 IS_POPUP_VAR = '_popup'
 TO_FIELD_VAR = '_to_field'
 
+
 HORIZONTAL, VERTICAL = 1, 2
-# returns the <ul> class for a given radio_admin field
-get_ul_class = lambda x: 'radiolist%s' % (' inline' if x == HORIZONTAL else '')
+
+
+def get_ul_class(radio_style):
+    return 'radiolist' if radio_style == VERTICAL else 'radiolist inline'
 
 
 class IncorrectLookupParameters(Exception):
@@ -1308,7 +1311,6 @@ class ModelAdmin(BaseModelAdmin):
             media=media,
             inline_admin_formsets=inline_admin_formsets,
             errors=helpers.AdminErrorList(form, formsets),
-            app_label=opts.app_label,
             preserved_filters=self.get_preserved_filters(request),
         )
         context.update(extra_context or {})
@@ -1532,7 +1534,6 @@ class ModelAdmin(BaseModelAdmin):
             media=media,
             has_add_permission=self.has_add_permission(request),
             opts=cl.opts,
-            app_label=app_label,
             action_form=action_form,
             actions_on_top=self.actions_on_top,
             actions_on_bottom=self.actions_on_bottom,
@@ -1627,7 +1628,6 @@ class ModelAdmin(BaseModelAdmin):
             action_list=action_list,
             module_name=capfirst(force_text(opts.verbose_name_plural)),
             object=obj,
-            app_label=app_label,
             opts=opts,
             preserved_filters=self.get_preserved_filters(request),
         )
diff --git a/django/contrib/admin/sites.py b/django/contrib/admin/sites.py
index 7b633bef89..8b81f6c68e 100644
--- a/django/contrib/admin/sites.py
+++ b/django/contrib/admin/sites.py
@@ -6,6 +6,7 @@ from django.contrib.auth import logout as auth_logout, REDIRECT_FIELD_NAME
 from django.contrib.contenttypes import views as contenttype_views
 from django.views.decorators.csrf import csrf_protect
 from django.db.models.base import ModelBase
+from django.apps import apps
 from django.core.exceptions import ImproperlyConfigured, PermissionDenied
 from django.core.urlresolvers import reverse, NoReverseMatch
 from django.template.response import TemplateResponse
@@ -156,20 +157,16 @@ class AdminSite(object):
         """
         Check that all things needed to run the admin have been correctly installed.
 
-        The default implementation checks that LogEntry, ContentType and the
-        auth context processor are installed.
+        The default implementation checks that admin and contenttypes apps are
+        installed, as well as the auth context processor.
         """
-        from django.contrib.admin.models import LogEntry
-        from django.contrib.contenttypes.models import ContentType
-
-        if not LogEntry._meta.installed:
+        if not apps.is_installed('django.contrib.admin'):
             raise ImproperlyConfigured("Put 'django.contrib.admin' in your "
                 "INSTALLED_APPS setting in order to use the admin application.")
-        if not ContentType._meta.installed:
+        if not apps.is_installed('django.contrib.contenttypes'):
             raise ImproperlyConfigured("Put 'django.contrib.contenttypes' in "
                 "your INSTALLED_APPS setting in order to use the admin application.")
-        if not ('django.contrib.auth.context_processors.auth' in settings.TEMPLATE_CONTEXT_PROCESSORS or
-                'django.core.context_processors.auth' in settings.TEMPLATE_CONTEXT_PROCESSORS):
+        if 'django.contrib.auth.context_processors.auth' not in settings.TEMPLATE_CONTEXT_PROCESSORS:
             raise ImproperlyConfigured("Put 'django.contrib.auth.context_processors.auth' "
                 "in your TEMPLATE_CONTEXT_PROCESSORS setting in order to use the admin application.")
 
@@ -383,7 +380,7 @@ class AdminSite(object):
                         app_dict[app_label]['models'].append(model_dict)
                     else:
                         app_dict[app_label] = {
-                            'name': app_label.title(),
+                            'name': apps.get_app_config(app_label).verbose_name,
                             'app_label': app_label,
                             'app_url': reverse('admin:app_list', kwargs={'app_label': app_label}, current_app=self.name),
                             'has_module_perms': has_module_perms,
@@ -392,7 +389,7 @@ class AdminSite(object):
 
         # Sort the apps alphabetically.
         app_list = list(six.itervalues(app_dict))
-        app_list.sort(key=lambda x: x['name'])
+        app_list.sort(key=lambda x: x['name'].lower())
 
         # Sort the models alphabetically within each app.
         for app in app_list:
@@ -410,6 +407,7 @@ class AdminSite(object):
 
     def app_index(self, request, app_label, extra_context=None):
         user = request.user
+        app_name = apps.get_app_config(app_label).verbose_name
         has_module_perms = user.has_module_perms(app_label)
         if not has_module_perms:
             raise PermissionDenied
@@ -444,7 +442,7 @@ class AdminSite(object):
                         # something to display, add in the necessary meta
                         # information.
                         app_dict = {
-                            'name': app_label.title(),
+                            'name': app_name,
                             'app_label': app_label,
                             'app_url': '',
                             'has_module_perms': has_module_perms,
@@ -455,7 +453,7 @@ class AdminSite(object):
         # Sort the models alphabetically within each app.
         app_dict['models'].sort(key=lambda x: x['name'])
         context = dict(self.each_context(),
-            title=_('%s administration') % capfirst(app_label),
+            title=_('%(app)s administration') % {'app': app_name},
             app_list=[app_dict],
             app_label=app_label,
         )
diff --git a/django/contrib/admin/templates/admin/auth/user/change_password.html b/django/contrib/admin/templates/admin/auth/user/change_password.html
index 2a1b4d3c90..f37f35c6a3 100644
--- a/django/contrib/admin/templates/admin/auth/user/change_password.html
+++ b/django/contrib/admin/templates/admin/auth/user/change_password.html
@@ -6,12 +6,12 @@
 <script type="text/javascript" src="{% url 'admin:jsi18n' %}"></script>
 {% endblock %}
 {% block extrastyle %}{{ block.super }}<link rel="stylesheet" type="text/css" href="{% static "admin/css/forms.css" %}" />{% endblock %}
-{% block bodyclass %}{{ opts.app_label }}-{{ opts.object_name.lower }} change-form{% endblock %}
+{% block bodyclass %}{{ opts.app_label }}-{{ opts.model_name }} change-form{% endblock %}
 {% if not is_popup %}
 {% block breadcrumbs %}
 <div class="breadcrumbs">
 <a href="{% url 'admin:index' %}">{% trans 'Home' %}</a>
-&rsaquo; <a href="{% url 'admin:app_list' app_label=opts.app_label %}">{{ opts.app_label|capfirst|escape }}</a>
+&rsaquo; <a href="{% url 'admin:app_list' app_label=opts.app_label %}">{{ opts.app_config.verbose_name }}</a>
 &rsaquo; <a href="{% url opts|admin_urlname:'changelist' %}">{{ opts.verbose_name_plural|capfirst }}</a>
 &rsaquo; <a href="{% url opts|admin_urlname:'change' original.pk|admin_urlquote %}">{{ original|truncatewords:"18" }}</a>
 &rsaquo; {% trans 'Change password' %}
diff --git a/django/contrib/admin/templates/admin/change_form.html b/django/contrib/admin/templates/admin/change_form.html
index 79ea73933c..bd71d97f3c 100644
--- a/django/contrib/admin/templates/admin/change_form.html
+++ b/django/contrib/admin/templates/admin/change_form.html
@@ -10,13 +10,13 @@
 
 {% block coltype %}colM{% endblock %}
 
-{% block bodyclass %}app-{{ opts.app_label }} model-{{ opts.object_name.lower }} change-form{% endblock %}
+{% block bodyclass %}app-{{ opts.app_label }} model-{{ opts.model_name }} change-form{% endblock %}
 
 {% if not is_popup %}
 {% block breadcrumbs %}
 <div class="breadcrumbs">
 <a href="{% url 'admin:index' %}">{% trans 'Home' %}</a>
-&rsaquo; <a href="{% url 'admin:app_list' app_label=opts.app_label %}">{{ app_label|capfirst|escape }}</a>
+&rsaquo; <a href="{% url 'admin:app_list' app_label=opts.app_label %}">{{ opts.app_config.verbose_name }}</a>
 &rsaquo; {% if has_change_permission %}<a href="{% url opts|admin_urlname:'changelist' %}">{{ opts.verbose_name_plural|capfirst }}</a>{% else %}{{ opts.verbose_name_plural|capfirst }}{% endif %}
 &rsaquo; {% if add %}{% trans 'Add' %} {{ opts.verbose_name }}{% else %}{{ original|truncatewords:"18" }}{% endif %}
 </div>
diff --git a/django/contrib/admin/templates/admin/change_list.html b/django/contrib/admin/templates/admin/change_list.html
index a5a31f9c67..407b0e0774 100644
--- a/django/contrib/admin/templates/admin/change_list.html
+++ b/django/contrib/admin/templates/admin/change_list.html
@@ -32,13 +32,13 @@
 {% endif %}{% endif %}
 {% endblock %}
 
-{% block bodyclass %}app-{{ opts.app_label }} model-{{ opts.object_name.lower }} change-list{% endblock %}
+{% block bodyclass %}app-{{ opts.app_label }} model-{{ opts.model_name }} change-list{% endblock %}
 
 {% if not is_popup %}
 {% block breadcrumbs %}
 <div class="breadcrumbs">
 <a href="{% url 'admin:index' %}">{% trans 'Home' %}</a>
-&rsaquo; <a href="{% url 'admin:app_list' app_label=cl.opts.app_label %}">{{ app_label|capfirst|escape }}</a>
+&rsaquo; <a href="{% url 'admin:app_list' app_label=cl.opts.app_label %}">{{ cl.opts.app_config.verbose_name }}</a>
 &rsaquo; {{ cl.opts.verbose_name_plural|capfirst }}
 </div>
 {% endblock %}
diff --git a/django/contrib/admin/templates/admin/delete_confirmation.html b/django/contrib/admin/templates/admin/delete_confirmation.html
index 2e94b61485..8e8962ff08 100644
--- a/django/contrib/admin/templates/admin/delete_confirmation.html
+++ b/django/contrib/admin/templates/admin/delete_confirmation.html
@@ -1,12 +1,12 @@
 {% extends "admin/base_site.html" %}
 {% load i18n admin_urls %}
 
-{% block bodyclass %}app-{{ opts.app_label }} model-{{ opts.object_name.lower }} delete-confirmation{% endblock %}
+{% block bodyclass %}app-{{ opts.app_label }} model-{{ opts.model_name }} delete-confirmation{% endblock %}
 
 {% block breadcrumbs %}
 <div class="breadcrumbs">
 <a href="{% url 'admin:index' %}">{% trans 'Home' %}</a>
-&rsaquo; <a href="{% url 'admin:app_list' app_label=opts.app_label %}">{{ app_label|capfirst }}</a>
+&rsaquo; <a href="{% url 'admin:app_list' app_label=opts.app_label %}">{{ opts.app_config.verbose_name }}</a>
 &rsaquo; <a href="{% url opts|admin_urlname:'changelist' %}">{{ opts.verbose_name_plural|capfirst|escape }}</a>
 &rsaquo; <a href="{% url opts|admin_urlname:'change' object.pk|admin_urlquote %}">{{ object|truncatewords:"18" }}</a>
 &rsaquo; {% trans 'Delete' %}
diff --git a/django/contrib/admin/templates/admin/delete_selected_confirmation.html b/django/contrib/admin/templates/admin/delete_selected_confirmation.html
index a80f4e4a54..3013c6a235 100644
--- a/django/contrib/admin/templates/admin/delete_selected_confirmation.html
+++ b/django/contrib/admin/templates/admin/delete_selected_confirmation.html
@@ -1,12 +1,12 @@
 {% extends "admin/base_site.html" %}
 {% load i18n l10n admin_urls %}
 
-{% block bodyclass %}app-{{ opts.app_label }} model-{{ opts.object_name.lower }} delete-confirmation delete-selected-confirmation{% endblock %}
+{% block bodyclass %}app-{{ opts.app_label }} model-{{ opts.model_name }} delete-confirmation delete-selected-confirmation{% endblock %}
 
 {% block breadcrumbs %}
 <div class="breadcrumbs">
 <a href="{% url 'admin:index' %}">{% trans 'Home' %}</a>
-&rsaquo; <a href="{% url 'admin:app_list' app_label=app_label %}">{{ app_label|capfirst|escape }}</a>
+&rsaquo; <a href="{% url 'admin:app_list' app_label=opts.app_label %}">{{ opts.app_config.verbose_name }}</a>
 &rsaquo; <a href="{% url opts|admin_urlname:'changelist' %}">{{ opts.verbose_name_plural|capfirst }}</a>
 &rsaquo; {% trans 'Delete multiple objects' %}
 </div>
diff --git a/django/contrib/admin/templates/admin/object_history.html b/django/contrib/admin/templates/admin/object_history.html
index c750ff14b3..cf3e7e2e0d 100644
--- a/django/contrib/admin/templates/admin/object_history.html
+++ b/django/contrib/admin/templates/admin/object_history.html
@@ -4,7 +4,7 @@
 {% block breadcrumbs %}
 <div class="breadcrumbs">
 <a href="{% url 'admin:index' %}">{% trans 'Home' %}</a>
-&rsaquo; <a href="{% url 'admin:app_list' app_label=app_label %}">{{ app_label|capfirst|escape }}</a>
+&rsaquo; <a href="{% url 'admin:app_list' app_label=opts.app_label %}">{{ opts.app_config.verbose_name }}</a>
 &rsaquo; <a href="{% url opts|admin_urlname:'changelist' %}">{{ module_name }}</a>
 &rsaquo; <a href="{% url opts|admin_urlname:'change' object.pk|admin_urlquote %}">{{ object|truncatewords:"18" }}</a>
 &rsaquo; {% trans 'History' %}
diff --git a/django/contrib/admin/templatetags/admin_list.py b/django/contrib/admin/templatetags/admin_list.py
index 0181f665ad..42ab18007e 100644
--- a/django/contrib/admin/templatetags/admin_list.py
+++ b/django/contrib/admin/templatetags/admin_list.py
@@ -333,7 +333,7 @@ def date_hierarchy(cl):
         month_lookup = cl.params.get(month_field)
         day_lookup = cl.params.get(day_field)
 
-        link = lambda d: cl.get_query_string(d, [field_generic])
+        link = lambda filters: cl.get_query_string(filters, [field_generic])
 
         if not (year_lookup or month_lookup or day_lookup):
             # select appropriate start level
diff --git a/django/contrib/admin/templatetags/admin_static.py b/django/contrib/admin/templatetags/admin_static.py
index 5ea3ba5838..77473c2e00 100644
--- a/django/contrib/admin/templatetags/admin_static.py
+++ b/django/contrib/admin/templatetags/admin_static.py
@@ -1,9 +1,9 @@
-from django.conf import settings
+from django.apps import apps
 from django.template import Library
 
 register = Library()
 
-if 'django.contrib.staticfiles' in settings.INSTALLED_APPS:
+if apps.is_installed('django.contrib.staticfiles'):
     from django.contrib.staticfiles.templatetags.staticfiles import static
 else:
     from django.templatetags.static import static
diff --git a/django/contrib/admin/tests.py b/django/contrib/admin/tests.py
index 248a5798dd..40fd10089b 100644
--- a/django/contrib/admin/tests.py
+++ b/django/contrib/admin/tests.py
@@ -32,7 +32,6 @@ class AdminSeleniumWebDriverTestCase(StaticLiveServerCase):
     @classmethod
     def _tearDownClassInternal(cls):
         if hasattr(cls, 'selenium'):
-            cls.selenium.refresh()  # see ticket #21227
             cls.selenium.quit()
         super(AdminSeleniumWebDriverTestCase, cls)._tearDownClassInternal()
 
@@ -51,8 +50,40 @@ class AdminSeleniumWebDriverTestCase(StaticLiveServerCase):
         Helper function that blocks until the element with the given tag name
         is found on the page.
         """
+        self.wait_for(tag_name, timeout)
+
+    def wait_for(self, css_selector, timeout=10):
+        """
+        Helper function that blocks until an css selector is found on the page.
+        """
+        from selenium.webdriver.common.by import By
+        from selenium.webdriver.support import expected_conditions as ec
         self.wait_until(
-            lambda driver: driver.find_element_by_tag_name(tag_name),
+            ec.presence_of_element_located((By.CSS_SELECTOR, css_selector)),
+            timeout
+        )
+
+    def wait_for_text(self, css_selector, text, timeout=10):
+        """
+        Helper function that blocks until the text is found in the css selector.
+        """
+        from selenium.webdriver.common.by import By
+        from selenium.webdriver.support import expected_conditions as ec
+        self.wait_until(
+            ec.text_to_be_present_in_element(
+                (By.CSS_SELECTOR, css_selector), text),
+            timeout
+        )
+
+    def wait_for_value(self, css_selector, text, timeout=10):
+        """
+        Helper function that blocks until the value is found in the css selector.
+        """
+        from selenium.webdriver.common.by import By
+        from selenium.webdriver.support import expected_conditions as ec
+        self.wait_until(
+            ec.text_to_be_present_in_element_value(
+                (By.CSS_SELECTOR, css_selector), text),
             timeout
         )
 
diff --git a/django/contrib/admin/validation.py b/django/contrib/admin/validation.py
index a15967e024..784bee6f8b 100644
--- a/django/contrib/admin/validation.py
+++ b/django/contrib/admin/validation.py
@@ -1,4 +1,3 @@
-from django.core.apps import app_cache
 from django.core.exceptions import ImproperlyConfigured
 from django.db import models
 from django.db.models.fields import FieldDoesNotExist
@@ -15,10 +14,6 @@ __all__ = ['BaseValidator', 'InlineValidator']
 
 
 class BaseValidator(object):
-    def __init__(self):
-        # Before we can introspect models, they need the app cache to be fully
-        # loaded so that inter-relations are set up correctly.
-        app_cache.populate()
 
     def validate(self, cls, model):
         for m in dir(self):
diff --git a/django/contrib/admindocs/apps.py b/django/contrib/admindocs/apps.py
new file mode 100644
index 0000000000..ddc23051f4
--- /dev/null
+++ b/django/contrib/admindocs/apps.py
@@ -0,0 +1,8 @@
+from django.apps import AppConfig
+
+from django.utils.translation import ugettext_lazy as _
+
+
+class AdminDocsConfig(AppConfig):
+    name = 'django.contrib.admindocs'
+    verbose_name = _("administrative documentation")
diff --git a/django/contrib/admindocs/templates/admin_doc/model_index.html b/django/contrib/admindocs/templates/admin_doc/model_index.html
index d4cde8334f..f48f80dd9f 100644
--- a/django/contrib/admindocs/templates/admin_doc/model_index.html
+++ b/django/contrib/admindocs/templates/admin_doc/model_index.html
@@ -27,7 +27,7 @@
 <table class="xfull">
 {% for model in group.list %}
 <tr>
-<th><a href="{% url 'django-admindocs-models-detail' app_label=model.app_label model_name=model.object_name.lower %}">{{ model.object_name }}</a></th>
+<th><a href="{% url 'django-admindocs-models-detail' app_label=model.app_label model_name=model.model_name %}">{{ model.object_name }}</a></th>
 </tr>
 {% endfor %}
 </table>
diff --git a/django/contrib/admindocs/views.py b/django/contrib/admindocs/views.py
index 9e6dd85595..7afb11ef34 100644
--- a/django/contrib/admindocs/views.py
+++ b/django/contrib/admindocs/views.py
@@ -5,10 +5,10 @@ import re
 import warnings
 
 from django import template
+from django.apps import apps
 from django.conf import settings
 from django.contrib import admin
 from django.contrib.admin.views.decorators import staff_member_required
-from django.core.apps import app_cache
 from django.db import models
 from django.core.exceptions import ViewDoesNotExist
 from django.http import Http404
@@ -174,7 +174,7 @@ class ModelIndexView(BaseAdminDocsView):
     template_name = 'admin_doc/model_index.html'
 
     def get_context_data(self, **kwargs):
-        m_list = [m._meta for m in app_cache.get_models()]
+        m_list = [m._meta for m in apps.get_models()]
         kwargs.update({'models': m_list})
         return super(ModelIndexView, self).get_context_data(**kwargs)
 
@@ -185,11 +185,12 @@ class ModelDetailView(BaseAdminDocsView):
     def get_context_data(self, **kwargs):
         # Get the model class.
         try:
-            app_cache.get_app_config(self.kwargs['app_label'])
+            apps.get_app_config(self.kwargs['app_label'])
         except LookupError:
             raise Http404(_("App %(app_label)r not found") % self.kwargs)
-        model = app_cache.get_model(self.kwargs['app_label'], self.kwargs['model_name'])
-        if model is None:
+        try:
+            model = apps.get_model(self.kwargs['app_label'], self.kwargs['model_name'])
+        except LookupError:
             raise Http404(_("Model %(model_name)r not found in app %(app_label)r") % self.kwargs)
 
         opts = model._meta
diff --git a/django/contrib/auth/__init__.py b/django/contrib/auth/__init__.py
index d5fc14dd2a..f2bcaba390 100644
--- a/django/contrib/auth/__init__.py
+++ b/django/contrib/auth/__init__.py
@@ -123,14 +123,15 @@ def get_user_model():
     """
     Returns the User model that is active in this project.
     """
-    from django.core.apps import app_cache
+    from django.apps import apps
 
     try:
         app_label, model_name = settings.AUTH_USER_MODEL.split('.')
     except ValueError:
         raise ImproperlyConfigured("AUTH_USER_MODEL must be of the form 'app_label.model_name'")
-    user_model = app_cache.get_model(app_label, model_name)
-    if user_model is None:
+    try:
+        user_model = apps.get_model(app_label, model_name)
+    except LookupError:
         raise ImproperlyConfigured("AUTH_USER_MODEL refers to model '%s' that has not been installed" % settings.AUTH_USER_MODEL)
     return user_model
 
diff --git a/django/contrib/auth/apps.py b/django/contrib/auth/apps.py
new file mode 100644
index 0000000000..e44ad1a0c7
--- /dev/null
+++ b/django/contrib/auth/apps.py
@@ -0,0 +1,8 @@
+from django.apps import AppConfig
+
+from django.utils.translation import ugettext_lazy as _
+
+
+class AuthConfig(AppConfig):
+    name = 'django.contrib.auth'
+    verbose_name = _("authentication and authorization")
diff --git a/django/contrib/auth/forms.py b/django/contrib/auth/forms.py
index e3c139a5fd..459a42febb 100644
--- a/django/contrib/auth/forms.py
+++ b/django/contrib/auth/forms.py
@@ -21,7 +21,11 @@ from django.contrib.sites.models import get_current_site
 
 UNMASKED_DIGITS_TO_SHOW = 6
 
-mask_password = lambda p: "%s%s" % (p[:UNMASKED_DIGITS_TO_SHOW], "*" * max(len(p) - UNMASKED_DIGITS_TO_SHOW, 0))
+
+def mask_password(password):
+    shown = password[:UNMASKED_DIGITS_TO_SHOW]
+    masked = "*" * max(len(password) - UNMASKED_DIGITS_TO_SHOW, 0)
+    return shown + masked
 
 
 class ReadOnlyPasswordHashWidget(forms.Widget):
diff --git a/django/contrib/auth/management/__init__.py b/django/contrib/auth/management/__init__.py
index ec963becc4..e801b15eb1 100644
--- a/django/contrib/auth/management/__init__.py
+++ b/django/contrib/auth/management/__init__.py
@@ -6,9 +6,9 @@ from __future__ import unicode_literals
 import getpass
 import unicodedata
 
+from django.apps import apps
 from django.contrib.auth import (models as auth_app, get_permission_codename,
     get_user_model)
-from django.core.apps import app_cache, UnavailableApp
 from django.core import exceptions
 from django.core.management.base import CommandError
 from django.db import DEFAULT_DB_ALIAS, router
@@ -60,25 +60,26 @@ def _check_permission_clashing(custom, builtin, ctype):
         pool.add(codename)
 
 
-def create_permissions(app, created_models, verbosity, db=DEFAULT_DB_ALIAS, **kwargs):
-    try:
-        app_cache.get_model('auth', 'Permission')
-    except UnavailableApp:
+def create_permissions(app_config, verbosity=2, interactive=True, db=DEFAULT_DB_ALIAS, **kwargs):
+    if not app_config.models_module:
         return
 
-    if not router.allow_migrate(db, auth_app.Permission):
+    try:
+        Permission = apps.get_model('auth', 'Permission')
+    except LookupError:
+        return
+
+    if not router.allow_migrate(db, Permission):
         return
 
     from django.contrib.contenttypes.models import ContentType
 
-    app_models = app_cache.get_models(app)
-
     # This will hold the permissions we're looking for as
     # (content_type, (codename, name))
     searched_perms = list()
     # The codenames and ctypes that should exist.
     ctypes = set()
-    for klass in app_models:
+    for klass in app_config.get_models():
         # Force looking up the content types in the current database
         # before creating foreign keys to them.
         ctype = ContentType.objects.db_manager(db).get_for_model(klass)
@@ -89,20 +90,20 @@ def create_permissions(app, created_models, verbosity, db=DEFAULT_DB_ALIAS, **kw
     # Find all the Permissions that have a content_type for a model we're
     # looking for.  We don't need to check for codenames since we already have
     # a list of the ones we're going to create.
-    all_perms = set(auth_app.Permission.objects.using(db).filter(
+    all_perms = set(Permission.objects.using(db).filter(
         content_type__in=ctypes,
     ).values_list(
         "content_type", "codename"
     ))
 
     perms = [
-        auth_app.Permission(codename=codename, name=name, content_type=ctype)
+        Permission(codename=codename, name=name, content_type=ctype)
         for ctype, (codename, name) in searched_perms
         if (ctype.pk, codename) not in all_perms
     ]
     # Validate the permissions before bulk_creation to avoid cryptic
     # database error when the verbose_name is longer than 50 characters
-    permission_name_max_length = auth_app.Permission._meta.get_field('name').max_length
+    permission_name_max_length = Permission._meta.get_field('name').max_length
     verbose_name_max_length = permission_name_max_length - 11  # len('Can change ') prefix
     for perm in perms:
         if len(perm.name) > permission_name_max_length:
@@ -112,23 +113,24 @@ def create_permissions(app, created_models, verbosity, db=DEFAULT_DB_ALIAS, **kw
                     verbose_name_max_length,
                 )
             )
-    auth_app.Permission.objects.using(db).bulk_create(perms)
+    Permission.objects.using(db).bulk_create(perms)
     if verbosity >= 2:
         for perm in perms:
             print("Adding permission '%s'" % perm)
 
 
-def create_superuser(app, created_models, verbosity, db, **kwargs):
+def create_superuser(app_config, verbosity=2, interactive=True, db=DEFAULT_DB_ALIAS, **kwargs):
     try:
-        app_cache.get_model('auth', 'Permission')
-        UserModel = get_user_model()
-    except UnavailableApp:
+        apps.get_model('auth', 'Permission')
+    except LookupError:
         return
 
+    UserModel = get_user_model()
+
     from django.core.management import call_command
 
-    if UserModel in created_models and kwargs.get('interactive', True):
-        msg = ("\nYou just installed Django's auth system, which means you "
+    if not UserModel.objects.exists() and interactive:
+        msg = ("\nYou have installed Django's auth system, and "
             "don't have any superusers defined.\nWould you like to create one "
             "now? (yes/no): ")
         confirm = input(msg)
@@ -202,7 +204,9 @@ def get_default_username(check_db=True):
             return ''
     return default_username
 
+
 signals.post_migrate.connect(create_permissions,
     dispatch_uid="django.contrib.auth.management.create_permissions")
 signals.post_migrate.connect(create_superuser,
-    sender=auth_app, dispatch_uid="django.contrib.auth.management.create_superuser")
+    sender=apps.get_app_config('auth'),
+    dispatch_uid="django.contrib.auth.management.create_superuser")
diff --git a/django/contrib/auth/management/commands/changepassword.py b/django/contrib/auth/management/commands/changepassword.py
index 32a5373fb0..e333cafb04 100644
--- a/django/contrib/auth/management/commands/changepassword.py
+++ b/django/contrib/auth/management/commands/changepassword.py
@@ -1,3 +1,5 @@
+from __future__ import unicode_literals
+
 import getpass
 from optparse import make_option
 
diff --git a/django/contrib/auth/tests/test_auth_backends.py b/django/contrib/auth/tests/test_auth_backends.py
index 757ad290a7..4331b8496c 100644
--- a/django/contrib/auth/tests/test_auth_backends.py
+++ b/django/contrib/auth/tests/test_auth_backends.py
@@ -10,8 +10,7 @@ from django.contrib.contenttypes.models import ContentType
 from django.core.exceptions import ImproperlyConfigured, PermissionDenied
 from django.contrib.auth import authenticate, get_user
 from django.http import HttpRequest
-from django.test import TestCase
-from django.test.utils import override_settings
+from django.test import TestCase, override_settings
 from django.contrib.auth.hashers import MD5PasswordHasher
 
 
diff --git a/django/contrib/auth/tests/test_basic.py b/django/contrib/auth/tests/test_basic.py
index 34b6142632..0bcd2c47c2 100644
--- a/django/contrib/auth/tests/test_basic.py
+++ b/django/contrib/auth/tests/test_basic.py
@@ -3,6 +3,7 @@ from __future__ import unicode_literals
 
 import locale
 
+from django.apps import apps
 from django.contrib.auth import get_user_model
 from django.contrib.auth.management.commands import createsuperuser
 from django.contrib.auth.models import User, AnonymousUser
@@ -11,9 +12,8 @@ from django.contrib.auth.tests.utils import skipIfCustomUser
 from django.core.exceptions import ImproperlyConfigured
 from django.core.management import call_command
 from django.dispatch import receiver
-from django.test import TestCase
+from django.test import TestCase, override_settings
 from django.test.signals import setting_changed
-from django.test.utils import override_settings
 from django.utils import translation
 from django.utils.encoding import force_str
 from django.utils.six import binary_type, PY2, StringIO
@@ -26,6 +26,7 @@ def user_model_swapped(**kwargs):
         # Reset User manager
         setattr(User, 'objects', User._default_manager)
         ensure_default_manager(User)
+        apps.clear_cache()
 
 
 def mock_inputs(inputs):
diff --git a/django/contrib/auth/tests/test_context_processors.py b/django/contrib/auth/tests/test_context_processors.py
index bf30790a8a..48c5b77f20 100644
--- a/django/contrib/auth/tests/test_context_processors.py
+++ b/django/contrib/auth/tests/test_context_processors.py
@@ -7,8 +7,7 @@ from django.contrib.auth.models import User, Permission
 from django.contrib.contenttypes.models import ContentType
 from django.contrib.auth.context_processors import PermWrapper, PermLookupDict
 from django.db.models import Q
-from django.test import TestCase
-from django.test.utils import override_settings
+from django.test import TestCase, override_settings
 from django.utils._os import upath
 
 
diff --git a/django/contrib/auth/tests/test_forms.py b/django/contrib/auth/tests/test_forms.py
index 41cb3350b1..837db709a5 100644
--- a/django/contrib/auth/tests/test_forms.py
+++ b/django/contrib/auth/tests/test_forms.py
@@ -12,8 +12,7 @@ from django.contrib.auth.forms import (UserCreationForm, AuthenticationForm,
 from django.contrib.auth.tests.utils import skipIfCustomUser
 from django.core import mail
 from django.forms.fields import Field, CharField
-from django.test import TestCase
-from django.test.utils import override_settings
+from django.test import TestCase, override_settings
 from django.utils.encoding import force_text
 from django.utils._os import upath
 from django.utils import translation
diff --git a/django/contrib/auth/tests/test_handlers.py b/django/contrib/auth/tests/test_handlers.py
index b86775fc28..f041bd54e1 100644
--- a/django/contrib/auth/tests/test_handlers.py
+++ b/django/contrib/auth/tests/test_handlers.py
@@ -5,7 +5,7 @@ from django.contrib.auth.models import User, Group
 from django.contrib.auth.tests.custom_user import CustomUser
 from django.contrib.auth.tests.utils import skipIfCustomUser
 from django.test import TransactionTestCase
-from django.test.utils import override_settings
+from django.test import override_settings
 
 
 # This must be a TransactionTestCase because the WSGI auth handler performs
diff --git a/django/contrib/auth/tests/test_management.py b/django/contrib/auth/tests/test_management.py
index d9de5a2ad0..8a591fc7a9 100644
--- a/django/contrib/auth/tests/test_management.py
+++ b/django/contrib/auth/tests/test_management.py
@@ -1,6 +1,7 @@
 from __future__ import unicode_literals
 from datetime import date
 
+from django.apps import apps
 from django.contrib.auth import models, management
 from django.contrib.auth.management import create_permissions
 from django.contrib.auth.management.commands import changepassword
@@ -8,13 +9,11 @@ from django.contrib.auth.models import User
 from django.contrib.auth.tests.custom_user import CustomUser
 from django.contrib.auth.tests.utils import skipIfCustomUser
 from django.contrib.contenttypes.models import ContentType
-from django.core.apps import app_cache
 from django.core import exceptions
 from django.core.management import call_command
 from django.core.management.base import CommandError
 from django.core.management.validation import get_validation_errors
-from django.test import TestCase
-from django.test.utils import override_settings
+from django.test import TestCase, override_settings
 from django.utils import six
 from django.utils.six import StringIO
 
@@ -83,6 +82,19 @@ class ChangepasswordManagementCommandTestCase(TestCase):
         with self.assertRaises(CommandError):
             command.execute("joe", stdout=self.stdout, stderr=self.stderr)
 
+    def test_that_changepassword_command_works_with_nonascii_output(self):
+        """
+        #21627 -- Executing the changepassword management command should allow
+        non-ASCII characters from the User object representation.
+        """
+        # 'Julia' with accented 'u':
+        models.User.objects.create_user(username='J\xfalia', password='qwerty')
+
+        command = changepassword.Command()
+        command._get_pass = lambda *args: 'not qwerty'
+
+        command.execute("J\xfalia", stdout=self.stdout)
+
 
 @skipIfCustomUser
 class CreatesuperuserManagementCommandTestCase(TestCase):
@@ -184,21 +196,21 @@ class CustomUserModelValidationTestCase(TestCase):
     def test_required_fields_is_list(self):
         "REQUIRED_FIELDS should be a list."
         new_io = StringIO()
-        get_validation_errors(new_io, app_cache.get_app_config('auth').models_module)
+        get_validation_errors(new_io, apps.get_app_config('auth'))
         self.assertIn("The REQUIRED_FIELDS must be a list or tuple.", new_io.getvalue())
 
     @override_settings(AUTH_USER_MODEL='auth.CustomUserBadRequiredFields')
     def test_username_not_in_required_fields(self):
         "USERNAME_FIELD should not appear in REQUIRED_FIELDS."
         new_io = StringIO()
-        get_validation_errors(new_io, app_cache.get_app_config('auth').models_module)
+        get_validation_errors(new_io, apps.get_app_config('auth'))
         self.assertIn("The field named as the USERNAME_FIELD should not be included in REQUIRED_FIELDS on a swappable User model.", new_io.getvalue())
 
     @override_settings(AUTH_USER_MODEL='auth.CustomUserNonUniqueUsername')
     def test_username_non_unique(self):
         "A non-unique USERNAME_FIELD should raise a model validation error."
         new_io = StringIO()
-        get_validation_errors(new_io, app_cache.get_app_config('auth').models_module)
+        get_validation_errors(new_io, apps.get_app_config('auth'))
         self.assertIn("The USERNAME_FIELD must be unique. Add unique=True to the field parameters.", new_io.getvalue())
 
 
@@ -220,13 +232,15 @@ class PermissionTestCase(TestCase):
         Test that we show proper error message if we are trying to create
         duplicate permissions.
         """
+        auth_app_config = apps.get_app_config('auth')
+
         # check duplicated default permission
         models.Permission._meta.permissions = [
             ('change_permission', 'Can edit permission (duplicate)')]
         six.assertRaisesRegex(self, CommandError,
             "The permission codename 'change_permission' clashes with a "
             "builtin permission for model 'auth.Permission'.",
-            create_permissions, models, [], verbosity=0)
+            create_permissions, auth_app_config, verbosity=0)
 
         # check duplicated custom permissions
         models.Permission._meta.permissions = [
@@ -237,21 +251,23 @@ class PermissionTestCase(TestCase):
         six.assertRaisesRegex(self, CommandError,
             "The permission codename 'my_custom_permission' is duplicated for model "
             "'auth.Permission'.",
-            create_permissions, models, [], verbosity=0)
+            create_permissions, auth_app_config, verbosity=0)
 
         # should not raise anything
         models.Permission._meta.permissions = [
             ('my_custom_permission', 'Some permission'),
             ('other_one', 'Some other permission'),
         ]
-        create_permissions(models, [], verbosity=0)
+        create_permissions(auth_app_config, verbosity=0)
 
     def test_default_permissions(self):
+        auth_app_config = apps.get_app_config('auth')
+
         permission_content_type = ContentType.objects.get_by_natural_key('auth', 'permission')
         models.Permission._meta.permissions = [
             ('my_custom_permission', 'Some permission'),
         ]
-        create_permissions(models, [], verbosity=0)
+        create_permissions(auth_app_config, verbosity=0)
 
         # add/change/delete permission by default + custom permission
         self.assertEqual(models.Permission.objects.filter(
@@ -260,7 +276,7 @@ class PermissionTestCase(TestCase):
 
         models.Permission.objects.filter(content_type=permission_content_type).delete()
         models.Permission._meta.default_permissions = []
-        create_permissions(models, [], verbosity=0)
+        create_permissions(auth_app_config, verbosity=0)
 
         # custom permission only since default permissions is empty
         self.assertEqual(models.Permission.objects.filter(
@@ -268,10 +284,12 @@ class PermissionTestCase(TestCase):
         ).count(), 1)
 
     def test_verbose_name_length(self):
+        auth_app_config = apps.get_app_config('auth')
+
         permission_content_type = ContentType.objects.get_by_natural_key('auth', 'permission')
         models.Permission.objects.filter(content_type=permission_content_type).delete()
         models.Permission._meta.verbose_name = "some ridiculously long verbose name that is out of control"
 
         six.assertRaisesRegex(self, exceptions.ValidationError,
             "The verbose_name of permission is longer than 39 characters",
-            create_permissions, models, [], verbosity=0)
+            create_permissions, auth_app_config, verbosity=0)
diff --git a/django/contrib/auth/tests/test_models.py b/django/contrib/auth/tests/test_models.py
index a858bb2566..9e2c653738 100644
--- a/django/contrib/auth/tests/test_models.py
+++ b/django/contrib/auth/tests/test_models.py
@@ -3,8 +3,7 @@ from django.contrib.auth.models import AbstractUser, Group, User, UserManager
 from django.contrib.auth.tests.utils import skipIfCustomUser
 from django.core import mail
 from django.db.models.signals import post_save
-from django.test import TestCase
-from django.test.utils import override_settings
+from django.test import TestCase, override_settings
 
 
 @skipIfCustomUser
diff --git a/django/contrib/auth/tests/test_signals.py b/django/contrib/auth/tests/test_signals.py
index 024f44f547..81266807c9 100644
--- a/django/contrib/auth/tests/test_signals.py
+++ b/django/contrib/auth/tests/test_signals.py
@@ -3,7 +3,7 @@ from django.contrib.auth.models import User
 from django.contrib.auth.tests.utils import skipIfCustomUser
 from django.test import TestCase
 from django.test.client import RequestFactory
-from django.test.utils import override_settings
+from django.test import override_settings
 
 
 @skipIfCustomUser
diff --git a/django/contrib/auth/tests/test_templates.py b/django/contrib/auth/tests/test_templates.py
index f7d74748a2..1d1a8b49a8 100644
--- a/django/contrib/auth/tests/test_templates.py
+++ b/django/contrib/auth/tests/test_templates.py
@@ -7,7 +7,7 @@ from django.contrib.auth.views import (
     password_reset_complete, password_change, password_change_done,
 )
 from django.test import RequestFactory, TestCase
-from django.test.utils import override_settings
+from django.test import override_settings
 from django.utils.encoding import force_bytes, force_text
 from django.utils.http import urlsafe_base64_encode
 
diff --git a/django/contrib/auth/tests/test_views.py b/django/contrib/auth/tests/test_views.py
index 4a1783b14d..6d841c287e 100644
--- a/django/contrib/auth/tests/test_views.py
+++ b/django/contrib/auth/tests/test_views.py
@@ -14,8 +14,8 @@ from django.utils.encoding import force_text
 from django.utils.http import urlquote
 from django.utils.six.moves.urllib.parse import urlparse, ParseResult
 from django.utils._os import upath
-from django.test import TestCase
-from django.test.utils import override_settings, patch_logger
+from django.test import TestCase, override_settings
+from django.test.utils import patch_logger
 from django.middleware.csrf import CsrfViewMiddleware
 from django.contrib.sessions.middleware import SessionMiddleware
 
diff --git a/django/contrib/comments/__init__.py b/django/contrib/comments/__init__.py
index 56ed32bafe..19dd7ef9a1 100644
--- a/django/contrib/comments/__init__.py
+++ b/django/contrib/comments/__init__.py
@@ -1,5 +1,6 @@
 from importlib import import_module
 import warnings
+from django.apps import apps
 from django.conf import settings
 from django.core import urlresolvers
 from django.core.exceptions import ImproperlyConfigured
@@ -14,20 +15,12 @@ def get_comment_app():
     """
     Get the comment app (i.e. "django.contrib.comments") as defined in the settings
     """
-    # Make sure the app's in INSTALLED_APPS
-    comments_app = get_comment_app_name()
-    if comments_app not in settings.INSTALLED_APPS:
-        raise ImproperlyConfigured("The COMMENTS_APP (%r) "\
-                                   "must be in INSTALLED_APPS" % settings.COMMENTS_APP)
-
-    # Try to import the package
     try:
-        package = import_module(comments_app)
-    except ImportError as e:
-        raise ImproperlyConfigured("The COMMENTS_APP setting refers to "\
-                                   "a non-existing package. (%s)" % e)
-
-    return package
+        app_config = apps.get_app_config(get_comment_app_name().rpartition(".")[2])
+    except LookupError:
+        raise ImproperlyConfigured("The COMMENTS_APP (%r) "
+                                   "must be in INSTALLED_APPS" % settings.COMMENTS_APP)
+    return app_config.module
 
 def get_comment_app_name():
     """
diff --git a/django/contrib/comments/apps.py b/django/contrib/comments/apps.py
new file mode 100644
index 0000000000..d6164dd697
--- /dev/null
+++ b/django/contrib/comments/apps.py
@@ -0,0 +1,8 @@
+from django.apps import AppConfig
+
+from django.utils.translation import ugettext_lazy as _
+
+
+class CommentsConfig(AppConfig):
+    name = 'django.contrib.comments'
+    verbose_name = _("comments")
diff --git a/django/contrib/comments/views/comments.py b/django/contrib/comments/views/comments.py
index 294c7c8e42..165f2b6574 100644
--- a/django/contrib/comments/views/comments.py
+++ b/django/contrib/comments/views/comments.py
@@ -1,9 +1,9 @@
 from django import http
+from django.apps import apps
 from django.conf import settings
 from django.contrib import comments
 from django.contrib.comments import signals
 from django.contrib.comments.views.utils import next_redirect, confirmation_view
-from django.core.apps import app_cache
 from django.core.exceptions import ObjectDoesNotExist, ValidationError
 from django.db import models
 from django.shortcuts import render_to_response
@@ -49,12 +49,12 @@ def post_comment(request, next=None, using=None):
     if ctype is None or object_pk is None:
         return CommentPostBadRequest("Missing content_type or object_pk field.")
     try:
-        model = app_cache.get_model(*ctype.split(".", 1))
+        model = apps.get_model(*ctype.split(".", 1))
         target = model._default_manager.using(using).get(pk=object_pk)
     except TypeError:
         return CommentPostBadRequest(
             "Invalid content_type value: %r" % escape(ctype))
-    except AttributeError:
+    except LookupError:
         return CommentPostBadRequest(
             "The given content-type %r does not resolve to a valid model." % \
                 escape(ctype))
diff --git a/django/contrib/contenttypes/apps.py b/django/contrib/contenttypes/apps.py
new file mode 100644
index 0000000000..0e55e8d66d
--- /dev/null
+++ b/django/contrib/contenttypes/apps.py
@@ -0,0 +1,8 @@
+from django.apps import AppConfig
+
+from django.utils.translation import ugettext_lazy as _
+
+
+class ContentTypesConfig(AppConfig):
+    name = 'django.contrib.contenttypes'
+    verbose_name = _("content types")
diff --git a/django/contrib/contenttypes/management.py b/django/contrib/contenttypes/management.py
index 7ff08b70f8..58f7da820e 100644
--- a/django/contrib/contenttypes/management.py
+++ b/django/contrib/contenttypes/management.py
@@ -1,5 +1,4 @@
-from django.contrib.contenttypes.models import ContentType
-from django.core.apps import app_cache, UnavailableApp
+from django.apps import apps
 from django.db import DEFAULT_DB_ALIAS, router
 from django.db.models import signals
 from django.utils.encoding import smart_text
@@ -7,29 +6,32 @@ from django.utils import six
 from django.utils.six.moves import input
 
 
-def update_contenttypes(app, created_models, verbosity=2, db=DEFAULT_DB_ALIAS, **kwargs):
+def update_contenttypes(app_config, verbosity=2, interactive=True, db=DEFAULT_DB_ALIAS, **kwargs):
     """
     Creates content types for models in the given app, removing any model
     entries that no longer have a matching model class.
     """
+    if not app_config.models_module:
+        return
+
     try:
-        app_cache.get_model('contenttypes', 'ContentType')
-    except UnavailableApp:
+        ContentType = apps.get_model('contenttypes', 'ContentType')
+    except LookupError:
         return
 
     if not router.allow_migrate(db, ContentType):
         return
 
     ContentType.objects.clear_cache()
-    app_models = app_cache.get_models(app)
-    if not app_models:
-        return
-    # They all have the same app_label, get the first one.
-    app_label = app_models[0]._meta.app_label
+
+    app_label = app_config.label
+
     app_models = dict(
         (model._meta.model_name, model)
-        for model in app_models
-    )
+        for model in app_config.get_models())
+
+    if not app_models:
+        return
 
     # Get all the content types
     content_types = dict(
@@ -85,11 +87,13 @@ If you're unsure, answer 'no'.
                 print("Stale content types remain.")
 
 
-def update_all_contenttypes(verbosity=2, **kwargs):
-    for app_config in app_cache.get_app_configs(only_with_models_module=True):
-        update_contenttypes(app_config.models_module, None, verbosity, **kwargs)
+def update_all_contenttypes(**kwargs):
+    for app_config in apps.get_app_configs():
+        update_contenttypes(app_config, **kwargs)
+
 
 signals.post_migrate.connect(update_contenttypes)
 
+
 if __name__ == "__main__":
     update_all_contenttypes()
diff --git a/django/contrib/contenttypes/models.py b/django/contrib/contenttypes/models.py
index 98eae0219c..0dc048cfa2 100644
--- a/django/contrib/contenttypes/models.py
+++ b/django/contrib/contenttypes/models.py
@@ -1,4 +1,4 @@
-from django.core.apps import app_cache
+from django.apps import apps
 from django.db import models
 from django.utils.translation import ugettext_lazy as _
 from django.utils.encoding import smart_text, force_text
@@ -157,8 +157,10 @@ class ContentType(models.Model):
 
     def model_class(self):
         "Returns the Python model class for this type of content."
-        return app_cache.get_model(self.app_label, self.model,
-                                only_installed=False)
+        try:
+            return apps.get_model(self.app_label, self.model)
+        except LookupError:
+            return None
 
     def get_object_for_this_type(self, **kwargs):
         """
diff --git a/django/contrib/contenttypes/tests.py b/django/contrib/contenttypes/tests.py
index 756430f393..2943a83095 100644
--- a/django/contrib/contenttypes/tests.py
+++ b/django/contrib/contenttypes/tests.py
@@ -1,12 +1,11 @@
 from __future__ import unicode_literals
 
-from django.db import models
 from django.contrib.contenttypes.models import ContentType
 from django.contrib.contenttypes.views import shortcut
-from django.contrib.sites.models import Site, get_current_site
+from django.contrib.sites.models import get_current_site
+from django.db import models
 from django.http import HttpRequest, Http404
-from django.test import TestCase
-from django.test.utils import override_settings
+from django.test import TestCase, override_settings
 from django.utils.http import urlquote
 from django.utils import six
 from django.utils.encoding import python_2_unicode_compatible
@@ -54,11 +53,9 @@ class FooWithBrokenAbsoluteUrl(FooWithoutUrl):
 class ContentTypesTests(TestCase):
 
     def setUp(self):
-        self._old_installed = Site._meta.app_config.installed
         ContentType.objects.clear_cache()
 
     def tearDown(self):
-        Site._meta.app_config.installed = self._old_installed
         ContentType.objects.clear_cache()
 
     def test_lookup_cache(self):
@@ -223,15 +220,15 @@ class ContentTypesTests(TestCase):
         user_ct = ContentType.objects.get_for_model(FooWithUrl)
         obj = FooWithUrl.objects.create(name="john")
 
-        Site._meta.app_config.installed = True
-        response = shortcut(request, user_ct.id, obj.id)
-        self.assertEqual("http://%s/users/john/" % get_current_site(request).domain,
-                         response._headers.get("location")[1])
+        with self.modify_settings(INSTALLED_APPS={'append': 'django.contrib.sites'}):
+            response = shortcut(request, user_ct.id, obj.id)
+            self.assertEqual("http://%s/users/john/" % get_current_site(request).domain,
+                             response._headers.get("location")[1])
 
-        Site._meta.app_config.installed = False
-        response = shortcut(request, user_ct.id, obj.id)
-        self.assertEqual("http://Example.com/users/john/",
-                         response._headers.get("location")[1])
+        with self.modify_settings(INSTALLED_APPS={'remove': 'django.contrib.sites'}):
+            response = shortcut(request, user_ct.id, obj.id)
+            self.assertEqual("http://Example.com/users/john/",
+                             response._headers.get("location")[1])
 
     def test_shortcut_view_without_get_absolute_url(self):
         """
diff --git a/django/contrib/flatpages/apps.py b/django/contrib/flatpages/apps.py
new file mode 100644
index 0000000000..67be36ebc5
--- /dev/null
+++ b/django/contrib/flatpages/apps.py
@@ -0,0 +1,8 @@
+from django.apps import AppConfig
+
+from django.utils.translation import ugettext_lazy as _
+
+
+class FlatPagesConfig(AppConfig):
+    name = 'django.contrib.flatpages'
+    verbose_name = _("flat pages")
diff --git a/django/contrib/flatpages/tests/test_csrf.py b/django/contrib/flatpages/tests/test_csrf.py
index 4506433195..23c03a1e13 100644
--- a/django/contrib/flatpages/tests/test_csrf.py
+++ b/django/contrib/flatpages/tests/test_csrf.py
@@ -2,7 +2,7 @@ import os
 from django.contrib.auth.models import User
 from django.contrib.auth.tests.utils import skipIfCustomUser
 from django.test import TestCase, Client
-from django.test.utils import override_settings
+from django.test import override_settings
 
 
 @override_settings(
diff --git a/django/contrib/flatpages/tests/test_forms.py b/django/contrib/flatpages/tests/test_forms.py
index a216b37c67..8a6db742fa 100644
--- a/django/contrib/flatpages/tests/test_forms.py
+++ b/django/contrib/flatpages/tests/test_forms.py
@@ -3,8 +3,7 @@ from __future__ import unicode_literals
 from django.conf import settings
 from django.contrib.flatpages.forms import FlatpageForm
 from django.contrib.flatpages.models import FlatPage
-from django.test import TestCase
-from django.test.utils import override_settings
+from django.test import TestCase, override_settings
 from django.utils import translation
 
 
diff --git a/django/contrib/flatpages/tests/test_middleware.py b/django/contrib/flatpages/tests/test_middleware.py
index dd1a0192ce..47d29bdb00 100644
--- a/django/contrib/flatpages/tests/test_middleware.py
+++ b/django/contrib/flatpages/tests/test_middleware.py
@@ -3,8 +3,7 @@ from django.conf import settings
 from django.contrib.auth.models import User
 from django.contrib.auth.tests.utils import skipIfCustomUser
 from django.contrib.flatpages.models import FlatPage
-from django.test import TestCase
-from django.test.utils import override_settings
+from django.test import TestCase, override_settings
 
 
 @override_settings(
diff --git a/django/contrib/flatpages/tests/test_templatetags.py b/django/contrib/flatpages/tests/test_templatetags.py
index 39ae734c8c..025c73c2cf 100644
--- a/django/contrib/flatpages/tests/test_templatetags.py
+++ b/django/contrib/flatpages/tests/test_templatetags.py
@@ -2,8 +2,7 @@ import os
 from django.contrib.auth.models import AnonymousUser, User
 from django.contrib.auth.tests.utils import skipIfCustomUser
 from django.template import Template, Context, TemplateSyntaxError
-from django.test import TestCase
-from django.test.utils import override_settings
+from django.test import TestCase, override_settings
 
 
 @override_settings(
diff --git a/django/contrib/flatpages/tests/test_views.py b/django/contrib/flatpages/tests/test_views.py
index 056641e301..d2683fbbf4 100644
--- a/django/contrib/flatpages/tests/test_views.py
+++ b/django/contrib/flatpages/tests/test_views.py
@@ -3,8 +3,7 @@ from django.conf import settings
 from django.contrib.auth.models import User
 from django.contrib.auth.tests.utils import skipIfCustomUser
 from django.contrib.flatpages.models import FlatPage
-from django.test import TestCase
-from django.test.utils import override_settings
+from django.test import TestCase, override_settings
 
 
 @override_settings(
diff --git a/django/contrib/formtools/apps.py b/django/contrib/formtools/apps.py
new file mode 100644
index 0000000000..335b685bad
--- /dev/null
+++ b/django/contrib/formtools/apps.py
@@ -0,0 +1,8 @@
+from django.apps import AppConfig
+
+from django.utils.translation import ugettext_lazy as _
+
+
+class FormToolsConfig(AppConfig):
+    name = 'django.contrib.formtools'
+    verbose_name = _("form tools")
diff --git a/django/contrib/formtools/tests/tests.py b/django/contrib/formtools/tests/tests.py
index 84b0c7e2d0..59939a1ecd 100644
--- a/django/contrib/formtools/tests/tests.py
+++ b/django/contrib/formtools/tests/tests.py
@@ -8,8 +8,7 @@ import warnings
 
 from django import http
 from django.contrib.formtools import preview, utils
-from django.test import TestCase
-from django.test.utils import override_settings
+from django.test import TestCase, override_settings
 from django.utils._os import upath
 
 from django.contrib.formtools.tests.forms import (
diff --git a/django/contrib/gis/apps.py b/django/contrib/gis/apps.py
new file mode 100644
index 0000000000..225efb8bb5
--- /dev/null
+++ b/django/contrib/gis/apps.py
@@ -0,0 +1,8 @@
+from django.apps import AppConfig
+
+from django.utils.translation import ugettext_lazy as _
+
+
+class GISConfig(AppConfig):
+    name = 'django.contrib.gis'
+    verbose_name = _("GIS")
diff --git a/django/contrib/gis/db/backends/postgis/creation.py b/django/contrib/gis/db/backends/postgis/creation.py
index 4f64ecce29..51ac197b8e 100644
--- a/django/contrib/gis/db/backends/postgis/creation.py
+++ b/django/contrib/gis/db/backends/postgis/creation.py
@@ -89,7 +89,7 @@ class PostGISCreation(DatabaseCreation):
             self.connection.close()
             self.connection.settings_dict["NAME"] = test_database_name
             cursor = self.connection.cursor()
-            cursor.execute("CREATE EXTENSION postgis")
+            cursor.execute("CREATE EXTENSION IF NOT EXISTS postgis")
             cursor.connection.commit()
 
         return test_database_name
diff --git a/django/contrib/gis/geos/__init__.py b/django/contrib/gis/geos/__init__.py
index 70b73fad8b..d5fe479dae 100644
--- a/django/contrib/gis/geos/__init__.py
+++ b/django/contrib/gis/geos/__init__.py
@@ -6,9 +6,9 @@ for more details:
 __all__ = ['HAS_GEOS']
 
 try:
-    from .libgeos import geos_version, geos_version_info, GEOS_PREPARE  # NOQA: flake8 detects only the last __all__
+    from .libgeos import geos_version, geos_version_info  # NOQA: flake8 detects only the last __all__
     HAS_GEOS = True
-    __all__ += ['geos_version', 'geos_version_info', 'GEOS_PREPARE']
+    __all__ += ['geos_version', 'geos_version_info']
 except ImportError:
     HAS_GEOS = False
 
diff --git a/django/contrib/gis/geos/collections.py b/django/contrib/gis/geos/collections.py
index 426cf3833d..483cb6f405 100644
--- a/django/contrib/gis/geos/collections.py
+++ b/django/contrib/gis/geos/collections.py
@@ -3,9 +3,8 @@
  GeometryCollection, MultiPoint, MultiLineString, and MultiPolygon
 """
 from ctypes import c_int, c_uint, byref
-from django.contrib.gis.geos.error import GEOSException
 from django.contrib.gis.geos.geometry import GEOSGeometry
-from django.contrib.gis.geos.libgeos import get_pointer_arr, GEOS_PREPARE
+from django.contrib.gis.geos.libgeos import get_pointer_arr
 from django.contrib.gis.geos.linestring import LineString, LinearRing
 from django.contrib.gis.geos.point import Point
 from django.contrib.gis.geos.polygon import Polygon
@@ -119,10 +118,7 @@ class MultiPolygon(GeometryCollection):
     @property
     def cascaded_union(self):
         "Returns a cascaded union of this MultiPolygon."
-        if GEOS_PREPARE:
-            return GEOSGeometry(capi.geos_cascaded_union(self.ptr), self.srid)
-        else:
-            raise GEOSException('The cascaded union operation requires GEOS 3.1+.')
+        return GEOSGeometry(capi.geos_cascaded_union(self.ptr), self.srid)
 
 # Setting the allowed types here since GeometryCollection is defined before
 # its subclasses.
diff --git a/django/contrib/gis/geos/geometry.py b/django/contrib/gis/geos/geometry.py
index 073415abea..f453f113f7 100644
--- a/django/contrib/gis/geos/geometry.py
+++ b/django/contrib/gis/geos/geometry.py
@@ -17,7 +17,7 @@ from django.contrib.gis.gdal.error import SRSException
 from django.contrib.gis.geos.base import GEOSBase, gdal
 from django.contrib.gis.geos.coordseq import GEOSCoordSeq
 from django.contrib.gis.geos.error import GEOSException, GEOSIndexError
-from django.contrib.gis.geos.libgeos import GEOM_PTR, GEOS_PREPARE
+from django.contrib.gis.geos.libgeos import GEOM_PTR
 
 # All other functions in this module come from the ctypes
 # prototypes module -- which handles all interaction with
@@ -289,8 +289,6 @@ class GEOSGeometry(GEOSBase, ListMixin):
         """
         Returns a string containing the reason for any invalidity.
         """
-        if not GEOS_PREPARE:
-            raise GEOSException('Upgrade GEOS to 3.1 to get validity reason.')
         return capi.geos_isvalidreason(self.ptr).decode()
 
     #### Binary predicates. ####
@@ -411,9 +409,6 @@ class GEOSGeometry(GEOSBase, ListMixin):
         extension of the WKB specification that includes SRID value that are
         a part of this geometry.
         """
-        if self.hasz and not GEOS_PREPARE:
-            # See: http://trac.osgeo.org/geos/ticket/216
-            raise GEOSException('Upgrade GEOS to 3.1 to get valid 3D HEXEWKB.')
         return ewkb_w(3 if self.hasz else 2).write_hex(self)
 
     @property
@@ -443,9 +438,6 @@ class GEOSGeometry(GEOSBase, ListMixin):
         This is an extension of the WKB specification that includes any SRID
         value that are a part of this geometry.
         """
-        if self.hasz and not GEOS_PREPARE:
-            # See: http://trac.osgeo.org/geos/ticket/216
-            raise GEOSException('Upgrade GEOS to 3.1 to get valid 3D EWKB.')
         return ewkb_w(3 if self.hasz else 2).write(self)
 
     @property
@@ -460,10 +452,7 @@ class GEOSGeometry(GEOSBase, ListMixin):
         Returns a PreparedGeometry corresponding to this geometry -- it is
         optimized for the contains, intersects, and covers operations.
         """
-        if GEOS_PREPARE:
-            return PreparedGeometry(self)
-        else:
-            raise GEOSException('GEOS 3.1+ required for prepared geometry support.')
+        return PreparedGeometry(self)
 
     #### GDAL-specific output routines ####
     @property
@@ -707,16 +696,14 @@ from django.contrib.gis.geos.linestring import LineString, LinearRing
 from django.contrib.gis.geos.point import Point
 from django.contrib.gis.geos.polygon import Polygon
 from django.contrib.gis.geos.collections import GeometryCollection, MultiPoint, MultiLineString, MultiPolygon
-GEOS_CLASSES = {0: Point,
-                1: LineString,
-                2: LinearRing,
-                3: Polygon,
-                4: MultiPoint,
-                5: MultiLineString,
-                6: MultiPolygon,
-                7: GeometryCollection,
-                }
-
-# If supported, import the PreparedGeometry class.
-if GEOS_PREPARE:
-    from django.contrib.gis.geos.prepared import PreparedGeometry
+from django.contrib.gis.geos.prepared import PreparedGeometry
+GEOS_CLASSES = {
+    0: Point,
+    1: LineString,
+    2: LinearRing,
+    3: Polygon,
+    4: MultiPoint,
+    5: MultiLineString,
+    6: MultiPolygon,
+    7: GeometryCollection,
+}
diff --git a/django/contrib/gis/geos/libgeos.py b/django/contrib/gis/geos/libgeos.py
index 239067a433..5be05cee50 100644
--- a/django/contrib/gis/geos/libgeos.py
+++ b/django/contrib/gis/geos/libgeos.py
@@ -155,22 +155,10 @@ GEOS_MINOR_VERSION = int(_verinfo['minor'])
 GEOS_SUBMINOR_VERSION = int(_verinfo['subminor'])
 del _verinfo
 GEOS_VERSION = (GEOS_MAJOR_VERSION, GEOS_MINOR_VERSION, GEOS_SUBMINOR_VERSION)
-GEOS_PREPARE = GEOS_VERSION >= (3, 1, 0)
 
-if GEOS_PREPARE:
-    # Here we set up the prototypes for the initGEOS_r and finishGEOS_r
-    # routines.  These functions aren't actually called until they are
-    # attached to a GEOS context handle -- this actually occurs in
-    # geos/prototypes/threadsafe.py.
-    lgeos.initGEOS_r.restype = CONTEXT_PTR
-    lgeos.finishGEOS_r.argtypes = [CONTEXT_PTR]
-else:
-    # When thread-safety isn't available, the initGEOS routine must be called
-    # first.  This function takes the notice and error functions, defined
-    # as Python callbacks above, as parameters. Here is the C code that is
-    # wrapped:
-    #  extern void GEOS_DLL initGEOS(GEOSMessageHandler notice_function, GEOSMessageHandler error_function);
-    lgeos.initGEOS(notice_h, error_h)
-    # Calling finishGEOS() upon exit of the interpreter.
-    import atexit
-    atexit.register(lgeos.finishGEOS)
+# Here we set up the prototypes for the initGEOS_r and finishGEOS_r
+# routines.  These functions aren't actually called until they are
+# attached to a GEOS context handle -- this actually occurs in
+# geos/prototypes/threadsafe.py.
+lgeos.initGEOS_r.restype = CONTEXT_PTR
+lgeos.finishGEOS_r.argtypes = [CONTEXT_PTR]
diff --git a/django/contrib/gis/geos/prepared.py b/django/contrib/gis/geos/prepared.py
index a6a205da5e..5458264f19 100644
--- a/django/contrib/gis/geos/prepared.py
+++ b/django/contrib/gis/geos/prepared.py
@@ -1,6 +1,8 @@
-from django.contrib.gis.geos.base import GEOSBase
-from django.contrib.gis.geos.geometry import GEOSGeometry
-from django.contrib.gis.geos.prototypes import prepared as capi
+from .base import GEOSBase
+from .error import GEOSException
+from .geometry import GEOSGeometry
+from .libgeos import geos_version_info
+from .prototypes import prepared as capi
 
 
 class PreparedGeometry(GEOSBase):
@@ -12,6 +14,10 @@ class PreparedGeometry(GEOSBase):
     ptr_type = capi.PREPGEOM_PTR
 
     def __init__(self, geom):
+        # Keeping a reference to the original geometry object to prevent it
+        # from being garbage collected which could then crash the prepared one
+        # See #21662
+        self._base_geom = geom
         if not isinstance(geom, GEOSGeometry):
             raise TypeError
         self.ptr = capi.geos_prepare(geom.ptr)
@@ -31,3 +37,30 @@ class PreparedGeometry(GEOSBase):
 
     def intersects(self, other):
         return capi.prepared_intersects(self.ptr, other.ptr)
+
+    # Added in GEOS 3.3:
+
+    def crosses(self, other):
+        if geos_version_info()['version'] < '3.3.0':
+            raise GEOSException("crosses on prepared geometries requires GEOS >= 3.3.0")
+        return capi.prepared_crosses(self.ptr, other.ptr)
+
+    def disjoint(self, other):
+        if geos_version_info()['version'] < '3.3.0':
+            raise GEOSException("disjoint on prepared geometries requires GEOS >= 3.3.0")
+        return capi.prepared_disjoint(self.ptr, other.ptr)
+
+    def overlaps(self, other):
+        if geos_version_info()['version'] < '3.3.0':
+            raise GEOSException("overlaps on prepared geometries requires GEOS >= 3.3.0")
+        return capi.prepared_overlaps(self.ptr, other.ptr)
+
+    def touches(self, other):
+        if geos_version_info()['version'] < '3.3.0':
+            raise GEOSException("touches on prepared geometries requires GEOS >= 3.3.0")
+        return capi.prepared_touches(self.ptr, other.ptr)
+
+    def within(self, other):
+        if geos_version_info()['version'] < '3.3.0':
+            raise GEOSException("within on prepared geometries requires GEOS >= 3.3.0")
+        return capi.prepared_within(self.ptr, other.ptr)
diff --git a/django/contrib/gis/geos/prototypes/misc.py b/django/contrib/gis/geos/prototypes/misc.py
index 6b10396aba..a8bb3cbd58 100644
--- a/django/contrib/gis/geos/prototypes/misc.py
+++ b/django/contrib/gis/geos/prototypes/misc.py
@@ -3,13 +3,13 @@
  ones that return the area, distance, and length.
 """
 from ctypes import c_int, c_double, POINTER
-from django.contrib.gis.geos.libgeos import GEOM_PTR, GEOS_PREPARE
+from django.contrib.gis.geos.libgeos import GEOM_PTR
 from django.contrib.gis.geos.prototypes.errcheck import check_dbl, check_string
 from django.contrib.gis.geos.prototypes.geom import geos_char_p
 from django.contrib.gis.geos.prototypes.threadsafe import GEOSFunc
 from django.utils.six.moves import xrange
 
-__all__ = ['geos_area', 'geos_distance', 'geos_length']
+__all__ = ['geos_area', 'geos_distance', 'geos_length', 'geos_isvalidreason']
 
 
 ### ctypes generator function ###
@@ -31,11 +31,7 @@ def dbl_from_geom(func, num_geom=1):
 geos_area = dbl_from_geom(GEOSFunc('GEOSArea'))
 geos_distance = dbl_from_geom(GEOSFunc('GEOSDistance'), num_geom=2)
 geos_length = dbl_from_geom(GEOSFunc('GEOSLength'))
-
-# Validity reason; only in GEOS 3.1+
-if GEOS_PREPARE:
-    geos_isvalidreason = GEOSFunc('GEOSisValidReason')
-    geos_isvalidreason.argtypes = [GEOM_PTR]
-    geos_isvalidreason.restype = geos_char_p
-    geos_isvalidreason.errcheck = check_string
-    __all__.append('geos_isvalidreason')
+geos_isvalidreason = GEOSFunc('GEOSisValidReason')
+geos_isvalidreason.argtypes = [GEOM_PTR]
+geos_isvalidreason.restype = geos_char_p
+geos_isvalidreason.errcheck = check_string
diff --git a/django/contrib/gis/geos/prototypes/prepared.py b/django/contrib/gis/geos/prototypes/prepared.py
index eef141a2f7..ced56395b0 100644
--- a/django/contrib/gis/geos/prototypes/prepared.py
+++ b/django/contrib/gis/geos/prototypes/prepared.py
@@ -1,5 +1,5 @@
 from ctypes import c_char
-from django.contrib.gis.geos.libgeos import GEOM_PTR, PREPGEOM_PTR
+from django.contrib.gis.geos.libgeos import GEOM_PTR, PREPGEOM_PTR, geos_version_info
 from django.contrib.gis.geos.prototypes.errcheck import check_predicate
 from django.contrib.gis.geos.prototypes.threadsafe import GEOSFunc
 
@@ -24,3 +24,10 @@ prepared_contains = prepared_predicate(GEOSFunc('GEOSPreparedContains'))
 prepared_contains_properly = prepared_predicate(GEOSFunc('GEOSPreparedContainsProperly'))
 prepared_covers = prepared_predicate(GEOSFunc('GEOSPreparedCovers'))
 prepared_intersects = prepared_predicate(GEOSFunc('GEOSPreparedIntersects'))
+
+if geos_version_info()['version'] > '3.3.0':
+    prepared_crosses = prepared_predicate(GEOSFunc('GEOSPreparedCrosses'))
+    prepared_disjoint = prepared_predicate(GEOSFunc('GEOSPreparedDisjoint'))
+    prepared_overlaps = prepared_predicate(GEOSFunc('GEOSPreparedOverlaps'))
+    prepared_touches = prepared_predicate(GEOSFunc('GEOSPreparedTouches'))
+    prepared_within = prepared_predicate(GEOSFunc('GEOSPreparedWithin'))
diff --git a/django/contrib/gis/geos/prototypes/topology.py b/django/contrib/gis/geos/prototypes/topology.py
index 5bc99e8409..60db46ec14 100644
--- a/django/contrib/gis/geos/prototypes/topology.py
+++ b/django/contrib/gis/geos/prototypes/topology.py
@@ -2,13 +2,14 @@
  This module houses the GEOS ctypes prototype functions for the
  topological operations on geometries.
 """
-__all__ = ['geos_boundary', 'geos_buffer', 'geos_centroid', 'geos_convexhull',
-           'geos_difference', 'geos_envelope', 'geos_intersection',
-           'geos_linemerge', 'geos_pointonsurface', 'geos_preservesimplify',
-           'geos_simplify', 'geos_symdifference', 'geos_union', 'geos_relate']
+__all__ = ['geos_boundary', 'geos_buffer', 'geos_cascaded_union',
+           'geos_centroid', 'geos_convexhull', 'geos_difference',
+           'geos_envelope', 'geos_intersection', 'geos_linemerge',
+           'geos_pointonsurface', 'geos_preservesimplify', 'geos_simplify',
+           'geos_symdifference', 'geos_union', 'geos_relate']
 
 from ctypes import c_double, c_int
-from django.contrib.gis.geos.libgeos import geos_version_info, GEOM_PTR, GEOS_PREPARE
+from django.contrib.gis.geos.libgeos import geos_version_info, GEOM_PTR
 from django.contrib.gis.geos.prototypes.errcheck import check_geom, check_minus_one, check_string
 from django.contrib.gis.geos.prototypes.geom import geos_char_p
 from django.contrib.gis.geos.prototypes.threadsafe import GEOSFunc
@@ -39,19 +40,16 @@ geos_simplify = topology(GEOSFunc('GEOSSimplify'), c_double)
 geos_symdifference = topology(GEOSFunc('GEOSSymDifference'), GEOM_PTR)
 geos_union = topology(GEOSFunc('GEOSUnion'), GEOM_PTR)
 
+geos_cascaded_union = GEOSFunc('GEOSUnionCascaded')
+geos_cascaded_union.argtypes = [GEOM_PTR]
+geos_cascaded_union.restype = GEOM_PTR
+
 # GEOSRelate returns a string, not a geometry.
 geos_relate = GEOSFunc('GEOSRelate')
 geos_relate.argtypes = [GEOM_PTR, GEOM_PTR]
 geos_relate.restype = geos_char_p
 geos_relate.errcheck = check_string
 
-# Routines only in GEOS 3.1+
-if GEOS_PREPARE:
-    geos_cascaded_union = GEOSFunc('GEOSUnionCascaded')
-    geos_cascaded_union.argtypes = [GEOM_PTR]
-    geos_cascaded_union.restype = GEOM_PTR
-    __all__.append('geos_cascaded_union')
-
 # Linear referencing routines
 info = geos_version_info()
 if info['version'] >= '3.2.0':
diff --git a/django/contrib/gis/geos/tests/test_geos.py b/django/contrib/gis/geos/tests/test_geos.py
index 3f0ce0652b..4c38c9bfcb 100644
--- a/django/contrib/gis/geos/tests/test_geos.py
+++ b/django/contrib/gis/geos/tests/test_geos.py
@@ -22,8 +22,7 @@ from .. import HAS_GEOS
 if HAS_GEOS:
     from .. import (GEOSException, GEOSIndexError, GEOSGeometry,
         GeometryCollection, Point, MultiPoint, Polygon, MultiPolygon, LinearRing,
-        LineString, MultiLineString, fromfile, fromstr, geos_version_info,
-        GEOS_PREPARE)
+        LineString, MultiLineString, fromfile, fromstr, geos_version_info)
     from ..base import gdal, numpy, GEOSBase
 
 
@@ -121,20 +120,12 @@ class GEOSTest(unittest.TestCase, TestDataMixin):
         # a bug in versions prior to 3.1 that puts the X coordinate in
         # place of Z; an exception should be raised on those versions.
         self.assertEqual(hexewkb_2d, pnt_2d.hexewkb)
-        if GEOS_PREPARE:
-            self.assertEqual(hexewkb_3d, pnt_3d.hexewkb)
-            self.assertEqual(True, GEOSGeometry(hexewkb_3d).hasz)
-        else:
-            with self.assertRaises(GEOSException):
-                pnt_3d.hexewkb
+        self.assertEqual(hexewkb_3d, pnt_3d.hexewkb)
+        self.assertEqual(True, GEOSGeometry(hexewkb_3d).hasz)
 
         # Same for EWKB.
         self.assertEqual(memoryview(a2b_hex(hexewkb_2d)), pnt_2d.ewkb)
-        if GEOS_PREPARE:
-            self.assertEqual(memoryview(a2b_hex(hexewkb_3d)), pnt_3d.ewkb)
-        else:
-            with self.assertRaises(GEOSException):
-                pnt_3d.ewkb
+        self.assertEqual(memoryview(a2b_hex(hexewkb_3d)), pnt_3d.ewkb)
 
         # Redundant sanity check.
         self.assertEqual(4326, GEOSGeometry(hexewkb_2d).srid)
@@ -869,10 +860,9 @@ class GEOSTest(unittest.TestCase, TestDataMixin):
         self.assertIsInstance(g1.ogr, gdal.OGRGeometry)
         self.assertIsNone(g1.srs)
 
-        if GEOS_PREPARE:
-            g1_3d = fromstr('POINT(5 23 8)')
-            self.assertIsInstance(g1_3d.ogr, gdal.OGRGeometry)
-            self.assertEqual(g1_3d.ogr.z, 8)
+        g1_3d = fromstr('POINT(5 23 8)')
+        self.assertIsInstance(g1_3d.ogr, gdal.OGRGeometry)
+        self.assertEqual(g1_3d.ogr.z, 8)
 
         g2 = fromstr('LINESTRING(0 0, 5 5, 23 23)', srid=4326)
         self.assertIsInstance(g2.ogr, gdal.OGRGeometry)
@@ -918,10 +908,7 @@ class GEOSTest(unittest.TestCase, TestDataMixin):
     def test_transform_3d(self):
         p3d = GEOSGeometry('POINT (5 23 100)', 4326)
         p3d.transform(2774)
-        if GEOS_PREPARE:
-            self.assertEqual(p3d.z, 100)
-        else:
-            self.assertIsNone(p3d.z)
+        self.assertEqual(p3d.z, 100)
 
     @skipUnless(HAS_GDAL, "GDAL is required.")
     def test_transform_noop(self):
@@ -1030,7 +1017,6 @@ class GEOSTest(unittest.TestCase, TestDataMixin):
                 if not no_srid:
                     self.assertEqual(geom.srid, tmpg.srid)
 
-    @skipUnless(HAS_GEOS and GEOS_PREPARE, "geos >= 3.1.0 is required")
     def test_prepared(self):
         "Testing PreparedGeometry support."
         # Creating a simple multipolygon and getting a prepared version.
@@ -1046,6 +1032,20 @@ class GEOSTest(unittest.TestCase, TestDataMixin):
             self.assertEqual(mpoly.intersects(pnt), prep.intersects(pnt))
             self.assertEqual(c, prep.covers(pnt))
 
+        if geos_version_info()['version'] > '3.3.0':
+            self.assertTrue(prep.crosses(fromstr('LINESTRING(1 1, 15 15)')))
+            self.assertTrue(prep.disjoint(Point(-5, -5)))
+            poly = Polygon(((-1, -1), (1, 1), (1, 0), (-1, -1)))
+            self.assertTrue(prep.overlaps(poly))
+            poly = Polygon(((-5, 0), (-5, 5), (0, 5), (-5, 0)))
+            self.assertTrue(prep.touches(poly))
+            poly = Polygon(((-1, -1), (-1, 11), (11, 11), (11, -1), (-1, -1)))
+            self.assertTrue(prep.within(poly))
+
+        # Original geometry deletion should not crash the prepared one (#21662)
+        del mpoly
+        self.assertTrue(prep.covers(Point(5, 5)))
+
     def test_line_merge(self):
         "Testing line merge support"
         ref_geoms = (fromstr('LINESTRING(1 1, 1 1, 3 3)'),
@@ -1057,7 +1057,6 @@ class GEOSTest(unittest.TestCase, TestDataMixin):
         for geom, merged in zip(ref_geoms, ref_merged):
             self.assertEqual(merged, geom.merged)
 
-    @skipUnless(HAS_GEOS and GEOS_PREPARE, "geos >= 3.1.0 is required")
     def test_valid_reason(self):
         "Testing IsValidReason support"
 
diff --git a/django/contrib/gis/management/commands/ogrinspect.py b/django/contrib/gis/management/commands/ogrinspect.py
index c7b1389574..78c610635a 100644
--- a/django/contrib/gis/management/commands/ogrinspect.py
+++ b/django/contrib/gis/management/commands/ogrinspect.py
@@ -1,4 +1,6 @@
+import inspect
 from optparse import make_option
+
 from django.contrib.gis import gdal
 from django.core.management.base import LabelCommand, CommandError
 
@@ -83,27 +85,21 @@ class Command(LabelCommand):
         if not gdal.HAS_GDAL:
             raise CommandError('GDAL is required to inspect geospatial data sources.')
 
-        # Removing options with `None` values.
-        options = dict((k, v) for k, v in options.items() if not v is None)
-
         # Getting the OGR DataSource from the string parameter.
         try:
             ds = gdal.DataSource(data_source)
         except gdal.OGRException as msg:
             raise CommandError(msg)
 
-        # Whether the user wants to generate the LayerMapping dictionary as well.
-        show_mapping = options.pop('mapping', False)
-
-        # Getting rid of settings that `_ogrinspect` doesn't like.
-        options.pop('verbosity', False)
-        options.pop('settings', False)
-
         # Returning the output of ogrinspect with the given arguments
         # and options.
         from django.contrib.gis.utils.ogrinspect import _ogrinspect, mapping
-        output = [s for s in _ogrinspect(ds, model_name, **options)]
-        if show_mapping:
+        # Filter options to params accepted by `_ogrinspect`
+        ogr_options = dict((k, v) for k, v in options.items()
+                           if k in inspect.getargspec(_ogrinspect).args and v is not None)
+        output = [s for s in _ogrinspect(ds, model_name, **ogr_options)]
+
+        if options['mapping']:
             # Constructing the keyword arguments for `mapping`, and
             # calling it on the data source.
             kwargs = {'geom_name': options['geom_name'],
diff --git a/django/contrib/gis/sitemaps/kml.py b/django/contrib/gis/sitemaps/kml.py
index aa9ae69f5d..74d7acd772 100644
--- a/django/contrib/gis/sitemaps/kml.py
+++ b/django/contrib/gis/sitemaps/kml.py
@@ -1,4 +1,4 @@
-from django.core.apps import app_cache
+from django.apps import apps
 from django.core import urlresolvers
 from django.contrib.sitemaps import Sitemap
 from django.contrib.gis.db.models.fields import GeometryField
@@ -26,7 +26,7 @@ class KMLSitemap(Sitemap):
         """
         kml_sources = []
         if sources is None:
-            sources = app_cache.get_models()
+            sources = apps.get_models()
         for source in sources:
             if isinstance(source, models.base.ModelBase):
                 for field in source._meta.fields:
diff --git a/django/contrib/gis/sitemaps/views.py b/django/contrib/gis/sitemaps/views.py
index e55a371672..a65612a541 100644
--- a/django/contrib/gis/sitemaps/views.py
+++ b/django/contrib/gis/sitemaps/views.py
@@ -2,7 +2,7 @@ from __future__ import unicode_literals
 
 import warnings
 
-from django.core.apps import app_cache
+from django.apps import apps
 from django.http import HttpResponse, Http404
 from django.template import loader
 from django.contrib.sites.models import get_current_site
@@ -81,8 +81,9 @@ def kml(request, label, model, field_name=None, compress=False, using=DEFAULT_DB
     must be that of a geographic field.
     """
     placemarks = []
-    klass = app_cache.get_model(label, model)
-    if not klass:
+    try:
+        klass = apps.get_model(label, model)
+    except LookupError:
         raise Http404('You must supply a valid app label and module name.  Got "%s.%s"' % (label, model))
 
     if field_name:
diff --git a/django/contrib/gis/tests/distapp/models.py b/django/contrib/gis/tests/distapp/models.py
index 811c275faf..4d95b219d7 100644
--- a/django/contrib/gis/tests/distapp/models.py
+++ b/django/contrib/gis/tests/distapp/models.py
@@ -3,77 +3,49 @@ from django.utils.encoding import python_2_unicode_compatible
 
 
 @python_2_unicode_compatible
-class SouthTexasCity(models.Model):
+class NamedModel(models.Model):
+    name = models.CharField(max_length=30)
+
+    objects = models.GeoManager()
+
+    class Meta:
+        abstract = True
+        app_label = 'distapp'
+
+    def __str__(self):
+        return self.name
+
+
+class SouthTexasCity(NamedModel):
     "City model on projected coordinate system for South Texas."
-    name = models.CharField(max_length=30)
     point = models.PointField(srid=32140)
-    objects = models.GeoManager()
-
-    def __str__(self):
-        return self.name
 
 
-@python_2_unicode_compatible
-class SouthTexasCityFt(models.Model):
+class SouthTexasCityFt(NamedModel):
     "Same City model as above, but U.S. survey feet are the units."
-    name = models.CharField(max_length=30)
     point = models.PointField(srid=2278)
-    objects = models.GeoManager()
-
-    def __str__(self):
-        return self.name
 
 
-@python_2_unicode_compatible
-class AustraliaCity(models.Model):
+class AustraliaCity(NamedModel):
     "City model for Australia, using WGS84."
-    name = models.CharField(max_length=30)
     point = models.PointField()
-    objects = models.GeoManager()
-
-    def __str__(self):
-        return self.name
 
 
-@python_2_unicode_compatible
-class CensusZipcode(models.Model):
+class CensusZipcode(NamedModel):
     "Model for a few South Texas ZIP codes (in original Census NAD83)."
-    name = models.CharField(max_length=5)
     poly = models.PolygonField(srid=4269)
-    objects = models.GeoManager()
-
-    def __str__(self):
-        return self.name
 
 
-@python_2_unicode_compatible
-class SouthTexasZipcode(models.Model):
+class SouthTexasZipcode(NamedModel):
     "Model for a few South Texas ZIP codes."
-    name = models.CharField(max_length=5)
     poly = models.PolygonField(srid=32140, null=True)
-    objects = models.GeoManager()
-
-    def __str__(self):
-        return self.name
 
 
-@python_2_unicode_compatible
-class Interstate(models.Model):
+class Interstate(NamedModel):
     "Geodetic model for U.S. Interstates."
-    name = models.CharField(max_length=10)
     path = models.LineStringField()
-    objects = models.GeoManager()
-
-    def __str__(self):
-        return self.name
 
 
-@python_2_unicode_compatible
-class SouthTexasInterstate(models.Model):
+class SouthTexasInterstate(NamedModel):
     "Projected model for South Texas Interstates."
-    name = models.CharField(max_length=10)
     path = models.LineStringField(srid=32140)
-    objects = models.GeoManager()
-
-    def __str__(self):
-        return self.name
diff --git a/django/contrib/gis/tests/geo3d/models.py b/django/contrib/gis/tests/geo3d/models.py
index 023c71ead1..2244ed8b15 100644
--- a/django/contrib/gis/tests/geo3d/models.py
+++ b/django/contrib/gis/tests/geo3d/models.py
@@ -3,85 +3,63 @@ from django.utils.encoding import python_2_unicode_compatible
 
 
 @python_2_unicode_compatible
-class City3D(models.Model):
+class NamedModel(models.Model):
     name = models.CharField(max_length=30)
-    point = models.PointField(dim=3)
+
     objects = models.GeoManager()
 
+    class Meta:
+        abstract = True
+        app_label = 'geo3d'
+
     def __str__(self):
         return self.name
 
 
-@python_2_unicode_compatible
-class Interstate2D(models.Model):
-    name = models.CharField(max_length=30)
+class City3D(NamedModel):
+    point = models.PointField(dim=3)
+
+
+class Interstate2D(NamedModel):
     line = models.LineStringField(srid=4269)
-    objects = models.GeoManager()
-
-    def __str__(self):
-        return self.name
 
 
-@python_2_unicode_compatible
-class Interstate3D(models.Model):
-    name = models.CharField(max_length=30)
+class Interstate3D(NamedModel):
     line = models.LineStringField(dim=3, srid=4269)
-    objects = models.GeoManager()
-
-    def __str__(self):
-        return self.name
 
 
-@python_2_unicode_compatible
-class InterstateProj2D(models.Model):
-    name = models.CharField(max_length=30)
+class InterstateProj2D(NamedModel):
     line = models.LineStringField(srid=32140)
-    objects = models.GeoManager()
-
-    def __str__(self):
-        return self.name
 
 
-@python_2_unicode_compatible
-class InterstateProj3D(models.Model):
-    name = models.CharField(max_length=30)
+class InterstateProj3D(NamedModel):
     line = models.LineStringField(dim=3, srid=32140)
-    objects = models.GeoManager()
-
-    def __str__(self):
-        return self.name
 
 
-@python_2_unicode_compatible
-class Polygon2D(models.Model):
-    name = models.CharField(max_length=30)
+class Polygon2D(NamedModel):
     poly = models.PolygonField(srid=32140)
-    objects = models.GeoManager()
-
-    def __str__(self):
-        return self.name
 
 
-@python_2_unicode_compatible
-class Polygon3D(models.Model):
-    name = models.CharField(max_length=30)
+class Polygon3D(NamedModel):
     poly = models.PolygonField(dim=3, srid=32140)
+
+
+class SimpleModel(models.Model):
+
     objects = models.GeoManager()
 
-    def __str__(self):
-        return self.name
+    class Meta:
+        abstract = True
+        app_label = 'geo3d'
 
 
-class Point2D(models.Model):
+class Point2D(SimpleModel):
     point = models.PointField()
-    objects = models.GeoManager()
 
 
-class Point3D(models.Model):
+class Point3D(SimpleModel):
     point = models.PointField(dim=3)
-    objects = models.GeoManager()
 
 
-class MultiPoint3D(models.Model):
+class MultiPoint3D(SimpleModel):
     mpoint = models.MultiPointField(dim=3)
-    objects = models.GeoManager()
diff --git a/django/contrib/gis/tests/geoadmin/models.py b/django/contrib/gis/tests/geoadmin/models.py
index d1d671954a..381a752570 100644
--- a/django/contrib/gis/tests/geoadmin/models.py
+++ b/django/contrib/gis/tests/geoadmin/models.py
@@ -7,8 +7,12 @@ from django.utils.encoding import python_2_unicode_compatible
 class City(models.Model):
     name = models.CharField(max_length=30)
     point = models.PointField()
+
     objects = models.GeoManager()
 
+    class Meta:
+        app_label = 'geoadmin'
+
     def __str__(self):
         return self.name
 
diff --git a/django/contrib/gis/tests/geoadmin/tests.py b/django/contrib/gis/tests/geoadmin/tests.py
index b39b3183dc..06a8ed245a 100644
--- a/django/contrib/gis/tests/geoadmin/tests.py
+++ b/django/contrib/gis/tests/geoadmin/tests.py
@@ -4,8 +4,7 @@ from unittest import skipUnless
 
 from django.contrib.gis.geos import HAS_GEOS
 from django.contrib.gis.tests.utils import HAS_SPATIAL_DB
-from django.test import TestCase
-from django.test.utils import override_settings
+from django.test import TestCase, override_settings
 
 if HAS_GEOS and HAS_SPATIAL_DB:
     from django.contrib.gis import admin
diff --git a/django/contrib/gis/tests/geoapp/models.py b/django/contrib/gis/tests/geoapp/models.py
index 8234bc8d9b..2550854b76 100644
--- a/django/contrib/gis/tests/geoapp/models.py
+++ b/django/contrib/gis/tests/geoapp/models.py
@@ -7,66 +7,66 @@ null_flag = not mysql
 
 
 @python_2_unicode_compatible
-class Country(models.Model):
+class NamedModel(models.Model):
     name = models.CharField(max_length=30)
+
+    objects = models.GeoManager()
+
+    class Meta:
+        abstract = True
+        app_label = 'geoapp'
+
+    def __str__(self):
+        return self.name
+
+
+class Country(NamedModel):
     mpoly = models.MultiPolygonField()  # SRID, by default, is 4326
-    objects = models.GeoManager()
-
-    def __str__(self):
-        return self.name
 
 
-@python_2_unicode_compatible
-class City(models.Model):
-    name = models.CharField(max_length=30)
+class City(NamedModel):
     point = models.PointField()
-    objects = models.GeoManager()
-
-    def __str__(self):
-        return self.name
 
 
 # This is an inherited model from City
 class PennsylvaniaCity(City):
     county = models.CharField(max_length=30)
     founded = models.DateTimeField(null=True)
-    objects = models.GeoManager()  # TODO: This should be implicitly inherited.
+
+    # TODO: This should be implicitly inherited.
+
+    objects = models.GeoManager()
+
+    class Meta:
+        app_label = 'geoapp'
 
 
-@python_2_unicode_compatible
-class State(models.Model):
-    name = models.CharField(max_length=30)
+class State(NamedModel):
     poly = models.PolygonField(null=null_flag)  # Allowing NULL geometries here.
-    objects = models.GeoManager()
-
-    def __str__(self):
-        return self.name
 
 
-@python_2_unicode_compatible
-class Track(models.Model):
-    name = models.CharField(max_length=30)
+class Track(NamedModel):
     line = models.LineStringField()
-    objects = models.GeoManager()
-
-    def __str__(self):
-        return self.name
 
 
 class Truth(models.Model):
     val = models.BooleanField(default=False)
+
     objects = models.GeoManager()
 
-if not spatialite:
-    @python_2_unicode_compatible
-    class Feature(models.Model):
-        name = models.CharField(max_length=20)
-        geom = models.GeometryField()
-        objects = models.GeoManager()
+    class Meta:
+        app_label = 'geoapp'
 
-        def __str__(self):
-            return self.name
+
+if not spatialite:
+
+    class Feature(NamedModel):
+        geom = models.GeometryField()
 
     class MinusOneSRID(models.Model):
         geom = models.PointField(srid=-1)  # Minus one SRID.
+
         objects = models.GeoManager()
+
+        class Meta:
+            app_label = 'geoapp'
diff --git a/django/contrib/gis/tests/geoapp/test_feeds.py b/django/contrib/gis/tests/geoapp/test_feeds.py
index 0817e65cb4..96ba26cece 100644
--- a/django/contrib/gis/tests/geoapp/test_feeds.py
+++ b/django/contrib/gis/tests/geoapp/test_feeds.py
@@ -7,12 +7,13 @@ from django.conf import settings
 from django.contrib.sites.models import Site
 from django.contrib.gis.geos import HAS_GEOS
 from django.contrib.gis.tests.utils import HAS_SPATIAL_DB
-from django.test import TestCase
+from django.test import TestCase, modify_settings
 
 if HAS_GEOS:
     from .models import City
 
 
+@modify_settings(INSTALLED_APPS={'append': 'django.contrib.sites'})
 @skipUnless(HAS_GEOS and HAS_SPATIAL_DB, "Geos and spatial db are required.")
 class GeoFeedTest(TestCase):
 
@@ -20,11 +21,6 @@ class GeoFeedTest(TestCase):
 
     def setUp(self):
         Site(id=settings.SITE_ID, domain="example.com", name="example.com").save()
-        self._old_installed = Site._meta.app_config.installed
-        Site._meta.app_config.installed = True
-
-    def tearDown(self):
-        Site._meta.app_config.installed = self._old_installed
 
     def assertChildNodes(self, elem, expected):
         "Taken from syndication/tests.py."
diff --git a/django/contrib/gis/tests/geoapp/test_sitemaps.py b/django/contrib/gis/tests/geoapp/test_sitemaps.py
index ee9974ceaa..c41cc53674 100644
--- a/django/contrib/gis/tests/geoapp/test_sitemaps.py
+++ b/django/contrib/gis/tests/geoapp/test_sitemaps.py
@@ -10,7 +10,7 @@ from django.conf import settings
 from django.contrib.gis.geos import HAS_GEOS
 from django.contrib.gis.tests.utils import HAS_SPATIAL_DB
 from django.contrib.sites.models import Site
-from django.test import TestCase
+from django.test import TestCase, modify_settings
 from django.test.utils import IgnoreDeprecationWarningsMixin
 from django.utils._os import upath
 
@@ -18,6 +18,7 @@ if HAS_GEOS:
     from .models import City, Country
 
 
+@modify_settings(INSTALLED_APPS={'append': 'django.contrib.sites'})
 @skipUnless(HAS_GEOS and HAS_SPATIAL_DB, "Geos and spatial db are required.")
 class GeoSitemapTest(IgnoreDeprecationWarningsMixin, TestCase):
 
@@ -26,12 +27,6 @@ class GeoSitemapTest(IgnoreDeprecationWarningsMixin, TestCase):
     def setUp(self):
         super(GeoSitemapTest, self).setUp()
         Site(id=settings.SITE_ID, domain="example.com", name="example.com").save()
-        self._old_installed = Site._meta.app_config.installed
-        Site._meta.app_config.installed = True
-
-    def tearDown(self):
-        Site._meta.app_config.installed = self._old_installed
-        super(GeoSitemapTest, self).tearDown()
 
     def assertChildNodes(self, elem, expected):
         "Taken from syndication/tests.py."
diff --git a/django/contrib/gis/tests/geogapp/models.py b/django/contrib/gis/tests/geogapp/models.py
index 1953bc5a29..f6f127ca96 100644
--- a/django/contrib/gis/tests/geogapp/models.py
+++ b/django/contrib/gis/tests/geogapp/models.py
@@ -3,31 +3,31 @@ from django.utils.encoding import python_2_unicode_compatible
 
 
 @python_2_unicode_compatible
-class City(models.Model):
+class NamedModel(models.Model):
     name = models.CharField(max_length=30)
-    point = models.PointField(geography=True)
+
     objects = models.GeoManager()
 
+    class Meta:
+        abstract = True
+        app_label = 'geogapp'
+
     def __str__(self):
         return self.name
 
 
-@python_2_unicode_compatible
-class Zipcode(models.Model):
+class City(NamedModel):
+    point = models.PointField(geography=True)
+
+
+class Zipcode(NamedModel):
     code = models.CharField(max_length=10)
     poly = models.PolygonField(geography=True)
-    objects = models.GeoManager()
-
-    def __str__(self):
-        return self.code
 
 
-@python_2_unicode_compatible
-class County(models.Model):
-    name = models.CharField(max_length=25)
+class County(NamedModel):
     state = models.CharField(max_length=20)
     mpoly = models.MultiPolygonField(geography=True)
-    objects = models.GeoManager()
 
     def __str__(self):
         return ' County, '.join([self.name, self.state])
diff --git a/django/contrib/gis/tests/inspectapp/models.py b/django/contrib/gis/tests/inspectapp/models.py
index 37c67a72fe..caf45fad9a 100644
--- a/django/contrib/gis/tests/inspectapp/models.py
+++ b/django/contrib/gis/tests/inspectapp/models.py
@@ -2,6 +2,7 @@ from django.contrib.gis.db import models
 
 
 class AllOGRFields(models.Model):
+
     f_decimal = models.FloatField()
     f_float = models.FloatField()
     f_int = models.IntegerField()
@@ -13,3 +14,6 @@ class AllOGRFields(models.Model):
     point = models.PointField()
 
     objects = models.GeoManager()
+
+    class Meta:
+        app_label = 'inspectapp'
diff --git a/django/contrib/gis/tests/inspectapp/tests.py b/django/contrib/gis/tests/inspectapp/tests.py
index 17642ea8df..2690dc484d 100644
--- a/django/contrib/gis/tests/inspectapp/tests.py
+++ b/django/contrib/gis/tests/inspectapp/tests.py
@@ -115,6 +115,13 @@ class OGRInspectTest(TestCase):
             '    objects = models.GeoManager()'
         ))
 
+    def test_management_command(self):
+        shp_file = os.path.join(TEST_DATA, 'cities', 'cities.shp')
+        out = StringIO()
+        call_command('ogrinspect', shp_file, 'City', stdout=out)
+        output = out.getvalue()
+        self.assertIn('class City(models.Model):', output)
+
 
 def get_ogr_db_string():
     """
diff --git a/django/contrib/gis/tests/layermap/models.py b/django/contrib/gis/tests/layermap/models.py
index 1b66c6d94c..246af1458d 100644
--- a/django/contrib/gis/tests/layermap/models.py
+++ b/django/contrib/gis/tests/layermap/models.py
@@ -1,61 +1,75 @@
 from django.contrib.gis.db import models
+from django.utils.encoding import python_2_unicode_compatible
 
 
-class State(models.Model):
-    name = models.CharField(max_length=20)
+@python_2_unicode_compatible
+class NamedModel(models.Model):
+    name = models.CharField(max_length=25)
+
     objects = models.GeoManager()
 
+    class Meta:
+        abstract = True
+        app_label = 'layermap'
 
-class County(models.Model):
-    name = models.CharField(max_length=25)
+    def __str__(self):
+        return self.name
+
+
+class State(NamedModel):
+    pass
+
+
+class County(NamedModel):
     state = models.ForeignKey(State)
     mpoly = models.MultiPolygonField(srid=4269)  # Multipolygon in NAD83
-    objects = models.GeoManager()
 
 
-class CountyFeat(models.Model):
-    name = models.CharField(max_length=25)
+class CountyFeat(NamedModel):
     poly = models.PolygonField(srid=4269)
-    objects = models.GeoManager()
 
 
-class City(models.Model):
-    name = models.CharField(max_length=25)
+class City(NamedModel):
     name_txt = models.TextField(default='')
     population = models.IntegerField()
     density = models.DecimalField(max_digits=7, decimal_places=1)
     dt = models.DateField()
     point = models.PointField()
-    objects = models.GeoManager()
 
 
-class Interstate(models.Model):
-    name = models.CharField(max_length=20)
+class Interstate(NamedModel):
     length = models.DecimalField(max_digits=6, decimal_places=2)
     path = models.LineStringField()
-    objects = models.GeoManager()
 
 
 # Same as `City` above, but for testing model inheritance.
-class CityBase(models.Model):
-    name = models.CharField(max_length=25)
+class CityBase(NamedModel):
     population = models.IntegerField()
     density = models.DecimalField(max_digits=7, decimal_places=1)
     point = models.PointField()
-    objects = models.GeoManager()
 
 
 class ICity1(CityBase):
     dt = models.DateField()
 
+    class Meta(CityBase.Meta):
+        pass
+
 
 class ICity2(ICity1):
     dt_time = models.DateTimeField(auto_now=True)
 
+    class Meta(ICity1.Meta):
+        pass
+
 
 class Invalid(models.Model):
     point = models.PointField()
 
+    class Meta:
+        app_label = 'layermap'
+
+
 # Mapping dictionaries for the models above.
 co_mapping = {'name': 'Name',
               'state': {'name': 'State'},  # ForeignKey's use another mapping dictionary for the _related_ Model (State in this case).
diff --git a/django/contrib/gis/tests/relatedapp/models.py b/django/contrib/gis/tests/relatedapp/models.py
index 6d4b530c58..3b4364f7b9 100644
--- a/django/contrib/gis/tests/relatedapp/models.py
+++ b/django/contrib/gis/tests/relatedapp/models.py
@@ -2,21 +2,28 @@ from django.contrib.gis.db import models
 from django.utils.encoding import python_2_unicode_compatible
 
 
-@python_2_unicode_compatible
-class Location(models.Model):
-    point = models.PointField()
+class SimpleModel(models.Model):
+
     objects = models.GeoManager()
 
+    class Meta:
+        abstract = True
+        app_label = 'relatedapp'
+
+
+@python_2_unicode_compatible
+class Location(SimpleModel):
+    point = models.PointField()
+
     def __str__(self):
         return self.point.wkt
 
 
 @python_2_unicode_compatible
-class City(models.Model):
+class City(SimpleModel):
     name = models.CharField(max_length=50)
     state = models.CharField(max_length=2)
     location = models.ForeignKey(Location)
-    objects = models.GeoManager()
 
     def __str__(self):
         return self.name
@@ -24,17 +31,20 @@ class City(models.Model):
 
 class AugmentedLocation(Location):
     extra_text = models.TextField(blank=True)
+
     objects = models.GeoManager()
 
+    class Meta:
+        app_label = 'relatedapp'
 
-class DirectoryEntry(models.Model):
+
+class DirectoryEntry(SimpleModel):
     listing_text = models.CharField(max_length=50)
     location = models.ForeignKey(AugmentedLocation)
-    objects = models.GeoManager()
 
 
 @python_2_unicode_compatible
-class Parcel(models.Model):
+class Parcel(SimpleModel):
     name = models.CharField(max_length=30)
     city = models.ForeignKey(City)
     center1 = models.PointField()
@@ -42,26 +52,22 @@ class Parcel(models.Model):
     center2 = models.PointField(srid=2276, db_column='mycenter')
     border1 = models.PolygonField()
     border2 = models.PolygonField(srid=2276)
-    objects = models.GeoManager()
 
     def __str__(self):
         return self.name
 
 
 # These use the GeoManager but do not have any geographic fields.
-class Author(models.Model):
+class Author(SimpleModel):
     name = models.CharField(max_length=100)
     dob = models.DateField()
-    objects = models.GeoManager()
 
 
-class Article(models.Model):
+class Article(SimpleModel):
     title = models.CharField(max_length=100)
     author = models.ForeignKey(Author, unique=True)
-    objects = models.GeoManager()
 
 
-class Book(models.Model):
+class Book(SimpleModel):
     title = models.CharField(max_length=100)
     author = models.ForeignKey(Author, related_name='books', null=True)
-    objects = models.GeoManager()
diff --git a/django/contrib/humanize/apps.py b/django/contrib/humanize/apps.py
new file mode 100644
index 0000000000..e52a5aa044
--- /dev/null
+++ b/django/contrib/humanize/apps.py
@@ -0,0 +1,8 @@
+from django.apps import AppConfig
+
+from django.utils.translation import ugettext_lazy as _
+
+
+class HumanizeConfig(AppConfig):
+    name = 'django.contrib.humanize'
+    verbose_name = _("humanize")
diff --git a/django/contrib/humanize/tests.py b/django/contrib/humanize/tests.py
index 0f31beb81f..ab4d53c760 100644
--- a/django/contrib/humanize/tests.py
+++ b/django/contrib/humanize/tests.py
@@ -11,8 +11,8 @@ except ImportError:
 from django.conf import settings
 from django.contrib.humanize.templatetags import humanize
 from django.template import Template, Context, defaultfilters
-from django.test import TestCase
-from django.test.utils import override_settings, TransRealMixin
+from django.test import TestCase, override_settings
+from django.test.utils import TransRealMixin
 from django.utils.html import escape
 from django.utils.timezone import utc, get_fixed_timezone
 from django.utils import translation
diff --git a/django/contrib/messages/apps.py b/django/contrib/messages/apps.py
new file mode 100644
index 0000000000..f8b07e9cb6
--- /dev/null
+++ b/django/contrib/messages/apps.py
@@ -0,0 +1,8 @@
+from django.apps import AppConfig
+
+from django.utils.translation import ugettext_lazy as _
+
+
+class MessagesConfig(AppConfig):
+    name = 'django.contrib.messages'
+    verbose_name = _("messages")
diff --git a/django/contrib/messages/storage/__init__.py b/django/contrib/messages/storage/__init__.py
index 9a09aff007..591ae14d7c 100644
--- a/django/contrib/messages/storage/__init__.py
+++ b/django/contrib/messages/storage/__init__.py
@@ -1,8 +1,12 @@
 from django.conf import settings
-from django.utils.module_loading import import_by_path as get_storage
+from django.utils.module_loading import import_by_path
 
 
-# Callable with the same interface as the storage classes i.e.  accepts a
-# 'request' object.  It is wrapped in a lambda to stop 'settings' being used at
-# the module level
-default_storage = lambda request: get_storage(settings.MESSAGE_STORAGE)(request)
+def default_storage(request):
+    """
+    Callable with the same interface as the storage classes.
+
+    This isn't just default_storage = import_by_path(settings.MESSAGE_STORAGE)
+    to avoid accessing the settings at the module level.
+    """
+    return import_by_path(settings.MESSAGE_STORAGE)(request)
diff --git a/django/contrib/messages/tests/base.py b/django/contrib/messages/tests/base.py
index f3e676fac5..b0c35b9d06 100644
--- a/django/contrib/messages/tests/base.py
+++ b/django/contrib/messages/tests/base.py
@@ -1,20 +1,21 @@
-from unittest import skipIf
+from unittest import skipUnless
 
 from django import http
-from django.conf import settings, global_settings
+from django.apps import apps
+from django.conf import global_settings
 from django.contrib.messages import constants, utils, get_level, set_level
 from django.contrib.messages.api import MessageFailure
 from django.contrib.messages.constants import DEFAULT_LEVELS
 from django.contrib.messages.storage import default_storage, base
 from django.contrib.messages.storage.base import Message
 from django.core.urlresolvers import reverse
-from django.test.utils import override_settings
+from django.test import modify_settings, override_settings
 from django.utils.translation import ugettext_lazy
 
 
 def skipUnlessAuthIsInstalled(func):
-    return skipIf(
-        'django.contrib.auth' not in settings.INSTALLED_APPS,
+    return skipUnless(
+        apps.is_installed('django.contrib.auth'),
         "django.contrib.auth isn't installed")(func)
 
 
@@ -218,16 +219,12 @@ class BaseTests(object):
         for msg in data['messages']:
             self.assertContains(response, msg)
 
-    @override_settings(
-        INSTALLED_APPS=filter(
-            lambda app: app != 'django.contrib.messages', settings.INSTALLED_APPS),
-        MIDDLEWARE_CLASSES=filter(
-            lambda m: 'MessageMiddleware' not in m, settings.MIDDLEWARE_CLASSES),
-        TEMPLATE_CONTEXT_PROCESSORS=filter(
-            lambda p: 'context_processors.messages' not in p,
-            settings.TEMPLATE_CONTEXT_PROCESSORS),
-        MESSAGE_LEVEL=constants.DEBUG
+    @modify_settings(
+        INSTALLED_APPS={'remove': 'django.contrib.messages'},
+        MIDDLEWARE_CLASSES={'remove': 'django.contrib.messages.middleware.MessageMiddleware'},
+        TEMPLATE_CONTEXT_PROCESSORS={'remove': 'django.contrib.messages.context_processors.messages'},
     )
+    @override_settings(MESSAGE_LEVEL=constants.DEBUG)
     def test_middleware_disabled(self):
         """
         Tests that, when the middleware is disabled, an exception is raised
@@ -243,15 +240,10 @@ class BaseTests(object):
             self.assertRaises(MessageFailure, self.client.post, add_url,
                               data, follow=True)
 
-    @override_settings(
-        INSTALLED_APPS=filter(
-            lambda app: app != 'django.contrib.messages', settings.INSTALLED_APPS),
-        MIDDLEWARE_CLASSES=filter(
-            lambda m: 'MessageMiddleware' not in m, settings.MIDDLEWARE_CLASSES),
-        TEMPLATE_CONTEXT_PROCESSORS=filter(
-            lambda p: 'context_processors.messages' not in p,
-            settings.TEMPLATE_CONTEXT_PROCESSORS),
-        MESSAGE_LEVEL=constants.DEBUG
+    @modify_settings(
+        INSTALLED_APPS={'remove': 'django.contrib.messages'},
+        MIDDLEWARE_CLASSES={'remove': 'django.contrib.messages.middleware.MessageMiddleware'},
+        TEMPLATE_CONTEXT_PROCESSORS={'remove': 'django.contrib.messages.context_processors.messages'},
     )
     def test_middleware_disabled_fail_silently(self):
         """
diff --git a/django/contrib/messages/tests/test_cookie.py b/django/contrib/messages/tests/test_cookie.py
index 028f01382b..d44dd94491 100644
--- a/django/contrib/messages/tests/test_cookie.py
+++ b/django/contrib/messages/tests/test_cookie.py
@@ -5,8 +5,7 @@ from django.contrib.messages.tests.base import BaseTests
 from django.contrib.messages.storage.cookie import (CookieStorage,
     MessageEncoder, MessageDecoder)
 from django.contrib.messages.storage.base import Message
-from django.test import TestCase
-from django.test.utils import override_settings
+from django.test import TestCase, override_settings
 from django.utils.safestring import SafeData, mark_safe
 
 
diff --git a/django/contrib/redirects/apps.py b/django/contrib/redirects/apps.py
new file mode 100644
index 0000000000..b4f8c168d8
--- /dev/null
+++ b/django/contrib/redirects/apps.py
@@ -0,0 +1,8 @@
+from django.apps import AppConfig
+
+from django.utils.translation import ugettext_lazy as _
+
+
+class RedirectsConfig(AppConfig):
+    name = 'django.contrib.redirects'
+    verbose_name = _("redirects")
diff --git a/django/contrib/redirects/middleware.py b/django/contrib/redirects/middleware.py
index 9053c64a9a..4894e30216 100644
--- a/django/contrib/redirects/middleware.py
+++ b/django/contrib/redirects/middleware.py
@@ -1,5 +1,6 @@
 from __future__ import unicode_literals
 
+from django.apps import apps
 from django.conf import settings
 from django.contrib.redirects.models import Redirect
 from django.contrib.sites.models import get_current_site
@@ -14,7 +15,7 @@ class RedirectFallbackMiddleware(object):
     response_redirect_class = http.HttpResponsePermanentRedirect
 
     def __init__(self):
-        if 'django.contrib.sites' not in settings.INSTALLED_APPS:
+        if not apps.is_installed('django.contrib.sites'):
             raise ImproperlyConfigured(
                 "You cannot use RedirectFallbackMiddleware when "
                 "django.contrib.sites is not installed."
diff --git a/django/contrib/redirects/tests.py b/django/contrib/redirects/tests.py
index 84638d6ab6..3bed0e02e5 100644
--- a/django/contrib/redirects/tests.py
+++ b/django/contrib/redirects/tests.py
@@ -2,20 +2,16 @@ from django import http
 from django.conf import settings
 from django.contrib.sites.models import Site
 from django.core.exceptions import ImproperlyConfigured
-from django.test import TestCase
-from django.test.utils import override_settings
+from django.test import TestCase, modify_settings, override_settings
 from django.utils import six
 
 from .middleware import RedirectFallbackMiddleware
 from .models import Redirect
 
 
-@override_settings(
-    APPEND_SLASH=False,
-    MIDDLEWARE_CLASSES=list(settings.MIDDLEWARE_CLASSES) +
-    ['django.contrib.redirects.middleware.RedirectFallbackMiddleware'],
-    SITE_ID=1,
-)
+@modify_settings(MIDDLEWARE_CLASSES={'append':
+    'django.contrib.redirects.middleware.RedirectFallbackMiddleware'})
+@override_settings(APPEND_SLASH=False, SITE_ID=1)
 class RedirectTests(TestCase):
 
     def setUp(self):
@@ -56,9 +52,7 @@ class RedirectTests(TestCase):
         response = self.client.get('/initial')
         self.assertEqual(response.status_code, 410)
 
-    @override_settings(
-        INSTALLED_APPS=[app for app in settings.INSTALLED_APPS
-                        if app != 'django.contrib.sites'])
+    @modify_settings(INSTALLED_APPS={'remove': 'django.contrib.sites'})
     def test_sites_not_installed(self):
         with self.assertRaises(ImproperlyConfigured):
             RedirectFallbackMiddleware()
@@ -70,11 +64,9 @@ class OverriddenRedirectFallbackMiddleware(RedirectFallbackMiddleware):
     response_redirect_class = http.HttpResponseRedirect
 
 
-@override_settings(
-    MIDDLEWARE_CLASSES=list(settings.MIDDLEWARE_CLASSES) +
-    ['django.contrib.redirects.tests.OverriddenRedirectFallbackMiddleware'],
-    SITE_ID=1,
-)
+@modify_settings(MIDDLEWARE_CLASSES={'append':
+    'django.contrib.redirects.tests.OverriddenRedirectFallbackMiddleware'})
+@override_settings(SITE_ID=1)
 class OverriddenRedirectMiddlewareTests(TestCase):
 
     def setUp(self):
diff --git a/django/contrib/sessions/apps.py b/django/contrib/sessions/apps.py
new file mode 100644
index 0000000000..8b5093e7c9
--- /dev/null
+++ b/django/contrib/sessions/apps.py
@@ -0,0 +1,8 @@
+from django.apps import AppConfig
+
+from django.utils.translation import ugettext_lazy as _
+
+
+class SessionsConfig(AppConfig):
+    name = 'django.contrib.sessions'
+    verbose_name = _("sessions")
diff --git a/django/contrib/sessions/tests.py b/django/contrib/sessions/tests.py
index 51a65a1fef..34b8964153 100644
--- a/django/contrib/sessions/tests.py
+++ b/django/contrib/sessions/tests.py
@@ -20,8 +20,8 @@ from django.core.cache.backends.base import InvalidCacheBackendError
 from django.core import management
 from django.core.exceptions import ImproperlyConfigured
 from django.http import HttpResponse
-from django.test import TestCase, RequestFactory
-from django.test.utils import override_settings, patch_logger
+from django.test import TestCase, RequestFactory, override_settings
+from django.test.utils import patch_logger
 from django.utils import six
 from django.utils import timezone
 
diff --git a/django/contrib/sitemaps/apps.py b/django/contrib/sitemaps/apps.py
new file mode 100644
index 0000000000..8237f0f188
--- /dev/null
+++ b/django/contrib/sitemaps/apps.py
@@ -0,0 +1,8 @@
+from django.apps import AppConfig
+
+from django.utils.translation import ugettext_lazy as _
+
+
+class SiteMapsConfig(AppConfig):
+    name = 'django.contrib.sitemaps'
+    verbose_name = _("site maps")
diff --git a/django/contrib/sitemaps/locale/en/LC_MESSAGES/django.po b/django/contrib/sitemaps/locale/en/LC_MESSAGES/django.po
new file mode 100644
index 0000000000..fcd182f511
--- /dev/null
+++ b/django/contrib/sitemaps/locale/en/LC_MESSAGES/django.po
@@ -0,0 +1,22 @@
+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER
+# This file is distributed under the same license as the PACKAGE package.
+# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
+#
+#, fuzzy
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2014-01-04 23:05+0100\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language-Team: LANGUAGE <LL@li.org>\n"
+"Language: \n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: apps.py:8
+msgid "site maps"
+msgstr ""
diff --git a/django/contrib/sitemaps/tests/base.py b/django/contrib/sitemaps/tests/base.py
index 98abb3dca4..ecddcc737b 100644
--- a/django/contrib/sitemaps/tests/base.py
+++ b/django/contrib/sitemaps/tests/base.py
@@ -25,10 +25,6 @@ class SitemapTestsBase(TestCase):
 
     def setUp(self):
         self.base_url = '%s://%s' % (self.protocol, self.domain)
-        self._old_installed = Site._meta.app_config.installed
         cache.clear()
         # Create an object for sitemap content.
         TestModel.objects.create(name='Test Object')
-
-    def tearDown(self):
-        Site._meta.app_config.installed = self._old_installed
diff --git a/django/contrib/sitemaps/tests/test_flatpages.py b/django/contrib/sitemaps/tests/test_flatpages.py
index 75ebb10f96..c284c66c0d 100644
--- a/django/contrib/sitemaps/tests/test_flatpages.py
+++ b/django/contrib/sitemaps/tests/test_flatpages.py
@@ -2,6 +2,7 @@ from __future__ import unicode_literals
 
 from unittest import skipUnless
 
+from django.apps import apps
 from django.conf import settings
 
 from .base import SitemapTestsBase
@@ -9,7 +10,7 @@ from .base import SitemapTestsBase
 
 class FlatpagesSitemapTests(SitemapTestsBase):
 
-    @skipUnless("django.contrib.flatpages" in settings.INSTALLED_APPS,
+    @skipUnless(apps.is_installed('django.contrib.flatpages'),
                 "django.contrib.flatpages app not installed.")
     def test_flatpage_sitemap(self):
         "Basic FlatPage sitemap test"
diff --git a/django/contrib/sitemaps/tests/test_generic.py b/django/contrib/sitemaps/tests/test_generic.py
index 5b265736b3..870e29886d 100644
--- a/django/contrib/sitemaps/tests/test_generic.py
+++ b/django/contrib/sitemaps/tests/test_generic.py
@@ -1,6 +1,6 @@
 from __future__ import unicode_literals
 
-from django.test.utils import override_settings
+from django.test import override_settings
 
 from .base import TestModel, SitemapTestsBase
 
diff --git a/django/contrib/sitemaps/tests/test_http.py b/django/contrib/sitemaps/tests/test_http.py
index 61be8c842a..2f9ebd8fad 100644
--- a/django/contrib/sitemaps/tests/test_http.py
+++ b/django/contrib/sitemaps/tests/test_http.py
@@ -4,11 +4,12 @@ import os
 from datetime import date
 from unittest import skipUnless
 
+from django.apps import apps
 from django.conf import settings
 from django.contrib.sitemaps import Sitemap, GenericSitemap
 from django.contrib.sites.models import Site
 from django.core.exceptions import ImproperlyConfigured
-from django.test.utils import override_settings
+from django.test import modify_settings, override_settings
 from django.utils.formats import localize
 from django.utils._os import upath
 from django.utils.translation import activate, deactivate
@@ -105,11 +106,10 @@ class HTTPSitemapTests(SitemapTestsBase):
         self.assertContains(response, '<lastmod>%s</lastmod>' % date.today())
         deactivate()
 
+    @modify_settings(INSTALLED_APPS={'remove': 'django.contrib.sites'})
     def test_requestsite_sitemap(self):
         # Make sure hitting the flatpages sitemap without the sites framework
         # installed doesn't raise an exception.
-        # Reset by SitemapTestsBase.tearDown().
-        Site._meta.app_config.installed = False
         response = self.client.get('/simple/sitemap.xml')
         expected_content = """<?xml version="1.0" encoding="UTF-8"?>
 <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
@@ -118,7 +118,7 @@ class HTTPSitemapTests(SitemapTestsBase):
 """ % date.today()
         self.assertXMLEqual(response.content.decode('utf-8'), expected_content)
 
-    @skipUnless("django.contrib.sites" in settings.INSTALLED_APPS,
+    @skipUnless(apps.is_installed('django.contrib.sites'),
                 "django.contrib.sites app not installed.")
     def test_sitemap_get_urls_no_site_1(self):
         """
@@ -128,14 +128,13 @@ class HTTPSitemapTests(SitemapTestsBase):
         Site.objects.all().delete()
         self.assertRaises(ImproperlyConfigured, Sitemap().get_urls)
 
+    @modify_settings(INSTALLED_APPS={'remove': 'django.contrib.sites'})
     def test_sitemap_get_urls_no_site_2(self):
         """
         Check we get ImproperlyConfigured when we don't pass a site object to
         Sitemap.get_urls if Site objects exists, but the sites framework is not
         actually installed.
         """
-        # Reset by SitemapTestsBase.tearDown().
-        Site._meta.app_config.installed = False
         self.assertRaises(ImproperlyConfigured, Sitemap().get_urls)
 
     def test_sitemap_item(self):
diff --git a/django/contrib/sitemaps/tests/test_https.py b/django/contrib/sitemaps/tests/test_https.py
index 9594d0f7a4..58ff68931e 100644
--- a/django/contrib/sitemaps/tests/test_https.py
+++ b/django/contrib/sitemaps/tests/test_https.py
@@ -2,7 +2,7 @@ from __future__ import unicode_literals
 
 from datetime import date
 
-from django.test.utils import override_settings
+from django.test import override_settings
 
 from .base import SitemapTestsBase
 
diff --git a/django/contrib/sites/apps.py b/django/contrib/sites/apps.py
new file mode 100644
index 0000000000..ea81102da0
--- /dev/null
+++ b/django/contrib/sites/apps.py
@@ -0,0 +1,8 @@
+from django.apps import AppConfig
+
+from django.utils.translation import ugettext_lazy as _
+
+
+class SitesConfig(AppConfig):
+    name = 'django.contrib.sites'
+    verbose_name = _("sites")
diff --git a/django/contrib/sites/management.py b/django/contrib/sites/management.py
index 7dec568fa4..e7624e75cf 100644
--- a/django/contrib/sites/management.py
+++ b/django/contrib/sites/management.py
@@ -2,17 +2,22 @@
 Creates the default Site object.
 """
 
-from django.db.models import signals
-from django.db import connections
-from django.db import router
-from django.contrib.sites.models import Site
-from django.contrib.sites import models as site_app
+from django.apps import apps
 from django.core.management.color import no_style
+from django.db import DEFAULT_DB_ALIAS, connections, router
+from django.db.models import signals
 
 
-def create_default_site(app, created_models, verbosity, db, **kwargs):
-    # Only create the default sites in databases where Django created the table
-    if Site in created_models and router.allow_migrate(db, Site):
+def create_default_site(app_config, verbosity=2, interactive=True, db=DEFAULT_DB_ALIAS, **kwargs):
+    try:
+        Site = apps.get_model('sites', 'Site')
+    except LookupError:
+        return
+
+    if not router.allow_migrate(db, Site):
+        return
+
+    if not Site.objects.exists():
         # The default settings set SITE_ID = 1, and some tests in Django's test
         # suite rely on this value. However, if database sequences are reused
         # (e.g. in the test suite after flush/syncdb), it isn't guaranteed that
@@ -32,6 +37,7 @@ def create_default_site(app, created_models, verbosity, db, **kwargs):
             for command in sequence_sql:
                 cursor.execute(command)
 
-    Site.objects.clear_cache()
+        Site.objects.clear_cache()
 
-signals.post_migrate.connect(create_default_site, sender=site_app)
+
+signals.post_migrate.connect(create_default_site, sender=apps.get_app_config('sites'))
diff --git a/django/contrib/sites/tests.py b/django/contrib/sites/tests.py
index 2be28a1429..efa4fefa44 100644
--- a/django/contrib/sites/tests.py
+++ b/django/contrib/sites/tests.py
@@ -4,19 +4,14 @@ from django.conf import settings
 from django.contrib.sites.models import Site, RequestSite, get_current_site
 from django.core.exceptions import ObjectDoesNotExist, ValidationError
 from django.http import HttpRequest
-from django.test import TestCase
-from django.test.utils import override_settings
+from django.test import TestCase, modify_settings, override_settings
 
 
+@modify_settings(INSTALLED_APPS={'append': 'django.contrib.sites'})
 class SitesFrameworkTests(TestCase):
 
     def setUp(self):
         Site(id=settings.SITE_ID, domain="example.com", name="example.com").save()
-        self._old_installed = Site._meta.app_config.installed
-        Site._meta.app_config.installed = True
-
-    def tearDown(self):
-        Site._meta.app_config.installed = self._old_installed
 
     def test_save_another(self):
         # Regression for #17415
@@ -67,10 +62,10 @@ class SitesFrameworkTests(TestCase):
         self.assertRaises(ObjectDoesNotExist, get_current_site, request)
 
         # A RequestSite is returned if the sites framework is not installed
-        Site._meta.app_config.installed = False
-        site = get_current_site(request)
-        self.assertTrue(isinstance(site, RequestSite))
-        self.assertEqual(site.name, "example.com")
+        with self.modify_settings(INSTALLED_APPS={'remove': 'django.contrib.sites'}):
+            site = get_current_site(request)
+            self.assertTrue(isinstance(site, RequestSite))
+            self.assertEqual(site.name, "example.com")
 
     def test_domain_name_with_whitespaces(self):
         # Regression for #17320
diff --git a/django/contrib/staticfiles/apps.py b/django/contrib/staticfiles/apps.py
new file mode 100644
index 0000000000..abb99c3cea
--- /dev/null
+++ b/django/contrib/staticfiles/apps.py
@@ -0,0 +1,8 @@
+from django.apps import AppConfig
+
+from django.utils.translation import ugettext_lazy as _
+
+
+class StaticFilesConfig(AppConfig):
+    name = 'django.contrib.staticfiles'
+    verbose_name = _("static files")
diff --git a/django/contrib/staticfiles/finders.py b/django/contrib/staticfiles/finders.py
index cf5eb4f85b..eede6fbaa8 100644
--- a/django/contrib/staticfiles/finders.py
+++ b/django/contrib/staticfiles/finders.py
@@ -1,6 +1,7 @@
 from collections import OrderedDict
 import os
 
+from django.apps import apps
 from django.conf import settings
 from django.core.exceptions import ImproperlyConfigured
 from django.core.files.storage import default_storage, Storage, FileSystemStorage
@@ -42,7 +43,7 @@ class FileSystemFinder(BaseFinder):
     A static files finder that uses the ``STATICFILES_DIRS`` setting
     to locate files.
     """
-    def __init__(self, apps=None, *args, **kwargs):
+    def __init__(self, app_names=None, *args, **kwargs):
         # List of locations with static files
         self.locations = []
         # Maps dir paths to an appropriate storage instance
@@ -113,14 +114,15 @@ class AppDirectoriesFinder(BaseFinder):
     """
     storage_class = AppStaticStorage
 
-    def __init__(self, apps=None, *args, **kwargs):
+    def __init__(self, app_names=None, *args, **kwargs):
         # The list of apps that are handled
         self.apps = []
-        # Mapping of app module paths to storage instances
+        # Mapping of app names to storage instances
         self.storages = OrderedDict()
-        if apps is None:
-            apps = settings.INSTALLED_APPS
-        for app in apps:
+        if app_names is None:
+            app_configs = apps.get_app_configs()
+            app_names = [app_config.name for app_config in app_configs]
+        for app in app_names:
             app_storage = self.storage_class(app)
             if os.path.isdir(app_storage.location):
                 self.storages[app] = app_storage
diff --git a/django/contrib/staticfiles/locale/en/LC_MESSAGES/django.po b/django/contrib/staticfiles/locale/en/LC_MESSAGES/django.po
new file mode 100644
index 0000000000..7fd617c346
--- /dev/null
+++ b/django/contrib/staticfiles/locale/en/LC_MESSAGES/django.po
@@ -0,0 +1,22 @@
+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER
+# This file is distributed under the same license as the PACKAGE package.
+# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
+#
+#, fuzzy
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2014-01-04 23:05+0100\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language-Team: LANGUAGE <LL@li.org>\n"
+"Language: \n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: apps.py:8
+msgid "static files"
+msgstr ""
diff --git a/django/contrib/staticfiles/management/commands/collectstatic.py b/django/contrib/staticfiles/management/commands/collectstatic.py
index 67fa6229c4..9009b82c67 100644
--- a/django/contrib/staticfiles/management/commands/collectstatic.py
+++ b/django/contrib/staticfiles/management/commands/collectstatic.py
@@ -137,32 +137,38 @@ class Command(NoArgsCommand):
 
     def handle_noargs(self, **options):
         self.set_options(**options)
-        # Warn before doing anything more.
-        if (isinstance(self.storage, FileSystemStorage) and
+
+        message = ['\n']
+        if self.dry_run:
+            message.append(
+                'You have activated the --dry-run option so no files will be modified.\n\n'
+            )
+
+        message.append(
+            'You have requested to collect static files at the destination\n'
+            'location as specified in your settings'
+        )
+
+        if (isinstance(self.storage._wrapped, FileSystemStorage) and
                 self.storage.location):
             destination_path = self.storage.location
-            destination_display = ':\n\n    %s' % destination_path
+            message.append(':\n\n    %s\n\n' % destination_path)
         else:
             destination_path = None
-            destination_display = '.'
+            message.append('.\n\n')
 
         if self.clear:
-            clear_display = 'This will DELETE EXISTING FILES!'
+            message.append('This will DELETE EXISTING FILES!\n')
         else:
-            clear_display = 'This will overwrite existing files!'
+            message.append('This will overwrite existing files!\n')
 
-        if self.interactive:
-            confirm = input("""
-You have requested to collect static files at the destination
-location as specified in your settings%s
+        message.append(
+            'Are you sure you want to do this?\n\n'
+            "Type 'yes' to continue, or 'no' to cancel: "
+        )
 
-%s
-Are you sure you want to do this?
-
-Type 'yes' to continue, or 'no' to cancel: """
-% (destination_display, clear_display))
-            if confirm != 'yes':
-                raise CommandError("Collecting static files cancelled.")
+        if self.interactive and input(''.join(message)) != 'yes':
+            raise CommandError("Collecting static files cancelled.")
 
         collected = self.collect()
         modified_count = len(collected['modified'])
diff --git a/django/contrib/staticfiles/storage.py b/django/contrib/staticfiles/storage.py
index 5190a299e4..b5d05aa6b2 100644
--- a/django/contrib/staticfiles/storage.py
+++ b/django/contrib/staticfiles/storage.py
@@ -32,16 +32,13 @@ class StaticFilesStorage(FileSystemStorage):
             location = settings.STATIC_ROOT
         if base_url is None:
             base_url = settings.STATIC_URL
-        check_settings(base_url)
-        super(StaticFilesStorage, self).__init__(location, base_url,
-                                                 *args, **kwargs)
-
-    def path(self, name):
-        if not self.location:
+        if not location:
             raise ImproperlyConfigured("You're using the staticfiles app "
                                        "without having set the STATIC_ROOT "
                                        "setting to a filesystem path.")
-        return super(StaticFilesStorage, self).path(name)
+        check_settings(base_url)
+        super(StaticFilesStorage, self).__init__(location, base_url,
+                                                 *args, **kwargs)
 
 
 class CachedFilesMixin(object):
diff --git a/django/contrib/syndication/apps.py b/django/contrib/syndication/apps.py
new file mode 100644
index 0000000000..a63adb3e1b
--- /dev/null
+++ b/django/contrib/syndication/apps.py
@@ -0,0 +1,8 @@
+from django.apps import AppConfig
+
+from django.utils.translation import ugettext_lazy as _
+
+
+class SyndicationConfig(AppConfig):
+    name = 'django.contrib.syndication'
+    verbose_name = _("syndication")
diff --git a/django/contrib/syndication/locale/en/LC_MESSAGES/django.po b/django/contrib/syndication/locale/en/LC_MESSAGES/django.po
new file mode 100644
index 0000000000..0bb22cbafe
--- /dev/null
+++ b/django/contrib/syndication/locale/en/LC_MESSAGES/django.po
@@ -0,0 +1,22 @@
+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER
+# This file is distributed under the same license as the PACKAGE package.
+# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
+#
+#, fuzzy
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2014-01-04 23:05+0100\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language-Team: LANGUAGE <LL@li.org>\n"
+"Language: \n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: apps.py:8
+msgid "syndication"
+msgstr ""
diff --git a/django/contrib/webdesign/apps.py b/django/contrib/webdesign/apps.py
new file mode 100644
index 0000000000..87047edaf0
--- /dev/null
+++ b/django/contrib/webdesign/apps.py
@@ -0,0 +1,8 @@
+from django.apps import AppConfig
+
+from django.utils.translation import ugettext_lazy as _
+
+
+class WebDesignConfig(AppConfig):
+    name = 'django.contrib.webdesign'
+    verbose_name = _("web design")
diff --git a/django/contrib/webdesign/locale/en/LC_MESSAGES/django.po b/django/contrib/webdesign/locale/en/LC_MESSAGES/django.po
new file mode 100644
index 0000000000..2ae0ee7272
--- /dev/null
+++ b/django/contrib/webdesign/locale/en/LC_MESSAGES/django.po
@@ -0,0 +1,22 @@
+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER
+# This file is distributed under the same license as the PACKAGE package.
+# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
+#
+#, fuzzy
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2014-01-04 23:05+0100\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language-Team: LANGUAGE <LL@li.org>\n"
+"Language: \n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: apps.py:8
+msgid "web design"
+msgstr ""
diff --git a/django/core/apps/__init__.py b/django/core/apps/__init__.py
deleted file mode 100644
index 0384b1257d..0000000000
--- a/django/core/apps/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-from .cache import app_cache, UnavailableApp    # NOQA
diff --git a/django/core/apps/base.py b/django/core/apps/base.py
deleted file mode 100644
index 860777bb03..0000000000
--- a/django/core/apps/base.py
+++ /dev/null
@@ -1,47 +0,0 @@
-from collections import OrderedDict
-
-from django.utils._os import upath
-
-
-class AppConfig(object):
-    """
-    Class representing a Django application and its configuration.
-    """
-
-    def __init__(self, name, app_module, models_module):
-        # Full Python path to the application eg. 'django.contrib.admin'.
-        # This is the value that appears in INSTALLED_APPS.
-        self.name = name
-
-        # Last component of the Python path to the application eg. 'admin'.
-        # This value must be unique across a Django project.
-        self.label = name.rpartition(".")[2]
-
-        # Root module eg. <module 'django.contrib.admin' from
-        # 'django/contrib/admin/__init__.pyc'>.
-        self.app_module = app_module
-
-        # Module containing models eg. <module 'django.contrib.admin.models'
-        # from 'django/contrib/admin/models.pyc'>. None if the application
-        # doesn't have a models module.
-        self.models_module = models_module
-
-        # Mapping of lower case model names to model classes.
-        # Populated by calls to AppCache.register_model().
-        self.models = OrderedDict()
-
-        # Whether the app is in INSTALLED_APPS or was automatically created
-        # when one of its models was imported.
-        self.installed = app_module is not None
-
-        # Filesystem path to the application directory eg.
-        # u'/usr/lib/python2.7/dist-packages/django/contrib/admin'.
-        # This is a unicode object on Python 2 and a str on Python 3.
-        self.path = upath(app_module.__path__[0]) if app_module is not None else None
-
-    @classmethod
-    def _stub(cls, label):
-        return cls(label, None, None)
-
-    def __repr__(self):
-        return '<AppConfig: %s>' % self.label
diff --git a/django/core/apps/cache.py b/django/core/apps/cache.py
deleted file mode 100644
index b076fc1968..0000000000
--- a/django/core/apps/cache.py
+++ /dev/null
@@ -1,395 +0,0 @@
-"Utilities for loading models and the modules that contain them."
-
-from collections import OrderedDict
-import imp
-from importlib import import_module
-import os
-import sys
-import warnings
-
-from django.conf import settings
-from django.core.exceptions import ImproperlyConfigured
-from django.utils.module_loading import module_has_submodule
-from django.utils._os import upath
-from django.utils import six
-
-from .base import AppConfig
-
-
-MODELS_MODULE_NAME = 'models'
-
-
-class UnavailableApp(Exception):
-    pass
-
-
-class AppCache(object):
-    """
-    A cache that stores installed applications and their models. Used to
-    provide reverse-relations and for app introspection.
-    """
-
-    def __init__(self, master=False):
-        # Only one master of the app-cache may exist at a given time, and it
-        # shall be the app_cache variable defined at the end of this module.
-        if master and hasattr(sys.modules[__name__], 'app_cache'):
-            raise RuntimeError("You may create only one master app cache.")
-
-        # When master is set to False, the app cache isn't populated from
-        # INSTALLED_APPS and ignores the only_installed arguments to
-        # get_model[s].
-        self.master = master
-
-        # Mapping of labels to AppConfig instances for installed apps.
-        self.app_configs = OrderedDict()
-
-        # Pending lookups for lazy relations
-        self.pending_lookups = {}
-
-        # Set of app names. Allows restricting the set of installed apps.
-        # Used by TransactionTestCase.available_apps for performance reasons.
-        self.available_apps = None
-
-        # -- Everything below here is only used when populating the cache --
-        self.loaded = False
-        self.handled = set()
-        self.postponed = []
-        self.nesting_level = 0
-        self._get_models_cache = {}
-
-    def populate(self):
-        """
-        Fill in all the cache information. This method is threadsafe, in the
-        sense that every caller will see the same state upon return, and if the
-        cache is already initialised, it does no work.
-        """
-        if self.loaded:
-            return
-        if not self.master:
-            self.loaded = True
-            return
-        # Note that we want to use the import lock here - the app loading is
-        # in many cases initiated implicitly by importing, and thus it is
-        # possible to end up in deadlock when one thread initiates loading
-        # without holding the importer lock and another thread then tries to
-        # import something which also launches the app loading. For details of
-        # this situation see #18251.
-        imp.acquire_lock()
-        try:
-            if self.loaded:
-                return
-            for app_name in settings.INSTALLED_APPS:
-                if app_name in self.handled:
-                    continue
-                self.load_app(app_name, can_postpone=True)
-            if not self.nesting_level:
-                for app_name in self.postponed:
-                    self.load_app(app_name)
-                self.loaded = True
-        finally:
-            imp.release_lock()
-
-    def load_app(self, app_name, can_postpone=False):
-        """
-        Loads the app with the provided fully qualified name, and returns the
-        model module.
-        """
-        app_module = import_module(app_name)
-        self.handled.add(app_name)
-        self.nesting_level += 1
-        try:
-            models_module = import_module('%s.%s' % (app_name, MODELS_MODULE_NAME))
-        except ImportError:
-            # If the app doesn't have a models module, we can just swallow the
-            # ImportError and return no models for this app.
-            if not module_has_submodule(app_module, MODELS_MODULE_NAME):
-                models_module = None
-            # But if the app does have a models module, we need to figure out
-            # whether to suppress or propagate the error. If can_postpone is
-            # True then it may be that the package is still being imported by
-            # Python and the models module isn't available yet. So we add the
-            # app to the postponed list and we'll try it again after all the
-            # recursion has finished (in populate). If can_postpone is False
-            # then it's time to raise the ImportError.
-            else:
-                if can_postpone:
-                    self.postponed.append(app_name)
-                    return
-                else:
-                    raise
-        finally:
-            self.nesting_level -= 1
-
-        app_config = AppConfig(
-            name=app_name, app_module=app_module, models_module=models_module)
-        # If a stub config existed for this app, preserve models registry.
-        old_app_config = self.app_configs.get(app_config.label)
-        if old_app_config is not None:
-            app_config.models = old_app_config.models
-        self.app_configs[app_config.label] = app_config
-
-        return models_module
-
-    def app_cache_ready(self):
-        """
-        Returns true if the model cache is fully populated.
-
-        Useful for code that wants to cache the results of get_models() for
-        themselves once it is safe to do so.
-        """
-        return self.loaded
-
-    def get_app_configs(self, only_installed=True, only_with_models_module=False):
-        """
-        Return an iterable of application configurations.
-
-        If only_installed is True (default), only applications explicitly
-        listed in INSTALLED_APPS are considered.
-
-        If only_with_models_module in True (non-default), only applications
-        containing a models module are considered.
-        """
-        self.populate()
-        for app_config in self.app_configs.values():
-            if only_installed and not app_config.installed:
-                continue
-            if only_with_models_module and app_config.models_module is None:
-                continue
-            if self.available_apps is not None and app_config.name not in self.available_apps:
-                continue
-            yield app_config
-
-    def get_app_config(self, app_label, only_installed=True, only_with_models_module=False):
-        """
-        Returns the application configuration for the given app_label.
-
-        Raises LookupError if no application exists with this app_label.
-
-        Raises UnavailableApp when set_available_apps() disables the
-        application with this app_label.
-
-        If only_installed is True (default), only applications explicitly
-        listed in INSTALLED_APPS are considered.
-
-        If only_with_models_module in True (non-default), only applications
-        containing a models module are considered.
-        """
-        self.populate()
-        app_config = self.app_configs.get(app_label)
-        if app_config is None:
-            raise LookupError("No app with label %r." % app_label)
-        if only_installed and not app_config.installed:
-            raise LookupError("App with label %r isn't in INSTALLED_APPS." % app_label)
-        if only_with_models_module and app_config.models_module is None:
-            raise LookupError("App with label %r doesn't have a models module." % app_label)
-        if self.available_apps is not None and app_config.name not in self.available_apps:
-            raise UnavailableApp("App with label %r isn't available." % app_label)
-        return app_config
-
-    def get_models(self, app_mod=None,
-                   include_auto_created=False, include_deferred=False,
-                   only_installed=True, include_swapped=False):
-        """
-        Given a module containing models, returns a list of the models.
-        Otherwise returns a list of all installed models.
-
-        By default, auto-created models (i.e., m2m models without an
-        explicit intermediate table) are not included. However, if you
-        specify include_auto_created=True, they will be.
-
-        By default, models created to satisfy deferred attribute
-        queries are *not* included in the list of models. However, if
-        you specify include_deferred, they will be.
-
-        By default, models that aren't part of installed apps will *not*
-        be included in the list of models. However, if you specify
-        only_installed=False, they will be. If you're using a non-default
-        AppCache, this argument does nothing - all models will be included.
-
-        By default, models that have been swapped out will *not* be
-        included in the list of models. However, if you specify
-        include_swapped, they will be.
-        """
-        if not self.master:
-            only_installed = False
-        cache_key = (app_mod, include_auto_created, include_deferred, only_installed, include_swapped)
-        model_list = None
-        try:
-            model_list = self._get_models_cache[cache_key]
-            if self.available_apps is not None and only_installed:
-                model_list = [
-                    m for m in model_list
-                    if self.app_configs[m._meta.app_label].name in self.available_apps
-                ]
-            return model_list
-        except KeyError:
-            pass
-        self.populate()
-        if app_mod:
-            app_label = app_mod.__name__.split('.')[-2]
-            try:
-                app_config = self.app_configs[app_label]
-            except KeyError:
-                app_list = []
-            else:
-                app_list = [app_config] if app_config.installed else []
-        else:
-            app_list = six.itervalues(self.app_configs)
-            if only_installed:
-                app_list = (app for app in app_list if app.installed)
-        model_list = []
-        for app in app_list:
-            model_list.extend(
-                model for model in app.models.values()
-                if ((not model._deferred or include_deferred) and
-                    (not model._meta.auto_created or include_auto_created) and
-                    (not model._meta.swapped or include_swapped))
-            )
-        self._get_models_cache[cache_key] = model_list
-        if self.available_apps is not None and only_installed:
-            model_list = [
-                m for m in model_list
-                if self.app_configs[m._meta.app_label].name in self.available_apps
-            ]
-        return model_list
-
-    def get_model(self, app_label, model_name,
-                  seed_cache=True, only_installed=True):
-        """
-        Returns the model matching the given app_label and case-insensitive
-        model_name.
-
-        Returns None if no model is found.
-
-        Raises UnavailableApp when set_available_apps() in in effect and
-        doesn't include app_label.
-        """
-        if not self.master:
-            only_installed = False
-        if seed_cache:
-            self.populate()
-        if only_installed:
-            app_config = self.app_configs.get(app_label)
-            if app_config is not None and not app_config.installed:
-                return None
-            if (self.available_apps is not None
-                    and app_config.name not in self.available_apps):
-                raise UnavailableApp("App with label %s isn't available." % app_label)
-        try:
-            return self.app_configs[app_label].models[model_name.lower()]
-        except KeyError:
-            return None
-
-    def register_model(self, app_label, model):
-        try:
-            app_config = self.app_configs[app_label]
-        except KeyError:
-            app_config = AppConfig._stub(app_label)
-            self.app_configs[app_label] = app_config
-        # Add the model to the app_config's models dictionary.
-        model_name = model._meta.model_name
-        model_dict = app_config.models
-        if model_name in model_dict:
-            # The same model may be imported via different paths (e.g.
-            # appname.models and project.appname.models). We use the source
-            # filename as a means to detect identity.
-            fname1 = os.path.abspath(upath(sys.modules[model.__module__].__file__))
-            fname2 = os.path.abspath(upath(sys.modules[model_dict[model_name].__module__].__file__))
-            # Since the filename extension could be .py the first time and
-            # .pyc or .pyo the second time, ignore the extension when
-            # comparing.
-            if os.path.splitext(fname1)[0] == os.path.splitext(fname2)[0]:
-                return
-        model_dict[model_name] = model
-        self._get_models_cache.clear()
-
-    def set_available_apps(self, available):
-        available = set(available)
-        installed = set(settings.INSTALLED_APPS)
-        if not available.issubset(installed):
-            raise ValueError("Available apps isn't a subset of installed "
-                "apps, extra apps: %s" % ", ".join(available - installed))
-        self.available_apps = available
-
-    def unset_available_apps(self):
-        self.available_apps = None
-
-    ### DEPRECATED METHODS GO BELOW THIS LINE ###
-
-    def get_app(self, app_label):
-        """
-        Returns the module containing the models for the given app_label.
-
-        Raises UnavailableApp when set_available_apps() in in effect and
-        doesn't include app_label.
-        """
-        warnings.warn(
-            "get_app_config(app_label).models_module supersedes get_app(app_label).",
-            PendingDeprecationWarning, stacklevel=2)
-        try:
-            return self.get_app_config(app_label).models_module
-        except LookupError as exc:
-            # Change the exception type for backwards compatibility.
-            raise ImproperlyConfigured(*exc.args)
-
-    def get_apps(self):
-        """
-        Returns a list of all installed modules that contain models.
-        """
-        warnings.warn(
-            "[a.models_module for a in get_app_configs()] supersedes get_apps().",
-            PendingDeprecationWarning, stacklevel=2)
-        return [app_config.models_module for app_config in self.get_app_configs()]
-
-    def _get_app_package(self, app):
-        return '.'.join(app.__name__.split('.')[:-1])
-
-    def get_app_package(self, app_label):
-        warnings.warn(
-            "get_app_config(label).name supersedes get_app_package(label).",
-            PendingDeprecationWarning, stacklevel=2)
-        return self._get_app_package(self.get_app(app_label))
-
-    def _get_app_path(self, app):
-        if hasattr(app, '__path__'):        # models/__init__.py package
-            app_path = app.__path__[0]
-        else:                               # models.py module
-            app_path = app.__file__
-        return os.path.dirname(upath(app_path))
-
-    def get_app_path(self, app_label):
-        warnings.warn(
-            "get_app_config(label).path supersedes get_app_path(label).",
-            PendingDeprecationWarning, stacklevel=2)
-        return self._get_app_path(self.get_app(app_label))
-
-    def get_app_paths(self):
-        """
-        Returns a list of paths to all installed apps.
-
-        Useful for discovering files at conventional locations inside apps
-        (static files, templates, etc.)
-        """
-        warnings.warn(
-            "[a.path for a in get_app_configs()] supersedes get_app_paths().",
-            PendingDeprecationWarning, stacklevel=2)
-
-        self.populate()
-
-        app_paths = []
-        for app in self.get_apps():
-            app_paths.append(self._get_app_path(app))
-        return app_paths
-
-    def register_models(self, app_label, *models):
-        """
-        Register a set of models as belonging to an app.
-        """
-        warnings.warn(
-            "register_models(app_label, models) is deprecated.",
-            PendingDeprecationWarning, stacklevel=2)
-        for model in models:
-            self.register_model(app_label, model)
-
-
-app_cache = AppCache(master=True)
diff --git a/django/core/checks/compatibility/django_1_6_0.py b/django/core/checks/compatibility/django_1_6_0.py
index fef8bc3a51..1be727f70d 100644
--- a/django/core/checks/compatibility/django_1_6_0.py
+++ b/django/core/checks/compatibility/django_1_6_0.py
@@ -1,6 +1,6 @@
 from __future__ import unicode_literals
 
-from django.core.apps import app_cache
+from django.apps import apps
 from django.db import models
 
 
@@ -32,7 +32,7 @@ def check_boolean_field_default_value():
     warns the user that the default has changed from False to Null.
     """
     fields = []
-    for cls in app_cache.get_models():
+    for cls in apps.get_models():
         opts = cls._meta
         for f in opts.local_fields:
             if isinstance(f, models.BooleanField) and not f.has_default():
diff --git a/django/core/handlers/wsgi.py b/django/core/handlers/wsgi.py
index 21cadf48b8..46efd0477e 100644
--- a/django/core/handlers/wsgi.py
+++ b/django/core/handlers/wsgi.py
@@ -14,6 +14,7 @@ from django.core.handlers import base
 from django.core.urlresolvers import set_script_prefix
 from django.utils import datastructures
 from django.utils.encoding import force_str, force_text
+from django.utils.functional import cached_property
 from django.utils import six
 
 # For backwards compatibility -- lots of code uses this in the wild!
@@ -136,15 +137,11 @@ class WSGIRequest(http.HttpRequest):
             self._request = datastructures.MergeDict(self.POST, self.GET)
         return self._request
 
-    def _get_get(self):
-        if not hasattr(self, '_get'):
-            # The WSGI spec says 'QUERY_STRING' may be absent.
-            raw_query_string = get_bytes_from_wsgi(self.environ, 'QUERY_STRING', '')
-            self._get = http.QueryDict(raw_query_string, encoding=self._encoding)
-        return self._get
-
-    def _set_get(self, get):
-        self._get = get
+    @cached_property
+    def GET(self):
+        # The WSGI spec says 'QUERY_STRING' may be absent.
+        raw_query_string = get_bytes_from_wsgi(self.environ, 'QUERY_STRING', '')
+        return http.QueryDict(raw_query_string, encoding=self._encoding)
 
     def _get_post(self):
         if not hasattr(self, '_post'):
@@ -154,23 +151,17 @@ class WSGIRequest(http.HttpRequest):
     def _set_post(self, post):
         self._post = post
 
-    def _get_cookies(self):
-        if not hasattr(self, '_cookies'):
-            raw_cookie = get_str_from_wsgi(self.environ, 'HTTP_COOKIE', '')
-            self._cookies = http.parse_cookie(raw_cookie)
-        return self._cookies
-
-    def _set_cookies(self, cookies):
-        self._cookies = cookies
+    @cached_property
+    def COOKIES(self):
+        raw_cookie = get_str_from_wsgi(self.environ, 'HTTP_COOKIE', '')
+        return http.parse_cookie(raw_cookie)
 
     def _get_files(self):
         if not hasattr(self, '_files'):
             self._load_post_and_files()
         return self._files
 
-    GET = property(_get_get, _set_get)
     POST = property(_get_post, _set_post)
-    COOKIES = property(_get_cookies, _set_cookies)
     FILES = property(_get_files)
     REQUEST = property(_get_request)
 
diff --git a/django/core/mail/backends/console.py b/django/core/mail/backends/console.py
index d0ecac74ea..0ce88534ea 100644
--- a/django/core/mail/backends/console.py
+++ b/django/core/mail/backends/console.py
@@ -5,6 +5,7 @@ import sys
 import threading
 
 from django.core.mail.backends.base import BaseEmailBackend
+from django.utils import six
 
 
 class EmailBackend(BaseEmailBackend):
@@ -13,6 +14,16 @@ class EmailBackend(BaseEmailBackend):
         self._lock = threading.RLock()
         super(EmailBackend, self).__init__(*args, **kwargs)
 
+    def write_message(self, message):
+        msg = message.message()
+        msg_data = msg.as_bytes()
+        if six.PY3:
+            charset = msg.get_charset().get_output_charset() if msg.get_charset() else 'utf-8'
+            msg_data = msg_data.decode(charset)
+        self.stream.write('%s\n' % msg_data)
+        self.stream.write('-' * 79)
+        self.stream.write('\n')
+
     def send_messages(self, email_messages):
         """Write all messages to the stream in a thread-safe way."""
         if not email_messages:
@@ -22,9 +33,7 @@ class EmailBackend(BaseEmailBackend):
             try:
                 stream_created = self.open()
                 for message in email_messages:
-                    self.stream.write('%s\n' % message.message().as_string())
-                    self.stream.write('-' * 79)
-                    self.stream.write('\n')
+                    self.write_message(message)
                     self.stream.flush()  # flush after each message
                     msg_count += 1
                 if stream_created:
diff --git a/django/core/mail/backends/filebased.py b/django/core/mail/backends/filebased.py
index 3f26551dab..5caedd5802 100644
--- a/django/core/mail/backends/filebased.py
+++ b/django/core/mail/backends/filebased.py
@@ -38,6 +38,11 @@ class EmailBackend(ConsoleEmailBackend):
         kwargs['stream'] = None
         super(EmailBackend, self).__init__(*args, **kwargs)
 
+    def write_message(self, message):
+        self.stream.write(message.message().as_bytes() + b'\n')
+        self.stream.write(b'-' * 79)
+        self.stream.write(b'\n')
+
     def _get_filename(self):
         """Return a unique file name."""
         if self._fname is None:
@@ -48,7 +53,7 @@ class EmailBackend(ConsoleEmailBackend):
 
     def open(self):
         if self.stream is None:
-            self.stream = open(self._get_filename(), 'a')
+            self.stream = open(self._get_filename(), 'ab')
             return True
         return False
 
diff --git a/django/core/mail/backends/smtp.py b/django/core/mail/backends/smtp.py
index c9e0a18728..e72e372ca9 100644
--- a/django/core/mail/backends/smtp.py
+++ b/django/core/mail/backends/smtp.py
@@ -7,7 +7,6 @@ from django.conf import settings
 from django.core.mail.backends.base import BaseEmailBackend
 from django.core.mail.utils import DNS_NAME
 from django.core.mail.message import sanitize_address
-from django.utils.encoding import force_bytes
 
 
 class EmailBackend(BaseEmailBackend):
@@ -111,10 +110,8 @@ class EmailBackend(BaseEmailBackend):
         recipients = [sanitize_address(addr, email_message.encoding)
                       for addr in email_message.recipients()]
         message = email_message.message()
-        charset = message.get_charset().get_output_charset() if message.get_charset() else 'utf-8'
         try:
-            self.connection.sendmail(from_email, recipients,
-                    force_bytes(message.as_string(), charset))
+            self.connection.sendmail(from_email, recipients, message.as_bytes())
         except smtplib.SMTPException:
             if not self.fail_silently:
                 raise
diff --git a/django/core/mail/message.py b/django/core/mail/message.py
index 85699aacec..cdd265521b 100644
--- a/django/core/mail/message.py
+++ b/django/core/mail/message.py
@@ -3,9 +3,10 @@ from __future__ import unicode_literals
 import mimetypes
 import os
 import random
+import sys
 import time
-from email import charset as Charset, encoders as Encoders, message_from_string
-from email.generator import Generator
+from email import (charset as Charset, encoders as Encoders,
+    message_from_string, generator)
 from email.message import Message
 from email.mime.text import MIMEText
 from email.mime.multipart import MIMEMultipart
@@ -121,13 +122,7 @@ def sanitize_address(addr, encoding):
     return formataddr((nm, addr))
 
 
-class SafeMIMEMessage(MIMEMessage):
-
-    def __setitem__(self, name, val):
-        # message/rfc822 attachments must be ASCII
-        name, val = forbid_multi_line_headers(name, val, 'ascii')
-        MIMEMessage.__setitem__(self, name, val)
-
+class MIMEMixin():
     def as_string(self, unixfrom=False):
         """Return the entire formatted message as a string.
         Optional `unixfrom' when True, means include the Unix From_ envelope
@@ -137,12 +132,36 @@ class SafeMIMEMessage(MIMEMessage):
         lines that begin with 'From '. See bug #13433 for details.
         """
         fp = six.StringIO()
-        g = Generator(fp, mangle_from_=False)
+        g = generator.Generator(fp, mangle_from_=False)
         g.flatten(self, unixfrom=unixfrom)
         return fp.getvalue()
 
+    if six.PY2:
+        as_bytes = as_string
+    else:
+        def as_bytes(self, unixfrom=False):
+            """Return the entire formatted message as bytes.
+            Optional `unixfrom' when True, means include the Unix From_ envelope
+            header.
 
-class SafeMIMEText(MIMEText):
+            This overrides the default as_bytes() implementation to not mangle
+            lines that begin with 'From '. See bug #13433 for details.
+            """
+            fp = six.BytesIO()
+            g = generator.BytesGenerator(fp, mangle_from_=False)
+            g.flatten(self, unixfrom=unixfrom)
+            return fp.getvalue()
+
+
+class SafeMIMEMessage(MIMEMixin, MIMEMessage):
+
+    def __setitem__(self, name, val):
+        # message/rfc822 attachments must be ASCII
+        name, val = forbid_multi_line_headers(name, val, 'ascii')
+        MIMEMessage.__setitem__(self, name, val)
+
+
+class SafeMIMEText(MIMEMixin, MIMEText):
 
     def __init__(self, text, subtype, charset):
         self.encoding = charset
@@ -152,7 +171,13 @@ class SafeMIMEText(MIMEText):
             # We do it manually and trigger re-encoding of the payload.
             MIMEText.__init__(self, text, subtype, None)
             del self['Content-Transfer-Encoding']
-            self.set_payload(text, utf8_charset)
+            # Workaround for versions without http://bugs.python.org/issue19063
+            if (3, 2) < sys.version_info < (3, 3, 4):
+                payload = text.encode(utf8_charset.output_charset)
+                self._payload = payload.decode('ascii', 'surrogateescape')
+                self.set_charset(utf8_charset)
+            else:
+                self.set_payload(text, utf8_charset)
             self.replace_header('Content-Type', 'text/%s; charset="%s"' % (subtype, charset))
         else:
             MIMEText.__init__(self, text, subtype, charset)
@@ -161,21 +186,8 @@ class SafeMIMEText(MIMEText):
         name, val = forbid_multi_line_headers(name, val, self.encoding)
         MIMEText.__setitem__(self, name, val)
 
-    def as_string(self, unixfrom=False):
-        """Return the entire formatted message as a string.
-        Optional `unixfrom' when True, means include the Unix From_ envelope
-        header.
 
-        This overrides the default as_string() implementation to not mangle
-        lines that begin with 'From '. See bug #13433 for details.
-        """
-        fp = six.StringIO()
-        g = Generator(fp, mangle_from_=False)
-        g.flatten(self, unixfrom=unixfrom)
-        return fp.getvalue()
-
-
-class SafeMIMEMultipart(MIMEMultipart):
+class SafeMIMEMultipart(MIMEMixin, MIMEMultipart):
 
     def __init__(self, _subtype='mixed', boundary=None, _subparts=None, encoding=None, **_params):
         self.encoding = encoding
@@ -185,19 +197,6 @@ class SafeMIMEMultipart(MIMEMultipart):
         name, val = forbid_multi_line_headers(name, val, self.encoding)
         MIMEMultipart.__setitem__(self, name, val)
 
-    def as_string(self, unixfrom=False):
-        """Return the entire formatted message as a string.
-        Optional `unixfrom' when True, means include the Unix From_ envelope
-        header.
-
-        This overrides the default as_string() implementation to not mangle
-        lines that begin with 'From '. See bug #13433 for details.
-        """
-        fp = six.StringIO()
-        g = Generator(fp, mangle_from_=False)
-        g.flatten(self, unixfrom=unixfrom)
-        return fp.getvalue()
-
 
 class EmailMessage(object):
     """
diff --git a/django/core/management/__init__.py b/django/core/management/__init__.py
index 0b47e179db..6d0cb7ea3d 100644
--- a/django/core/management/__init__.py
+++ b/django/core/management/__init__.py
@@ -5,18 +5,18 @@ from optparse import OptionParser, NO_DEFAULT
 import os
 import sys
 
+import django
+from django.apps import apps
+from django.conf import settings
 from django.core.exceptions import ImproperlyConfigured
 from django.core.management.base import BaseCommand, CommandError, handle_default_options
 from django.core.management.color import color_style
+from django.utils import lru_cache
 from django.utils import six
 
 # For backwards compatibility: get_version() used to be in this module.
 from django import get_version
 
-# A cache of loaded commands, so that call_command
-# doesn't have to reload every time it's called.
-_commands = None
-
 
 def find_commands(management_dir):
     """
@@ -40,6 +40,9 @@ def find_management_module(app_name):
 
     Raises ImportError if the management module cannot be found for any reason.
     """
+    # TODO: this method is only called from get_commands() which has already
+    # imported the application module at that point.
+
     parts = app_name.split('.')
     parts.append('management')
     parts.reverse()
@@ -79,6 +82,7 @@ def load_command_class(app_name, name):
     return module.Command()
 
 
+@lru_cache.lru_cache(maxsize=None)
 def get_commands():
     """
     Returns a dictionary mapping command names to their callback applications.
@@ -101,28 +105,28 @@ def get_commands():
     The dictionary is cached on the first call and reused on subsequent
     calls.
     """
-    global _commands
-    if _commands is None:
-        _commands = dict((name, 'django.core') for name in find_commands(__path__[0]))
+    commands = {name: 'django.core' for name in find_commands(__path__[0])}
 
-        # Find the installed apps
-        from django.conf import settings
+    # Find the installed apps
+    try:
+        settings.INSTALLED_APPS
+    except ImproperlyConfigured:
+        # Still useful for commands that do not require functional
+        # settings, like startproject or help.
+        app_names = []
+    else:
+        app_configs = apps.get_app_configs()
+        app_names = [app_config.name for app_config in app_configs]
+
+    # Find and load the management module for each installed app.
+    for app_name in reversed(app_names):
         try:
-            apps = settings.INSTALLED_APPS
-        except ImproperlyConfigured:
-            # Still useful for commands that do not require functional settings,
-            # like startproject or help
-            apps = []
+            path = find_management_module(app_name)
+            commands.update({name: app_name for name in find_commands(path)})
+        except ImportError:
+            pass  # No management module - ignore this app
 
-        # Find and load the management module for each installed app.
-        for app_name in apps:
-            try:
-                path = find_management_module(app_name)
-                _commands.update(dict((name, app_name) for name in find_commands(path)))
-            except ImportError:
-                pass  # No management module - ignore this app
-
-    return _commands
+    return commands
 
 
 def call_command(name, *args, **options):
@@ -257,7 +261,6 @@ class ManagementUtility(object):
                     usage.append("    %s" % name)
             # Output an extra note if settings are not properly configured
             try:
-                from django.conf import settings
                 settings.INSTALLED_APPS
             except ImproperlyConfigured as e:
                 usage.append(style.NOTICE(
@@ -339,9 +342,9 @@ class ManagementUtility(object):
             elif cwords[0] in ('dumpdata', 'sql', 'sqlall', 'sqlclear',
                     'sqlcustom', 'sqlindexes', 'sqlsequencereset', 'test'):
                 try:
-                    from django.conf import settings
+                    app_configs = apps.get_app_configs()
                     # Get the last part of the dotted path as the app name.
-                    options += [(a.split('.')[-1], 0) for a in settings.INSTALLED_APPS]
+                    options += [(app_config.label, 0) for app_config in app_configs]
                 except ImportError:
                     # Fail silently if DJANGO_SETTINGS_MODULE isn't set. The
                     # user will find out once they execute the command.
@@ -380,6 +383,14 @@ class ManagementUtility(object):
         except:  # Needed because parser.parse_args can raise SystemExit
             pass  # Ignore any option errors at this point.
 
+        try:
+            settings.INSTALLED_APPS
+        except ImproperlyConfigured:
+            # Some commands are supposed to work without configured settings
+            pass
+        else:
+            django.setup()
+
         try:
             subcommand = self.argv[1]
         except IndexError:
diff --git a/django/core/management/base.py b/django/core/management/base.py
index aeb27e1f0b..e55f777b75 100644
--- a/django/core/management/base.py
+++ b/django/core/management/base.py
@@ -7,6 +7,7 @@ from __future__ import unicode_literals
 
 import os
 import sys
+import warnings
 
 from optparse import make_option, OptionParser
 
@@ -112,8 +113,8 @@ class BaseCommand(object):
     ``args``
         A string listing the arguments accepted by the command,
         suitable for use in help messages; e.g., a command which takes
-        a list of application names might set this to '<appname
-        appname ...>'.
+        a list of application names might set this to '<app_label
+        app_label ...>'.
 
     ``can_import_settings``
         A boolean indicating whether the command needs to be able to
@@ -140,8 +141,8 @@ class BaseCommand(object):
         performed prior to executing the command. Default value is
         ``True``. To validate an individual application's models
         rather than all applications' models, call
-        ``self.validate(app)`` from ``handle()``, where ``app`` is the
-        application's Python module.
+        ``self.validate(app_config)`` from ``handle()``, where ``app_config``
+        is the application's configuration provided by the app registry.
 
     ``leave_locale_alone``
         A boolean indicating whether the locale set in settings should be
@@ -303,16 +304,16 @@ class BaseCommand(object):
             if saved_locale is not None:
                 translation.activate(saved_locale)
 
-    def validate(self, app=None, display_num_errors=False):
+    def validate(self, app_config=None, display_num_errors=False):
         """
         Validates the given app, raising CommandError for any errors.
 
-        If app is None, then this will validate all installed apps.
+        If app_config is None, then this will validate all installed apps.
 
         """
         from django.core.management.validation import get_validation_errors
         s = StringIO()
-        num_errors = get_validation_errors(s, app)
+        num_errors = get_validation_errors(s, app_config)
         if num_errors:
             s.seek(0)
             error_text = s.read()
@@ -331,42 +332,54 @@ class BaseCommand(object):
 
 class AppCommand(BaseCommand):
     """
-    A management command which takes one or more installed application
-    names as arguments, and does something with each of them.
+    A management command which takes one or more installed application labels
+    as arguments, and does something with each of them.
 
     Rather than implementing ``handle()``, subclasses must implement
-    ``handle_app()``, which will be called once for each application.
-
+    ``handle_app_config()``, which will be called once for each application.
     """
-    args = '<appname appname ...>'
+    args = '<app_label app_label ...>'
 
     def handle(self, *app_labels, **options):
-        from django.core.apps import app_cache
+        from django.apps import apps
         if not app_labels:
-            raise CommandError('Enter at least one appname.')
+            raise CommandError("Enter at least one application label.")
         try:
-            app_configs = [app_cache.get_app_config(app_label) for app_label in app_labels]
+            app_configs = [apps.get_app_config(app_label) for app_label in app_labels]
         except (LookupError, ImportError) as e:
             raise CommandError("%s. Are you sure your INSTALLED_APPS setting is correct?" % e)
         output = []
         for app_config in app_configs:
-            if app_config.models_module is None:
-                raise CommandError(
-                    "AppCommand cannot handle app %r because it doesn't have "
-                    "a models module." % app_config.label)
-            app_output = self.handle_app(app_config.models_module, **options)
+            app_output = self.handle_app_config(app_config, **options)
             if app_output:
                 output.append(app_output)
         return '\n'.join(output)
 
-    def handle_app(self, app, **options):
+    def handle_app_config(self, app_config, **options):
         """
-        Perform the command's actions for ``app``, which will be the
-        Python module corresponding to an application name given on
-        the command line.
-
+        Perform the command's actions for app_config, an AppConfig instance
+        corresponding to an application label given on the command line.
         """
-        raise NotImplementedError('subclasses of AppCommand must provide a handle_app() method')
+        try:
+            # During the deprecation path, keep delegating to handle_app if
+            # handle_app_config isn't implemented in a subclass.
+            handle_app = self.handle_app
+        except AttributeError:
+            # Keep only this exception when the deprecation completes.
+            raise NotImplementedError(
+                "Subclasses of AppCommand must provide"
+                "a handle_app_config() method.")
+        else:
+            warnings.warn(
+                "AppCommand.handle_app() is superseded by "
+                "AppCommand.handle_app_config().",
+                PendingDeprecationWarning, stacklevel=2)
+            if app_config.models_module is None:
+                raise CommandError(
+                    "AppCommand cannot handle app '%s' in legacy mode "
+                    "because it doesn't have a models module."
+                    % app_config.label)
+            return handle_app(app_config.models_module, **options)
 
 
 class LabelCommand(BaseCommand):
diff --git a/django/core/management/commands/dumpdata.py b/django/core/management/commands/dumpdata.py
index fa657bcd72..1242bd4e57 100644
--- a/django/core/management/commands/dumpdata.py
+++ b/django/core/management/commands/dumpdata.py
@@ -3,6 +3,7 @@ import warnings
 from collections import OrderedDict
 from optparse import make_option
 
+from django.apps import apps
 from django.core.management.base import BaseCommand, CommandError
 from django.core import serializers
 from django.db import router, DEFAULT_DB_ALIAS
@@ -15,10 +16,12 @@ class Command(BaseCommand):
         make_option('--indent', default=None, dest='indent', type='int',
             help='Specifies the indent level to use when pretty-printing output'),
         make_option('--database', action='store', dest='database',
-            default=DEFAULT_DB_ALIAS, help='Nominates a specific database to dump '
-                'fixtures from. Defaults to the "default" database.'),
+            default=DEFAULT_DB_ALIAS,
+            help='Nominates a specific database to dump fixtures from. '
+                 'Defaults to the "default" database.'),
         make_option('-e', '--exclude', dest='exclude', action='append', default=[],
-            help='An appname or appname.ModelName to exclude (use multiple --exclude to exclude multiple apps/models).'),
+            help='An app_label or app_label.ModelName to exclude '
+                 '(use multiple --exclude to exclude multiple apps/models).'),
         make_option('-n', '--natural', action='store_true', dest='use_natural_keys', default=False,
             help='Use natural keys if they are available.'),
         make_option('--natural-foreign', action='store_true', dest='use_natural_foreign_keys', default=False,
@@ -26,19 +29,19 @@ class Command(BaseCommand):
         make_option('--natural-primary', action='store_true', dest='use_natural_primary_keys', default=False,
             help='Use natural primary keys if they are available.'),
         make_option('-a', '--all', action='store_true', dest='use_base_manager', default=False,
-            help="Use Django's base manager to dump all models stored in the database, including those that would otherwise be filtered or modified by a custom manager."),
-        make_option('--pks', dest='primary_keys', help="Only dump objects with "
-            "given primary keys. Accepts a comma separated list of keys. "
-            "This option will only work when you specify one model."),
+            help="Use Django's base manager to dump all models stored in the database, "
+                 "including those that would otherwise be filtered or modified by a custom manager."),
+        make_option('--pks', dest='primary_keys',
+            help="Only dump objects with given primary keys. "
+                 "Accepts a comma separated list of keys. "
+                 "This option will only work when you specify one model."),
     )
     help = ("Output the contents of the database as a fixture of the given "
             "format (using each model's default manager unless --all is "
             "specified).")
-    args = '[appname appname.ModelName ...]'
+    args = '[app_label app_label.ModelName ...]'
 
     def handle(self, *app_labels, **options):
-        from django.core.apps import app_cache
-
         format = options.get('format')
         indent = options.get('indent')
         using = options.get('database')
@@ -63,24 +66,24 @@ class Command(BaseCommand):
         for exclude in excludes:
             if '.' in exclude:
                 app_label, model_name = exclude.split('.', 1)
-                model_obj = app_cache.get_model(app_label, model_name)
-                if not model_obj:
+                try:
+                    model = apps.get_model(app_label, model_name)
+                except LookupError:
                     raise CommandError('Unknown model in excludes: %s' % exclude)
-                excluded_models.add(model_obj)
+                excluded_models.add(model)
             else:
                 try:
-                    app_obj = app_cache.get_app_config(exclude).models_module
-                    if app_obj is not None:
-                        excluded_apps.add(app_obj)
+                    app_config = apps.get_app_config(exclude)
                 except LookupError:
                     raise CommandError('Unknown app in excludes: %s' % exclude)
+                excluded_apps.add(app_config)
 
         if len(app_labels) == 0:
             if primary_keys:
                 raise CommandError("You can only use --pks option with one model")
-            app_list = OrderedDict((app_config.models_module, None)
-                for app_config in app_cache.get_app_configs(only_with_models_module=True)
-                if app_config.models_module not in excluded_apps)
+            app_list = OrderedDict((app_config, None)
+                for app_config in apps.get_app_configs()
+                if app_config.models_module is not None and app_config not in excluded_apps)
         else:
             if len(app_labels) > 1 and primary_keys:
                 raise CommandError("You can only use --pks option with one model")
@@ -89,32 +92,31 @@ class Command(BaseCommand):
                 try:
                     app_label, model_label = label.split('.')
                     try:
-                        app = app_cache.get_app_config(app_label).models_module
+                        app_config = apps.get_app_config(app_label)
                     except LookupError:
                         raise CommandError("Unknown application: %s" % app_label)
-                    if app is None or app in excluded_apps:
+                    if app_config.models_module is None or app_config in excluded_apps:
                         continue
-                    model = app_cache.get_model(app_label, model_label)
-                    if model is None:
+                    try:
+                        model = apps.get_model(app_label, model_label)
+                    except LookupError:
                         raise CommandError("Unknown model: %s.%s" % (app_label, model_label))
 
-                    if app in app_list.keys():
-                        if app_list[app] and model not in app_list[app]:
-                            app_list[app].append(model)
-                    else:
-                        app_list[app] = [model]
+                    app_list_value = app_list.setdefault(app_config, [])
+                    if model not in app_list_value:
+                        app_list_value.append(model)
                 except ValueError:
                     if primary_keys:
                         raise CommandError("You can only use --pks option with one model")
                     # This is just an app - no model qualifier
                     app_label = label
                     try:
-                        app = app_cache.get_app_config(app_label).models_module
+                        app_config = apps.get_app_config(app_label)
                     except LookupError:
                         raise CommandError("Unknown application: %s" % app_label)
-                    if app is None or app in excluded_apps:
+                    if app_config.models_module is None or app_config in excluded_apps:
                         continue
-                    app_list[app] = None
+                    app_list[app_config] = None
 
         # Check that the serialization format exists; this is a shortcut to
         # avoid collating all the objects and _then_ failing.
@@ -156,19 +158,18 @@ class Command(BaseCommand):
 
 
 def sort_dependencies(app_list):
-    """Sort a list of app,modellist pairs into a single list of models.
+    """Sort a list of (app_config, models) pairs into a single list of models.
 
     The single list of models is sorted so that any model with a natural key
     is serialized before a normal model, and any model with a natural key
     dependency has it's dependencies serialized first.
     """
-    from django.core.apps import app_cache
     # Process the list of models, and get the list of dependencies
     model_dependencies = []
     models = set()
-    for app, model_list in app_list:
+    for app_config, model_list in app_list:
         if model_list is None:
-            model_list = app_cache.get_models(app)
+            model_list = app_config.get_models()
 
         for model in model_list:
             models.add(model)
@@ -176,7 +177,7 @@ def sort_dependencies(app_list):
             if hasattr(model, 'natural_key'):
                 deps = getattr(model.natural_key, 'dependencies', [])
                 if deps:
-                    deps = [app_cache.get_model(*d.split('.')) for d in deps]
+                    deps = [apps.get_model(*d.split('.')) for d in deps]
             else:
                 deps = []
 
diff --git a/django/core/management/commands/flush.py b/django/core/management/commands/flush.py
index 562147e403..4a3f7c2d8b 100644
--- a/django/core/management/commands/flush.py
+++ b/django/core/management/commands/flush.py
@@ -2,8 +2,7 @@ import sys
 from importlib import import_module
 from optparse import make_option
 
-from django.conf import settings
-from django.core.apps import app_cache
+from django.apps import apps
 from django.db import connections, router, transaction, DEFAULT_DB_ALIAS
 from django.core.management import call_command
 from django.core.management.base import NoArgsCommand, CommandError
@@ -42,9 +41,9 @@ class Command(NoArgsCommand):
 
         # Import the 'management' module within each installed app, to register
         # dispatcher events.
-        for app_name in settings.INSTALLED_APPS:
+        for app_config in apps.get_app_configs():
             try:
-                import_module('.management', app_name)
+                import_module('.management', app_config.name)
             except ImportError:
                 pass
 
@@ -94,6 +93,6 @@ Are you sure you want to do this?
         # Emit the post migrate signal. This allows individual applications to
         # respond as if the database had been migrated from scratch.
         all_models = []
-        for app_config in app_cache.get_app_configs(only_with_models_module=True):
-            all_models.extend(router.get_migratable_models(app_config.models_module, database, include_auto_created=True))
+        for app_config in apps.get_app_configs():
+            all_models.extend(router.get_migratable_models(app_config, database, include_auto_created=True))
         emit_post_migrate_signal(set(all_models), verbosity, interactive, database)
diff --git a/django/core/management/commands/inspectdb.py b/django/core/management/commands/inspectdb.py
index a24ae2b51e..0f291237f7 100644
--- a/django/core/management/commands/inspectdb.py
+++ b/django/core/management/commands/inspectdb.py
@@ -45,7 +45,7 @@ class Command(NoArgsCommand):
         yield "#   * Remove `managed = False` lines for those models you wish to give write DB access"
         yield "# Feel free to rename the models, but don't rename db_table values or field names."
         yield "#"
-        yield "# Also note: You'll have to insert the output of 'django-admin.py sqlcustom [appname]'"
+        yield "# Also note: You'll have to insert the output of 'django-admin.py sqlcustom [app_label]'"
         yield "# into your database."
         yield "from __future__ import unicode_literals"
         yield ''
diff --git a/django/core/management/commands/loaddata.py b/django/core/management/commands/loaddata.py
index ee88232d9f..65bc96ba99 100644
--- a/django/core/management/commands/loaddata.py
+++ b/django/core/management/commands/loaddata.py
@@ -7,8 +7,8 @@ import warnings
 import zipfile
 from optparse import make_option
 
+from django.apps import apps
 from django.conf import settings
-from django.core.apps import app_cache
 from django.core import serializers
 from django.core.management.base import BaseCommand, CommandError
 from django.core.management.color import no_style
@@ -230,7 +230,7 @@ class Command(BaseCommand):
         current directory.
         """
         dirs = []
-        for app_config in app_cache.get_app_configs():
+        for app_config in apps.get_app_configs():
             d = os.path.join(app_config.path, 'fixtures')
             if os.path.isdir(d):
                 dirs.append(d)
diff --git a/django/core/management/commands/makemigrations.py b/django/core/management/commands/makemigrations.py
index 3bd7ad42be..411aec42b3 100644
--- a/django/core/management/commands/makemigrations.py
+++ b/django/core/management/commands/makemigrations.py
@@ -3,7 +3,7 @@ import os
 import operator
 from optparse import make_option
 
-from django.core.apps import app_cache
+from django.apps import apps
 from django.core.management.base import BaseCommand, CommandError
 from django.db import connections, DEFAULT_DB_ALIAS, migrations
 from django.db.migrations.loader import MigrationLoader
@@ -37,7 +37,7 @@ class Command(BaseCommand):
         bad_app_labels = set()
         for app_label in app_labels:
             try:
-                app_cache.get_app_config(app_label)
+                apps.get_app_config(app_label)
             except LookupError:
                 bad_app_labels.add(app_label)
         if bad_app_labels:
@@ -72,7 +72,7 @@ class Command(BaseCommand):
         # Detect changes
         autodetector = MigrationAutodetector(
             loader.graph.project_state(),
-            ProjectState.from_app_cache(app_cache),
+            ProjectState.from_apps(apps),
             InteractiveMigrationQuestioner(specified_apps=app_labels),
         )
         changes = autodetector.changes(graph=loader.graph, trim_to_apps=app_labels or None)
diff --git a/django/core/management/commands/migrate.py b/django/core/management/commands/migrate.py
index b607e8ee43..cb863509c8 100644
--- a/django/core/management/commands/migrate.py
+++ b/django/core/management/commands/migrate.py
@@ -6,8 +6,7 @@ from importlib import import_module
 import itertools
 import traceback
 
-from django.conf import settings
-from django.core.apps import app_cache
+from django.apps import apps
 from django.core.management import call_command
 from django.core.management.base import BaseCommand, CommandError
 from django.core.management.color import no_style
@@ -47,9 +46,9 @@ class Command(BaseCommand):
 
         # Import the 'management' module within each installed app, to register
         # dispatcher events.
-        for app_name in settings.INSTALLED_APPS:
-            if module_has_submodule(import_module(app_name), "management"):
-                import_module('.management', app_name)
+        for app_config in apps.get_app_configs():
+            if module_has_submodule(app_config.module, "management"):
+                import_module('.management', app_config.name)
 
         # Get the database we're operating from
         db = options.get('database')
@@ -76,7 +75,7 @@ class Command(BaseCommand):
         run_syncdb = False
         target_app_labels_only = True
         if len(args) > 2:
-            raise CommandError("Too many command-line arguments (expecting 'appname' or 'appname migrationname')")
+            raise CommandError("Too many command-line arguments (expecting 'app_label' or 'app_label migrationname')")
         elif len(args) == 2:
             app_label, migration_name = args
             if app_label not in executor.loader.migrated_apps:
@@ -136,7 +135,7 @@ class Command(BaseCommand):
                 # If there's changes that aren't in migrations yet, tell them how to fix it.
                 autodetector = MigrationAutodetector(
                     executor.loader.graph.project_state(),
-                    ProjectState.from_app_cache(app_cache),
+                    ProjectState.from_apps(apps),
                 )
                 changes = autodetector.changes(graph=executor.loader.graph)
                 if changes:
@@ -168,8 +167,8 @@ class Command(BaseCommand):
                 else:
                     self.stdout.write(self.style.MIGRATE_SUCCESS(" OK"))
 
-    def sync_apps(self, connection, apps):
-        "Runs the old syncdb-style operation on a list of apps."
+    def sync_apps(self, connection, app_labels):
+        "Runs the old syncdb-style operation on a list of app_labels."
         cursor = connection.cursor()
 
         # Get a list of already installed *models* so that references work right.
@@ -181,9 +180,9 @@ class Command(BaseCommand):
         # Build the manifest of apps and models that are to be synchronized
         all_models = [
             (app_config.label,
-                router.get_migratable_models(app_config.models_module, connection.alias, include_auto_created=True))
-            for app_config in app_cache.get_app_configs(only_with_models_module=True)
-            if app_config.label in apps
+                router.get_migratable_models(app_config, connection.alias, include_auto_created=True))
+            for app_config in apps.get_app_configs()
+            if app_config.models_module is not None and app_config.label in app_labels
         ]
 
         def model_installed(model):
@@ -278,7 +277,7 @@ class Command(BaseCommand):
 
         return created_models
 
-    def show_migration_list(self, connection, apps=None):
+    def show_migration_list(self, connection, app_names=None):
         """
         Shows a list of all migrations on the system, or only those of
         some named apps.
@@ -287,24 +286,24 @@ class Command(BaseCommand):
         loader = MigrationLoader(connection)
         graph = loader.graph
         # If we were passed a list of apps, validate it
-        if apps:
+        if app_names:
             invalid_apps = []
-            for app in apps:
-                if app not in loader.migrated_apps:
-                    invalid_apps.append(app)
+            for app_name in app_names:
+                if app_name not in loader.migrated_apps:
+                    invalid_apps.append(app_name)
             if invalid_apps:
                 raise CommandError("No migrations present for: %s" % (", ".join(invalid_apps)))
         # Otherwise, show all apps in alphabetic order
         else:
-            apps = sorted(loader.migrated_apps)
+            app_names = sorted(loader.migrated_apps)
         # For each app, print its migrations in order from oldest (roots) to
         # newest (leaves).
-        for app in apps:
-            self.stdout.write(app, self.style.MIGRATE_LABEL)
+        for app_name in app_names:
+            self.stdout.write(app_name, self.style.MIGRATE_LABEL)
             shown = set()
-            for node in graph.leaf_nodes(app):
+            for node in graph.leaf_nodes(app_name):
                 for plan_node in graph.forwards_plan(node):
-                    if plan_node not in shown and plan_node[0] == app:
+                    if plan_node not in shown and plan_node[0] == app_name:
                         # Give it a nice title if it's a squashed one
                         title = plan_node[1]
                         if graph.nodes[plan_node].replaces:
diff --git a/django/core/management/commands/shell.py b/django/core/management/commands/shell.py
index 5c189ac980..5ef51db3f9 100644
--- a/django/core/management/commands/shell.py
+++ b/django/core/management/commands/shell.py
@@ -1,6 +1,7 @@
-import os
-from django.core.management.base import NoArgsCommand
 from optparse import make_option
+import os
+
+from django.core.management.base import NoArgsCommand
 
 
 class Command(NoArgsCommand):
@@ -64,11 +65,6 @@ class Command(NoArgsCommand):
         raise ImportError
 
     def handle_noargs(self, **options):
-        # XXX: (Temporary) workaround for ticket #1796: force early loading of all
-        # models from installed apps.
-        from django.core.apps import app_cache
-        app_cache.get_models()
-
         use_plain = options.get('plain', False)
         no_startup = options.get('no_startup', False)
         interface = options.get('interface', None)
diff --git a/django/core/management/commands/sql.py b/django/core/management/commands/sql.py
index 399458693e..3fd081940d 100644
--- a/django/core/management/commands/sql.py
+++ b/django/core/management/commands/sql.py
@@ -18,5 +18,9 @@ class Command(AppCommand):
 
     output_transaction = True
 
-    def handle_app(self, app, **options):
-        return '\n'.join(sql_create(app, self.style, connections[options.get('database')]))
+    def handle_app_config(self, app_config, **options):
+        if app_config.models_module is None:
+            return
+        connection = connections[options.get('database')]
+        statements = sql_create(app_config, self.style, connection)
+        return '\n'.join(statements)
diff --git a/django/core/management/commands/sqlall.py b/django/core/management/commands/sqlall.py
index 0e2c05ba82..69746f1c3d 100644
--- a/django/core/management/commands/sqlall.py
+++ b/django/core/management/commands/sqlall.py
@@ -18,5 +18,9 @@ class Command(AppCommand):
 
     output_transaction = True
 
-    def handle_app(self, app, **options):
-        return '\n'.join(sql_all(app, self.style, connections[options.get('database')]))
+    def handle_app_config(self, app_config, **options):
+        if app_config.models_module is None:
+            return
+        connection = connections[options.get('database')]
+        statements = sql_all(app_config, self.style, connection)
+        return '\n'.join(statements)
diff --git a/django/core/management/commands/sqlclear.py b/django/core/management/commands/sqlclear.py
index efcdbbca35..e611390533 100644
--- a/django/core/management/commands/sqlclear.py
+++ b/django/core/management/commands/sqlclear.py
@@ -18,5 +18,9 @@ class Command(AppCommand):
 
     output_transaction = True
 
-    def handle_app(self, app, **options):
-        return '\n'.join(sql_delete(app, self.style, connections[options.get('database')]))
+    def handle_app_config(self, app_config, **options):
+        if app_config.models_module is None:
+            return
+        connection = connections[options.get('database')]
+        statements = sql_delete(app_config, self.style, connection)
+        return '\n'.join(statements)
diff --git a/django/core/management/commands/sqlcustom.py b/django/core/management/commands/sqlcustom.py
index b71a3dd6d4..bfc6f395d4 100644
--- a/django/core/management/commands/sqlcustom.py
+++ b/django/core/management/commands/sqlcustom.py
@@ -18,5 +18,9 @@ class Command(AppCommand):
 
     output_transaction = True
 
-    def handle_app(self, app, **options):
-        return '\n'.join(sql_custom(app, self.style, connections[options.get('database')]))
+    def handle_app_config(self, app_config, **options):
+        if app_config.models_module is None:
+            return
+        connection = connections[options.get('database')]
+        statements = sql_custom(app_config, self.style, connection)
+        return '\n'.join(statements)
diff --git a/django/core/management/commands/sqldropindexes.py b/django/core/management/commands/sqldropindexes.py
index d531808996..4bdb42d608 100644
--- a/django/core/management/commands/sqldropindexes.py
+++ b/django/core/management/commands/sqldropindexes.py
@@ -19,5 +19,9 @@ class Command(AppCommand):
 
     output_transaction = True
 
-    def handle_app(self, app, **options):
-        return '\n'.join(sql_destroy_indexes(app, self.style, connections[options.get('database')]))
+    def handle_app_config(self, app_config, **options):
+        if app_config.models_module is None:
+            return
+        connection = connections[options.get('database')]
+        statements = sql_destroy_indexes(app_config, self.style, connection)
+        return '\n'.join(statements)
diff --git a/django/core/management/commands/sqlindexes.py b/django/core/management/commands/sqlindexes.py
index 2dc4f35dc6..2f1fd8d103 100644
--- a/django/core/management/commands/sqlindexes.py
+++ b/django/core/management/commands/sqlindexes.py
@@ -19,5 +19,9 @@ class Command(AppCommand):
 
     output_transaction = True
 
-    def handle_app(self, app, **options):
-        return '\n'.join(sql_indexes(app, self.style, connections[options.get('database')]))
+    def handle_app_config(self, app_config, **options):
+        if app_config.models_module is None:
+            return
+        connection = connections[options.get('database')]
+        statements = sql_indexes(app_config, self.style, connection)
+        return '\n'.join(statements)
diff --git a/django/core/management/commands/sqlmigrate.py b/django/core/management/commands/sqlmigrate.py
index 0e6da940e9..e828733f2c 100644
--- a/django/core/management/commands/sqlmigrate.py
+++ b/django/core/management/commands/sqlmigrate.py
@@ -31,7 +31,7 @@ class Command(BaseCommand):
 
         # Resolve command-line arguments into a migration
         if len(args) != 2:
-            raise CommandError("Wrong number of arguments (expecting 'sqlmigrate appname migrationname')")
+            raise CommandError("Wrong number of arguments (expecting 'sqlmigrate app_label migrationname')")
         else:
             app_label, migration_name = args
             if app_label not in executor.loader.migrated_apps:
diff --git a/django/core/management/commands/sqlsequencereset.py b/django/core/management/commands/sqlsequencereset.py
index cc35030a91..9d25125efb 100644
--- a/django/core/management/commands/sqlsequencereset.py
+++ b/django/core/management/commands/sqlsequencereset.py
@@ -2,7 +2,6 @@ from __future__ import unicode_literals
 
 from optparse import make_option
 
-from django.core.apps import app_cache
 from django.core.management.base import AppCommand
 from django.db import connections, DEFAULT_DB_ALIAS
 
@@ -19,6 +18,10 @@ class Command(AppCommand):
 
     output_transaction = True
 
-    def handle_app(self, app, **options):
+    def handle_app_config(self, app_config, **options):
+        if app_config.models_module is None:
+            return
         connection = connections[options.get('database')]
-        return '\n'.join(connection.ops.sequence_reset_sql(self.style, app_cache.get_models(app, include_auto_created=True)))
+        models = app_config.get_models(include_auto_created=True)
+        statements = connection.ops.sequence_reset_sql(self.style, models)
+        return '\n'.join(statements)
diff --git a/django/core/management/sql.py b/django/core/management/sql.py
index 0b6e38124e..d2c7786390 100644
--- a/django/core/management/sql.py
+++ b/django/core/management/sql.py
@@ -5,13 +5,13 @@ import os
 import re
 import warnings
 
+from django.apps import apps
 from django.conf import settings
-from django.core.apps import app_cache
 from django.core.management.base import CommandError
 from django.db import models, router
 
 
-def sql_create(app, style, connection):
+def sql_create(app_config, style, connection):
     "Returns a list of the CREATE TABLE SQL statements for the given app."
 
     if connection.settings_dict['ENGINE'] == 'django.db.backends.dummy':
@@ -25,13 +25,13 @@ def sql_create(app, style, connection):
     # We trim models from the current app so that the sqlreset command does not
     # generate invalid SQL (leaving models out of known_models is harmless, so
     # we can be conservative).
-    app_models = app_cache.get_models(app, include_auto_created=True)
+    app_models = app_config.get_models(include_auto_created=True)
     final_output = []
     tables = connection.introspection.table_names()
     known_models = set(model for model in connection.introspection.installed_models(tables) if model not in app_models)
     pending_references = {}
 
-    for model in router.get_migratable_models(app, connection.alias, include_auto_created=True):
+    for model in router.get_migratable_models(app_config, connection.alias, include_auto_created=True):
         output, references = connection.creation.sql_create_model(model, style, known_models)
         final_output.extend(output)
         for refto, refs in references.items():
@@ -57,7 +57,7 @@ def sql_create(app, style, connection):
     return final_output
 
 
-def sql_delete(app, style, connection):
+def sql_delete(app_config, style, connection):
     "Returns a list of the DROP TABLE SQL statements for the given app."
 
     # This should work even if a connection isn't available
@@ -78,7 +78,7 @@ def sql_delete(app, style, connection):
     to_delete = set()
 
     references_to_delete = {}
-    app_models = router.get_migratable_models(app, connection.alias, include_auto_created=True)
+    app_models = router.get_migratable_models(app_config, connection.alias, include_auto_created=True)
     for model in app_models:
         if cursor and connection.introspection.table_name_converter(model._meta.db_table) in table_names:
             # The table exists, so it needs to be dropped
@@ -118,11 +118,11 @@ def sql_flush(style, connection, only_django=False, reset_sequences=True, allow_
     return statements
 
 
-def sql_custom(app, style, connection):
+def sql_custom(app_config, style, connection):
     "Returns a list of the custom table modifying SQL statements for the given app."
     output = []
 
-    app_models = router.get_migratable_models(app, connection.alias)
+    app_models = router.get_migratable_models(app_config, connection.alias)
 
     for model in app_models:
         output.extend(custom_sql_for_model(model, style, connection))
@@ -130,25 +130,25 @@ def sql_custom(app, style, connection):
     return output
 
 
-def sql_indexes(app, style, connection):
+def sql_indexes(app_config, style, connection):
     "Returns a list of the CREATE INDEX SQL statements for all models in the given app."
     output = []
-    for model in router.get_migratable_models(app, connection.alias, include_auto_created=True):
+    for model in router.get_migratable_models(app_config, connection.alias, include_auto_created=True):
         output.extend(connection.creation.sql_indexes_for_model(model, style))
     return output
 
 
-def sql_destroy_indexes(app, style, connection):
+def sql_destroy_indexes(app_config, style, connection):
     "Returns a list of the DROP INDEX SQL statements for all models in the given app."
     output = []
-    for model in router.get_migratable_models(app, connection.alias, include_auto_created=True):
+    for model in router.get_migratable_models(app_config, connection.alias, include_auto_created=True):
         output.extend(connection.creation.sql_destroy_indexes_for_model(model, style))
     return output
 
 
-def sql_all(app, style, connection):
+def sql_all(app_config, style, connection):
     "Returns a list of CREATE TABLE SQL, initial-data inserts, and CREATE INDEX SQL for the given module."
-    return sql_create(app, style, connection) + sql_custom(app, style, connection) + sql_indexes(app, style, connection)
+    return sql_create(app_config, style, connection) + sql_custom(app_config, style, connection) + sql_indexes(app_config, style, connection)
 
 
 def _split_statements(content):
@@ -169,7 +169,7 @@ def _split_statements(content):
 def custom_sql_for_model(model, style, connection):
     opts = model._meta
     app_dirs = []
-    app_dir = app_cache.get_app_config(model._meta.app_label).path
+    app_dir = apps.get_app_config(model._meta.app_label).path
     app_dirs.append(os.path.normpath(os.path.join(app_dir, 'sql')))
 
     # Deprecated location -- remove in Django 1.9
@@ -207,10 +207,19 @@ def custom_sql_for_model(model, style, connection):
 
 def emit_pre_migrate_signal(create_models, verbosity, interactive, db):
     # Emit the pre_migrate signal for every application.
-    for app_config in app_cache.get_app_configs(only_with_models_module=True):
+    for app_config in apps.get_app_configs():
+        if app_config.models_module is None:
+            continue
         if verbosity >= 2:
             print("Running pre-migrate handlers for application %s" % app_config.label)
         models.signals.pre_migrate.send(
+            sender=app_config,
+            app_config=app_config,
+            verbosity=verbosity,
+            interactive=interactive,
+            db=db)
+        # For backwards-compatibility -- remove in Django 1.9.
+        models.signals.pre_syncdb.send(
             sender=app_config.models_module,
             app=app_config.models_module,
             create_models=create_models,
@@ -221,10 +230,19 @@ def emit_pre_migrate_signal(create_models, verbosity, interactive, db):
 
 def emit_post_migrate_signal(created_models, verbosity, interactive, db):
     # Emit the post_migrate signal for every application.
-    for app_config in app_cache.get_app_configs(only_with_models_module=True):
+    for app_config in apps.get_app_configs():
+        if app_config.models_module is None:
+            continue
         if verbosity >= 2:
             print("Running post-migrate handlers for application %s" % app_config.label)
         models.signals.post_migrate.send(
+            sender=app_config,
+            app_config=app_config,
+            verbosity=verbosity,
+            interactive=interactive,
+            db=db)
+        # For backwards-compatibility -- remove in Django 1.9.
+        models.signals.post_syncdb.send(
             sender=app_config.models_module,
             app=app_config.models_module,
             created_models=created_models,
diff --git a/django/core/management/validation.py b/django/core/management/validation.py
index 1cedcb9925..e5eee65fef 100644
--- a/django/core/management/validation.py
+++ b/django/core/management/validation.py
@@ -20,19 +20,19 @@ class ModelErrorCollection:
         self.outfile.write(self.style.ERROR(force_str("%s: %s\n" % (context, error))))
 
 
-def get_validation_errors(outfile, app=None):
+def get_validation_errors(outfile, app_config=None):
     """
     Validates all models that are part of the specified app. If no app name is provided,
     validates all models of all installed apps. Writes errors, if any, to outfile.
     Returns number of errors.
     """
-    from django.core.apps import app_cache
+    from django.apps import apps
     from django.db import connection, models
     from django.db.models.deletion import SET_NULL, SET_DEFAULT
 
     e = ModelErrorCollection(outfile)
 
-    for cls in app_cache.get_models(app, include_swapped=True):
+    for cls in (app_config or apps).get_models(include_swapped=True):
         opts = cls._meta
 
         # Check swappable attribute.
@@ -42,7 +42,9 @@ def get_validation_errors(outfile, app=None):
             except ValueError:
                 e.add(opts, "%s is not of the form 'app_label.app_name'." % opts.swappable)
                 continue
-            if not app_cache.get_model(app_label, model_name):
+            try:
+                apps.get_model(app_label, model_name)
+            except LookupError:
                 e.add(opts, "Model has been swapped out for '%s' which has not been installed or is abstract." % opts.swapped)
             # No need to perform any other validation checks on a swapped model.
             continue
@@ -152,7 +154,7 @@ def get_validation_errors(outfile, app=None):
             # Check to see if the related field will clash with any existing
             # fields, m2m fields, m2m related objects or related objects
             if f.rel:
-                if f.rel.to not in app_cache.get_models():
+                if f.rel.to not in apps.get_models():
                     # If the related model is swapped, provide a hint;
                     # otherwise, the model just hasn't been installed.
                     if not isinstance(f.rel.to, six.string_types) and f.rel.to._meta.swapped:
@@ -207,7 +209,7 @@ def get_validation_errors(outfile, app=None):
             # Check to see if the related m2m field will clash with any
             # existing fields, m2m fields, m2m related objects or related
             # objects
-            if f.rel.to not in app_cache.get_models():
+            if f.rel.to not in apps.get_models():
                 # If the related model is swapped, provide a hint;
                 # otherwise, the model just hasn't been installed.
                 if not isinstance(f.rel.to, six.string_types) and f.rel.to._meta.swapped:
@@ -265,7 +267,7 @@ def get_validation_errors(outfile, app=None):
                                 )
                             else:
                                 seen_to = True
-                if f.rel.through not in app_cache.get_models(include_auto_created=True):
+                if f.rel.through not in apps.get_models(include_auto_created=True):
                     e.add(opts, "'%s' specifies an m2m relation through model "
                         "%s, which has not been installed." % (f.name, f.rel.through))
                 signature = (f.rel.to, cls, f.rel.through)
diff --git a/django/core/serializers/base.py b/django/core/serializers/base.py
index db4b79a020..e5c295131e 100644
--- a/django/core/serializers/base.py
+++ b/django/core/serializers/base.py
@@ -3,7 +3,6 @@ Module for abstract serializer/unserializer base classes.
 """
 import warnings
 
-from django.core.apps import app_cache
 from django.db import models
 from django.utils import six
 
@@ -137,9 +136,6 @@ class Deserializer(six.Iterator):
             self.stream = six.StringIO(stream_or_string)
         else:
             self.stream = stream_or_string
-        # Make sure the app cache is loaded before deserialization starts
-        # (otherwise subclass calls to get_model() and friends might fail...)
-        app_cache.populate()
 
     def __iter__(self):
         return self
diff --git a/django/core/serializers/python.py b/django/core/serializers/python.py
index 13d6f01a4e..3d14a1b509 100644
--- a/django/core/serializers/python.py
+++ b/django/core/serializers/python.py
@@ -5,8 +5,8 @@ other serializers.
 """
 from __future__ import unicode_literals
 
+from django.apps import apps
 from django.conf import settings
-from django.core.apps import app_cache
 from django.core.serializers import base
 from django.db import models, DEFAULT_DB_ALIAS
 from django.utils.encoding import smart_text, is_protected_type
@@ -88,8 +88,6 @@ def Deserializer(object_list, **options):
     db = options.pop('using', DEFAULT_DB_ALIAS)
     ignore = options.pop('ignorenonexistent', False)
 
-    app_cache.populate()
-
     for d in object_list:
         # Look up the model and starting build a dict of data for it.
         Model = _get_model(d["model"])
@@ -155,9 +153,7 @@ def _get_model(model_identifier):
     Helper to look up a model from an "app_label.model_name" string.
     """
     try:
-        Model = app_cache.get_model(*model_identifier.split("."))
-    except TypeError:
-        Model = None
-    if Model is None:
+        Model = apps.get_model(*model_identifier.split("."))
+    except (LookupError, TypeError):
         raise base.DeserializationError("Invalid model identifier: '%s'" % model_identifier)
     return Model
diff --git a/django/core/serializers/xml_serializer.py b/django/core/serializers/xml_serializer.py
index 90ad2cf398..06dd134754 100644
--- a/django/core/serializers/xml_serializer.py
+++ b/django/core/serializers/xml_serializer.py
@@ -4,8 +4,8 @@ XML serializer.
 
 from __future__ import unicode_literals
 
+from django.apps import apps
 from django.conf import settings
-from django.core.apps import app_cache
 from django.core.serializers import base
 from django.db import models, DEFAULT_DB_ALIAS
 from django.utils.xmlutils import SimplerXMLGenerator
@@ -277,10 +277,8 @@ class Deserializer(base.Deserializer):
                 "<%s> node is missing the required '%s' attribute"
                 % (node.nodeName, attr))
         try:
-            Model = app_cache.get_model(*model_identifier.split("."))
-        except TypeError:
-            Model = None
-        if Model is None:
+            Model = apps.get_model(*model_identifier.split("."))
+        except (LookupError, TypeError):
             raise base.DeserializationError(
                 "<%s> node has invalid model identifier: '%s'"
                 % (node.nodeName, model_identifier))
diff --git a/django/core/validators.py b/django/core/validators.py
index 695dda258b..5559bca28f 100644
--- a/django/core/validators.py
+++ b/django/core/validators.py
@@ -44,7 +44,7 @@ class RegexValidator(object):
 @deconstructible
 class URLValidator(RegexValidator):
     regex = re.compile(
-        r'^(?:http|ftp)s?://'  # http:// or https://
+        r'^(?:[a-z0-9\.\-]*)://'  # scheme is validated separately
         r'(?:(?:[A-Z0-9](?:[A-Z0-9-]{0,61}[A-Z0-9])?\.)+(?:[A-Z]{2,6}\.?|[A-Z0-9-]{2,}\.?)|'  # domain...
         r'localhost|'  # localhost...
         r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}|'  # ...or ipv4
@@ -52,14 +52,26 @@ class URLValidator(RegexValidator):
         r'(?::\d+)?'  # optional port
         r'(?:/?|[/?]\S+)$', re.IGNORECASE)
     message = _('Enter a valid URL.')
+    schemes = ['http', 'https', 'ftp', 'ftps']
+
+    def __init__(self, schemes=None, **kwargs):
+        super(URLValidator, self).__init__(**kwargs)
+        if schemes is not None:
+            self.schemes = schemes
 
     def __call__(self, value):
+        value = force_text(value)
+        # Check first if the scheme is valid
+        scheme = value.split('://')[0].lower()
+        if scheme not in self.schemes:
+            raise ValidationError(self.message, code=self.code)
+
+        # Then check full URL
         try:
             super(URLValidator, self).__call__(value)
         except ValidationError as e:
             # Trivial case failed. Try for possible IDN domain
             if value:
-                value = force_text(value)
                 scheme, netloc, path, query, fragment = urlsplit(value)
                 try:
                     netloc = netloc.encode('idna').decode('ascii')  # IDN -> ACE
diff --git a/django/core/wsgi.py b/django/core/wsgi.py
index edea3334c9..4ff41318d3 100644
--- a/django/core/wsgi.py
+++ b/django/core/wsgi.py
@@ -1,3 +1,4 @@
+import django
 from django.core.handlers.wsgi import WSGIHandler
 
 
@@ -10,4 +11,5 @@ def get_wsgi_application():
     case the internal WSGI implementation changes or moves in the future.
 
     """
+    django.setup()
     return WSGIHandler()
diff --git a/django/db/backends/__init__.py b/django/db/backends/__init__.py
index c3468f0c5f..8e1a43a877 100644
--- a/django/db/backends/__init__.py
+++ b/django/db/backends/__init__.py
@@ -1274,11 +1274,11 @@ class BaseDatabaseIntrospection(object):
         If only_existing is True, the resulting list will only include the tables
         that actually exist in the database.
         """
-        from django.core.apps import app_cache
+        from django.apps import apps
         from django.db import router
         tables = set()
-        for app_config in app_cache.get_app_configs(only_with_models_module=True):
-            for model in router.get_migratable_models(app_config.models_module, self.connection.alias):
+        for app_config in apps.get_app_configs():
+            for model in router.get_migratable_models(app_config, self.connection.alias):
                 if not model._meta.managed:
                     continue
                 tables.add(model._meta.db_table)
@@ -1295,11 +1295,11 @@ class BaseDatabaseIntrospection(object):
 
     def installed_models(self, tables):
         "Returns a set of all models represented by the provided list of table names."
-        from django.core.apps import app_cache
+        from django.apps import apps
         from django.db import router
         all_models = []
-        for app_config in app_cache.get_app_configs(only_with_models_module=True):
-            all_models.extend(router.get_migratable_models(app_config.models_module, self.connection.alias))
+        for app_config in apps.get_app_configs():
+            all_models.extend(router.get_migratable_models(app_config, self.connection.alias))
         tables = list(map(self.table_name_converter, tables))
         return set([
             m for m in all_models
@@ -1308,13 +1308,13 @@ class BaseDatabaseIntrospection(object):
 
     def sequence_list(self):
         "Returns a list of information about all DB sequences for all models in all apps."
-        from django.core.apps import app_cache
+        from django.apps import apps
         from django.db import models, router
 
         sequence_list = []
 
-        for app_config in app_cache.get_app_configs(only_with_models_module=True):
-            for model in router.get_migratable_models(app_config.models_module, self.connection.alias):
+        for app_config in apps.get_app_configs():
+            for model in router.get_migratable_models(app_config, self.connection.alias):
                 if not model._meta.managed:
                     continue
                 if model._meta.swapped:
diff --git a/django/db/backends/oracle/base.py b/django/db/backends/oracle/base.py
index 6078eecb20..aae3240e12 100644
--- a/django/db/backends/oracle/base.py
+++ b/django/db/backends/oracle/base.py
@@ -103,7 +103,6 @@ class DatabaseFeatures(BaseDatabaseFeatures):
     nulls_order_largest = True
     requires_literal_defaults = True
     connection_persists_old_columns = True
-    nulls_order_largest = True
     closed_cursor_error_class = InterfaceError
 
 
diff --git a/django/db/backends/schema.py b/django/db/backends/schema.py
index e33956763c..e690567738 100644
--- a/django/db/backends/schema.py
+++ b/django/db/backends/schema.py
@@ -52,6 +52,7 @@ class BaseDatabaseSchemaEditor(object):
     sql_delete_unique = "ALTER TABLE %(table)s DROP CONSTRAINT %(name)s"
 
     sql_create_fk = "ALTER TABLE %(table)s ADD CONSTRAINT %(name)s FOREIGN KEY (%(column)s) REFERENCES %(to_table)s (%(to_column)s) DEFERRABLE INITIALLY DEFERRED"
+    sql_create_inline_fk = None
     sql_delete_fk = "ALTER TABLE %(table)s DROP CONSTRAINT %(name)s"
 
     sql_create_index = "CREATE INDEX %(name)s ON %(table)s (%(columns)s)%(extra)s"
@@ -185,11 +186,10 @@ class BaseDatabaseSchemaEditor(object):
             db_params = field.db_parameters(connection=self.connection)
             if db_params['check']:
                 definition += " CHECK (%s)" % db_params['check']
-            # Add the SQL to our big list
-            column_sqls.append("%s %s" % (
-                self.quote_name(field.column),
-                definition,
-            ))
+            # Autoincrement SQL (for backends with inline variant)
+            col_type_suffix = field.db_type_suffix(connection=self.connection)
+            if col_type_suffix:
+                definition += " %s" % col_type_suffix
             params.extend(extra_params)
             # Indexes
             if field.db_index and not field.unique:
@@ -202,19 +202,30 @@ class BaseDatabaseSchemaEditor(object):
                     }
                 )
             # FK
-            if field.rel and self.connection.features.supports_foreign_keys:
+            if field.rel:
                 to_table = field.rel.to._meta.db_table
                 to_column = field.rel.to._meta.get_field(field.rel.field_name).column
-                self.deferred_sql.append(
-                    self.sql_create_fk % {
-                        "name": self._create_index_name(model, [field.column], suffix="_fk_%s_%s" % (to_table, to_column)),
-                        "table": self.quote_name(model._meta.db_table),
-                        "column": self.quote_name(field.column),
+                if self.connection.features.supports_foreign_keys:
+                    self.deferred_sql.append(
+                        self.sql_create_fk % {
+                            "name": self._create_index_name(model, [field.column], suffix="_fk_%s_%s" % (to_table, to_column)),
+                            "table": self.quote_name(model._meta.db_table),
+                            "column": self.quote_name(field.column),
+                            "to_table": self.quote_name(to_table),
+                            "to_column": self.quote_name(to_column),
+                        }
+                    )
+                elif self.sql_create_inline_fk:
+                    definition += " " + self.sql_create_inline_fk % {
                         "to_table": self.quote_name(to_table),
                         "to_column": self.quote_name(to_column),
                     }
-                )
-            # Autoincrement SQL
+            # Add the SQL to our big list
+            column_sqls.append("%s %s" % (
+                self.quote_name(field.column),
+                definition,
+            ))
+            # Autoincrement SQL (for backends with post table definition variant)
             if field.get_internal_type() == "AutoField":
                 autoinc_sql = self.connection.ops.autoinc_sql(model._meta.db_table, field.column)
                 if autoinc_sql:
@@ -227,7 +238,7 @@ class BaseDatabaseSchemaEditor(object):
             })
         # Make the table
         sql = self.sql_create_table % {
-            "table": model._meta.db_table,
+            "table": self.quote_name(model._meta.db_table),
             "definition": ", ".join(column_sqls)
         }
         self.execute(sql, params)
diff --git a/django/db/backends/sqlite3/schema.py b/django/db/backends/sqlite3/schema.py
index e2b9603819..41391724f6 100644
--- a/django/db/backends/sqlite3/schema.py
+++ b/django/db/backends/sqlite3/schema.py
@@ -1,4 +1,4 @@
-from django.core.apps.cache import AppCache
+from django.apps.registry import Apps
 from django.db.backends.schema import BaseDatabaseSchemaEditor
 from django.db.models.fields.related import ManyToManyField
 
@@ -6,6 +6,7 @@ from django.db.models.fields.related import ManyToManyField
 class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
 
     sql_delete_table = "DROP TABLE %(table)s"
+    sql_create_inline_fk = "REFERENCES %(to_table)s (%(to_column)s)"
 
     def _remake_table(self, model, create_fields=[], delete_fields=[], alter_fields=[], rename_fields=[], override_uniques=None):
         """
@@ -38,14 +39,14 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
         for field in delete_fields:
             del body[field.name]
             del mapping[field.column]
-        # Work inside a new AppCache
-        app_cache = AppCache()
+        # Work inside a new app registry
+        apps = Apps()
         # Construct a new model for the new state
         meta_contents = {
             'app_label': model._meta.app_label,
             'db_table': model._meta.db_table + "__new",
             'unique_together': model._meta.unique_together if override_uniques is None else override_uniques,
-            'app_cache': app_cache,
+            'apps': apps,
         }
         meta = type("Meta", tuple(), meta_contents)
         body['Meta'] = meta
diff --git a/django/db/migrations/autodetector.py b/django/db/migrations/autodetector.py
index 4074366188..c7ac756b2e 100644
--- a/django/db/migrations/autodetector.py
+++ b/django/db/migrations/autodetector.py
@@ -47,19 +47,19 @@ class MigrationAutodetector(object):
         """
         # We'll store migrations as lists by app names for now
         self.migrations = {}
-        old_app_cache = self.from_state.render()
-        new_app_cache = self.to_state.render()
+        old_apps = self.from_state.render()
+        new_apps = self.to_state.render()
         # Prepare lists of old/new model keys that we care about
         # (i.e. ignoring proxy ones)
         old_model_keys = [
             (al, mn)
             for al, mn in self.from_state.models.keys()
-            if not old_app_cache.get_model(al, mn)._meta.proxy
+            if not old_apps.get_model(al, mn)._meta.proxy
         ]
         new_model_keys = [
             (al, mn)
             for al, mn in self.to_state.models.keys()
-            if not new_app_cache.get_model(al, mn)._meta.proxy
+            if not new_apps.get_model(al, mn)._meta.proxy
         ]
         # Adding models. Phase 1 is adding models with no outward relationships.
         added_models = set(new_model_keys) - set(old_model_keys)
@@ -68,12 +68,12 @@ class MigrationAutodetector(object):
             model_state = self.to_state.models[app_label, model_name]
             # Are there any relationships out from this model? if so, punt it to the next phase.
             related_fields = []
-            for field in new_app_cache.get_model(app_label, model_name)._meta.local_fields:
+            for field in new_apps.get_model(app_label, model_name)._meta.local_fields:
                 if field.rel:
                     if field.rel.to:
-                        related_fields.append((field.name, field.rel.to._meta.app_label.lower(), field.rel.to._meta.object_name.lower()))
+                        related_fields.append((field.name, field.rel.to._meta.app_label, field.rel.to._meta.model_name))
                     if hasattr(field.rel, "through") and not field.rel.though._meta.auto_created:
-                        related_fields.append((field.name, field.rel.through._meta.app_label.lower(), field.rel.through._meta.object_name.lower()))
+                        related_fields.append((field.name, field.rel.through._meta.app_label, field.rel.through._meta.model_name))
             if related_fields:
                 pending_add[app_label, model_name] = related_fields
             else:
@@ -299,6 +299,7 @@ class MigrationAutodetector(object):
                 for migration in migrations:
                     name_map[(app_label, migration.name)] = (app_label, "__first__")
                 del changes[app_label]
+                continue
             # Work out the next number in the sequence
             if app_leaf is None:
                 next_number = 1
diff --git a/django/db/migrations/executor.py b/django/db/migrations/executor.py
index 26d269fd9f..7ebfe3d13b 100644
--- a/django/db/migrations/executor.py
+++ b/django/db/migrations/executor.py
@@ -22,7 +22,7 @@ class MigrationExecutor(object):
         plan = []
         applied = set(self.loader.applied_migrations)
         for target in targets:
-            # If the target is (appname, None), that means unmigrate everything
+            # If the target is (app_label, None), that means unmigrate everything
             if target[1] is None:
                 for root in self.loader.graph.root_nodes():
                     if root[0] == target[0]:
@@ -129,10 +129,10 @@ class MigrationExecutor(object):
         on initial migrations (as it only looks for CreateModel).
         """
         project_state = self.loader.graph.project_state((migration.app_label, migration.name), at_end=True)
-        app_cache = project_state.render()
+        apps = project_state.render()
         for operation in migration.operations:
             if isinstance(operation, migrations.CreateModel):
-                model = app_cache.get_model(migration.app_label, operation.name)
+                model = apps.get_model(migration.app_label, operation.name)
                 if model._meta.db_table not in self.connection.introspection.get_table_list(self.connection.cursor()):
                     return False
         return True
diff --git a/django/db/migrations/graph.py b/django/db/migrations/graph.py
index 4f89fa2909..eddabbd434 100644
--- a/django/db/migrations/graph.py
+++ b/django/db/migrations/graph.py
@@ -63,14 +63,14 @@ class MigrationGraph(object):
             raise ValueError("Node %r not a valid node" % (node, ))
         return self.dfs(node, lambda x: self.dependents.get(x, set()))
 
-    def root_nodes(self):
+    def root_nodes(self, app=None):
         """
         Returns all root nodes - that is, nodes with no dependencies inside
         their app. These are the starting point for an app.
         """
         roots = set()
         for node in self.nodes:
-            if not any(key[0] == node[0] for key in self.dependencies.get(node, set())):
+            if not any(key[0] == node[0] for key in self.dependencies.get(node, set())) and (not app or app == node[0]):
                 roots.add(node)
         return roots
 
@@ -145,6 +145,9 @@ class MigrationGraph(object):
             project_state = self.nodes[node].mutate_state(project_state)
         return project_state
 
+    def __contains__(self, node):
+        return node in self.nodes
+
 
 class CircularDependencyError(Exception):
     """
diff --git a/django/db/migrations/loader.py b/django/db/migrations/loader.py
index 4c12e05add..73f9d2a71e 100644
--- a/django/db/migrations/loader.py
+++ b/django/db/migrations/loader.py
@@ -2,13 +2,19 @@ from importlib import import_module
 import os
 import sys
 
-from django.core.apps import app_cache
+from django.apps import apps
 from django.db.migrations.recorder import MigrationRecorder
 from django.db.migrations.graph import MigrationGraph
+from django.db.migrations.migration import Migration
+from django.db.migrations.state import ModelState
+from django.db.migrations import operations
 from django.utils import six
 from django.conf import settings
 
 
+MIGRATIONS_MODULE_NAME = 'migrations'
+
+
 class MigrationLoader(object):
     """
     Loads migration files from disk, and their status from the database.
@@ -46,7 +52,8 @@ class MigrationLoader(object):
         if app_label in settings.MIGRATION_MODULES:
             return settings.MIGRATION_MODULES[app_label]
         else:
-            return '%s.migrations' % app_cache.get_app_config(app_label).name
+            app_package_name = apps.get_app_config(app_label).name
+            return '%s.%s' % (app_package_name, MIGRATIONS_MODULE_NAME)
 
     def load_disk(self):
         """
@@ -55,7 +62,9 @@ class MigrationLoader(object):
         self.disk_migrations = {}
         self.unmigrated_apps = set()
         self.migrated_apps = set()
-        for app_config in app_cache.get_app_configs(only_with_models_module=True):
+        for app_config in apps.get_app_configs():
+            if app_config.models_module is None:
+                continue
             # Get the migrations module directory
             module_name = self.migrations_module(app_config.label)
             was_loaded = module_name in sys.modules
@@ -64,7 +73,7 @@ class MigrationLoader(object):
             except ImportError as e:
                 # I hate doing this, but I don't want to squash other import errors.
                 # Might be better to try a directory check directly.
-                if "No module named" in str(e) and "migrations" in str(e):
+                if "No module named" in str(e) and MIGRATIONS_MODULE_NAME in str(e):
                     self.unmigrated_apps.add(app_config.label)
                     continue
                 raise
@@ -185,6 +194,38 @@ class MigrationLoader(object):
             self.graph.add_node(key, migration)
         for key, migration in normal.items():
             for parent in migration.dependencies:
+                # Special-case __first__, which means "the first migration" for
+                # migrated apps, and is ignored for unmigrated apps. It allows
+                # makemigrations to declare dependencies on apps before they
+                # even have migrations.
+                if parent[1] == "__first__" and parent not in self.graph:
+                    if parent[0] in self.unmigrated_apps:
+                        # This app isn't migrated, but something depends on it.
+                        # We'll add a fake initial migration for it into the
+                        # graph.
+                        app_config = apps.get_app_config(parent[0])
+                        ops = []
+                        for model in app_config.get_models():
+                            model_state = ModelState.from_model(model)
+                            ops.append(
+                                operations.CreateModel(
+                                    name=model_state.name,
+                                    fields=model_state.fields,
+                                    options=model_state.options,
+                                    bases=model_state.bases,
+                                )
+                            )
+                        new_migration = type(
+                            "FakeInitialMigration",
+                            (Migration, ),
+                            {"operations": ops},
+                        )(parent[1], parent[0])
+                        self.graph.add_node(parent, new_migration)
+                        self.applied_migrations.add(parent)
+                    elif parent[0] in self.migrated_apps:
+                        parent = (parent[0], list(self.graph.root_nodes(parent[0]))[0])
+                    else:
+                        raise ValueError("Dependency on unknown app %s" % parent[0])
                 self.graph.add_dependency(key, parent)
 
     def detect_conflicts(self):
diff --git a/django/db/migrations/operations/models.py b/django/db/migrations/operations/models.py
index 8c7fe126a8..1aefbd9457 100644
--- a/django/db/migrations/operations/models.py
+++ b/django/db/migrations/operations/models.py
@@ -20,14 +20,14 @@ class CreateModel(Operation):
         state.models[app_label, self.name.lower()] = ModelState(app_label, self.name, self.fields, self.options, self.bases)
 
     def database_forwards(self, app_label, schema_editor, from_state, to_state):
-        app_cache = to_state.render()
-        model = app_cache.get_model(app_label, self.name)
+        apps = to_state.render()
+        model = apps.get_model(app_label, self.name)
         if router.allow_migrate(schema_editor.connection.alias, model):
             schema_editor.create_model(model)
 
     def database_backwards(self, app_label, schema_editor, from_state, to_state):
-        app_cache = from_state.render()
-        model = app_cache.get_model(app_label, self.name)
+        apps = from_state.render()
+        model = apps.get_model(app_label, self.name)
         if router.allow_migrate(schema_editor.connection.alias, model):
             schema_editor.delete_model(model)
 
@@ -73,14 +73,14 @@ class DeleteModel(Operation):
         del state.models[app_label, self.name.lower()]
 
     def database_forwards(self, app_label, schema_editor, from_state, to_state):
-        app_cache = from_state.render()
-        model = app_cache.get_model(app_label, self.name)
+        apps = from_state.render()
+        model = apps.get_model(app_label, self.name)
         if router.allow_migrate(schema_editor.connection.alias, model):
             schema_editor.delete_model(model)
 
     def database_backwards(self, app_label, schema_editor, from_state, to_state):
-        app_cache = to_state.render()
-        model = app_cache.get_model(app_label, self.name)
+        apps = to_state.render()
+        model = apps.get_model(app_label, self.name)
         if router.allow_migrate(schema_editor.connection.alias, model):
             schema_editor.create_model(model)
 
@@ -106,10 +106,10 @@ class RenameModel(Operation):
         del state.models[app_label, self.old_name.lower()]
 
     def database_forwards(self, app_label, schema_editor, from_state, to_state):
-        old_app_cache = from_state.render()
-        new_app_cache = to_state.render()
-        old_model = old_app_cache.get_model(app_label, self.old_name)
-        new_model = new_app_cache.get_model(app_label, self.new_name)
+        old_apps = from_state.render()
+        new_apps = to_state.render()
+        old_model = old_apps.get_model(app_label, self.old_name)
+        new_model = new_apps.get_model(app_label, self.new_name)
         if router.allow_migrate(schema_editor.connection.alias, new_model):
             schema_editor.alter_db_table(
                 new_model,
@@ -118,10 +118,10 @@ class RenameModel(Operation):
             )
 
     def database_backwards(self, app_label, schema_editor, from_state, to_state):
-        old_app_cache = from_state.render()
-        new_app_cache = to_state.render()
-        old_model = old_app_cache.get_model(app_label, self.new_name)
-        new_model = new_app_cache.get_model(app_label, self.old_name)
+        old_apps = from_state.render()
+        new_apps = to_state.render()
+        old_model = old_apps.get_model(app_label, self.new_name)
+        new_model = new_apps.get_model(app_label, self.old_name)
         if router.allow_migrate(schema_editor.connection.alias, new_model):
             schema_editor.alter_db_table(
                 new_model,
@@ -152,10 +152,10 @@ class AlterModelTable(Operation):
         state.models[app_label, self.name.lower()].options["db_table"] = self.table
 
     def database_forwards(self, app_label, schema_editor, from_state, to_state):
-        old_app_cache = from_state.render()
-        new_app_cache = to_state.render()
-        old_model = old_app_cache.get_model(app_label, self.name)
-        new_model = new_app_cache.get_model(app_label, self.name)
+        old_apps = from_state.render()
+        new_apps = to_state.render()
+        old_model = old_apps.get_model(app_label, self.name)
+        new_model = new_apps.get_model(app_label, self.name)
         if router.allow_migrate(schema_editor.connection.alias, new_model):
             schema_editor.alter_db_table(
                 new_model,
@@ -189,10 +189,10 @@ class AlterUniqueTogether(Operation):
         model_state.options["unique_together"] = self.unique_together
 
     def database_forwards(self, app_label, schema_editor, from_state, to_state):
-        old_app_cache = from_state.render()
-        new_app_cache = to_state.render()
-        old_model = old_app_cache.get_model(app_label, self.name)
-        new_model = new_app_cache.get_model(app_label, self.name)
+        old_apps = from_state.render()
+        new_apps = to_state.render()
+        old_model = old_apps.get_model(app_label, self.name)
+        new_model = new_apps.get_model(app_label, self.name)
         if router.allow_migrate(schema_editor.connection.alias, new_model):
             schema_editor.alter_unique_together(
                 new_model,
@@ -225,10 +225,10 @@ class AlterIndexTogether(Operation):
         model_state.options["index_together"] = self.index_together
 
     def database_forwards(self, app_label, schema_editor, from_state, to_state):
-        old_app_cache = from_state.render()
-        new_app_cache = to_state.render()
-        old_model = old_app_cache.get_model(app_label, self.name)
-        new_model = new_app_cache.get_model(app_label, self.name)
+        old_apps = from_state.render()
+        new_apps = to_state.render()
+        old_model = old_apps.get_model(app_label, self.name)
+        new_model = new_apps.get_model(app_label, self.name)
         if router.allow_migrate(schema_editor.connection.alias, new_model):
             schema_editor.alter_index_together(
                 new_model,
diff --git a/django/db/migrations/operations/special.py b/django/db/migrations/operations/special.py
index f48d8cab05..65fd8125fc 100644
--- a/django/db/migrations/operations/special.py
+++ b/django/db/migrations/operations/special.py
@@ -134,7 +134,7 @@ class RunPython(Operation):
 
     def database_forwards(self, app_label, schema_editor, from_state, to_state):
         # We now execute the Python code in a context that contains a 'models'
-        # object, representing the versioned models as an AppCache.
+        # object, representing the versioned models as an app registry.
         # We could try to override the global cache, but then people will still
         # use direct imports, so we go with a documentation approach instead.
         if callable(self.code):
diff --git a/django/db/migrations/questioner.py b/django/db/migrations/questioner.py
index 8a11559993..3c43c29c11 100644
--- a/django/db/migrations/questioner.py
+++ b/django/db/migrations/questioner.py
@@ -2,10 +2,12 @@ import importlib
 import os
 import sys
 
-from django.core.apps import app_cache
+from django.apps import apps
 from django.utils import datetime_safe
 from django.utils.six.moves import input
 
+from .loader import MIGRATIONS_MODULE_NAME
+
 
 class MigrationQuestioner(object):
     """
@@ -28,10 +30,10 @@ class MigrationQuestioner(object):
         # Apps from the new app template will have these; the python
         # file check will ensure we skip South ones.
         try:
-            app_config = app_cache.get_app_config(app_label)
+            app_config = apps.get_app_config(app_label)
         except LookupError:         # It's a fake app.
             return self.defaults.get("ask_initial", False)
-        migrations_import_path = "%s.migrations" % app_config.name
+        migrations_import_path = "%s.%s" % (app_config.name, MIGRATIONS_MODULE_NAME)
         try:
             migrations_module = importlib.import_module(migrations_import_path)
         except ImportError:
diff --git a/django/db/migrations/recorder.py b/django/db/migrations/recorder.py
index c2cfd2e9af..15a3b49578 100644
--- a/django/db/migrations/recorder.py
+++ b/django/db/migrations/recorder.py
@@ -1,4 +1,4 @@
-from django.core.apps.cache import AppCache
+from django.apps.registry import Apps
 from django.db import models
 from django.utils.timezone import now
 
@@ -22,7 +22,7 @@ class MigrationRecorder(object):
         applied = models.DateTimeField(default=now)
 
         class Meta:
-            app_cache = AppCache()
+            apps = Apps()
             app_label = "migrations"
             db_table = "django_migrations"
 
diff --git a/django/db/migrations/state.py b/django/db/migrations/state.py
index c43728d58e..3bc7837089 100644
--- a/django/db/migrations/state.py
+++ b/django/db/migrations/state.py
@@ -1,4 +1,5 @@
-from django.core.apps.cache import AppCache
+from django.apps import AppConfig
+from django.apps.registry import Apps
 from django.db import models
 from django.db.models.options import DEFAULT_NAMES, normalize_unique_together
 from django.utils import six
@@ -18,7 +19,7 @@ class ProjectState(object):
 
     def __init__(self, models=None):
         self.models = models or {}
-        self.app_cache = None
+        self.apps = None
 
     def add_model_state(self, model_state):
         self.models[(model_state.app_label, model_state.name.lower())] = model_state
@@ -30,9 +31,11 @@ class ProjectState(object):
         )
 
     def render(self):
-        "Turns the project state into actual models in a new AppCache"
-        if self.app_cache is None:
-            self.app_cache = AppCache()
+        "Turns the project state into actual models in a new Apps"
+        if self.apps is None:
+            # Populate the app registry with a stub for each application.
+            app_labels = set(model_state.app_label for model_state in self.models.values())
+            self.apps = Apps([AppConfigStub(label) for label in sorted(app_labels)])
             # We keep trying to render the models in a loop, ignoring invalid
             # base errors, until the size of the unrendered models doesn't
             # decrease by at least one, meaning there's a base dependency loop/
@@ -42,19 +45,19 @@ class ProjectState(object):
                 new_unrendered_models = []
                 for model in unrendered_models:
                     try:
-                        model.render(self.app_cache)
+                        model.render(self.apps)
                     except InvalidBasesError:
                         new_unrendered_models.append(model)
                 if len(new_unrendered_models) == len(unrendered_models):
                     raise InvalidBasesError("Cannot resolve bases for %r" % new_unrendered_models)
                 unrendered_models = new_unrendered_models
-        return self.app_cache
+        return self.apps
 
     @classmethod
-    def from_app_cache(cls, app_cache):
-        "Takes in an AppCache and returns a ProjectState matching it"
+    def from_apps(cls, apps):
+        "Takes in an Apps and returns a ProjectState matching it"
         app_models = {}
-        for model in app_cache.get_models():
+        for model in apps.get_models():
             model_state = ModelState.from_model(model)
             app_models[(model_state.app_label, model_state.name.lower())] = model_state
         return cls(app_models)
@@ -68,6 +71,17 @@ class ProjectState(object):
         return not (self == other)
 
 
+class AppConfigStub(AppConfig):
+    """
+    Stubs a Django AppConfig. Only provides a label and a dict of models.
+    """
+    def __init__(self, label):
+        super(AppConfigStub, self).__init__(label, None)
+
+    def import_models(self, all_models):
+        self.models = all_models
+
+
 class ModelState(object):
     """
     Represents a Django Model. We don't use the actual Model class
@@ -123,7 +137,7 @@ class ModelState(object):
         options = {}
         for name in DEFAULT_NAMES:
             # Ignore some special options
-            if name in ["app_cache", "app_label"]:
+            if name in ["apps", "app_label"]:
                 continue
             elif name in model._meta.original_attrs:
                 if name == "unique_together":
@@ -133,7 +147,7 @@ class ModelState(object):
                     options[name] = model._meta.original_attrs[name]
         # Make our record
         bases = tuple(
-            ("%s.%s" % (base._meta.app_label, base._meta.object_name.lower()) if hasattr(base, "_meta") else base)
+            ("%s.%s" % (base._meta.app_label, base._meta.model_name) if hasattr(base, "_meta") else base)
             for base in model.__bases__
             if (not hasattr(base, "_meta") or not base._meta.abstract)
         )
@@ -164,20 +178,21 @@ class ModelState(object):
             bases=self.bases,
         )
 
-    def render(self, app_cache):
-        "Creates a Model object from our current state into the given app_cache"
+    def render(self, apps):
+        "Creates a Model object from our current state into the given apps"
         # First, make a Meta object
-        meta_contents = {'app_label': self.app_label, "app_cache": app_cache}
+        meta_contents = {'app_label': self.app_label, "apps": apps}
         meta_contents.update(self.options)
         if "unique_together" in meta_contents:
             meta_contents["unique_together"] = list(meta_contents["unique_together"])
         meta = type("Meta", tuple(), meta_contents)
         # Then, work out our bases
-        bases = tuple(
-            (app_cache.get_model(*base.split(".", 1)) if isinstance(base, six.string_types) else base)
-            for base in self.bases
-        )
-        if None in bases:
+        try:
+            bases = tuple(
+                (apps.get_model(*base.split(".", 1)) if isinstance(base, six.string_types) else base)
+                for base in self.bases
+            )
+        except LookupError:
             raise InvalidBasesError("Cannot resolve one or more bases from %r" % (self.bases,))
         # Turn fields into a dict for the body, add other bits
         body = dict(self.fields)
diff --git a/django/db/migrations/writer.py b/django/db/migrations/writer.py
index 04e00501f9..549c72ed60 100644
--- a/django/db/migrations/writer.py
+++ b/django/db/migrations/writer.py
@@ -5,7 +5,7 @@ from importlib import import_module
 import os
 import types
 
-from django.core.apps import app_cache
+from django.apps import apps
 from django.db import models
 from django.db.migrations.loader import MigrationLoader
 from django.utils.encoding import force_text
@@ -69,7 +69,7 @@ class MigrationWriter(object):
             migrations_module = import_module(migrations_package_name)
             basedir = os.path.dirname(migrations_module.__file__)
         except ImportError:
-            app_config = app_cache.get_app_config(self.migration.app_label)
+            app_config = apps.get_app_config(self.migration.app_label)
             migrations_package_basename = migrations_package_name.split(".")[-1]
 
             # Alright, see if it's a direct submodule of the app
diff --git a/django/db/models/base.py b/django/db/models/base.py
index 56973d4e38..d7b54b9268 100644
--- a/django/db/models/base.py
+++ b/django/db/models/base.py
@@ -3,10 +3,10 @@ from __future__ import unicode_literals
 import copy
 import sys
 from functools import update_wrapper
-from django.utils.six.moves import zip
+import warnings
 
-from django.core.apps import app_cache
-from django.core.apps.cache import MODELS_MODULE_NAME
+from django.apps import apps
+from django.apps.base import MODELS_MODULE_NAME
 import django.db.models.manager  # NOQA: Imported to register signal handler.
 from django.conf import settings
 from django.core.exceptions import (ObjectDoesNotExist,
@@ -25,6 +25,7 @@ from django.utils.translation import ugettext_lazy as _
 from django.utils.functional import curry
 from django.utils.encoding import force_str, force_text
 from django.utils import six
+from django.utils.six.moves import zip
 from django.utils.text import get_text_list, capfirst
 
 
@@ -86,23 +87,42 @@ class ModelBase(type):
             meta = attr_meta
         base_meta = getattr(new_class, '_meta', None)
 
+        # Look for an application configuration to attach the model to.
+        app_config = apps.get_containing_app_config(module)
+
         if getattr(meta, 'app_label', None) is None:
-            # Figure out the app_label by looking one level up from the package
-            # or module named 'models'. If no such package or module exists,
-            # fall back to looking one level up from the module this model is
-            # defined in.
 
-            # For 'django.contrib.sites.models', this would be 'sites'.
-            # For 'geo.models.places' this would be 'geo'.
+            if app_config is None:
+                # If the model is imported before the configuration for its
+                # application is created (#21719), or isn't in an installed
+                # application (#21680), use the legacy logic to figure out the
+                # app_label by looking one level up from the package or module
+                # named 'models'. If no such package or module exists, fall
+                # back to looking one level up from the module this model is
+                # defined in.
+
+                # For 'django.contrib.sites.models', this would be 'sites'.
+                # For 'geo.models.places' this would be 'geo'.
+
+                warnings.warn(
+                    "Model class %s.%s doesn't declare an explicit app_label "
+                    "and either isn't in an application in  INSTALLED_APPS "
+                    "or else was imported before its application was loaded. "
+                    "This will no longer be supported in Django 1.9."
+                    % (module, name), PendingDeprecationWarning, stacklevel=2)
+
+                model_module = sys.modules[new_class.__module__]
+                package_components = model_module.__name__.split('.')
+                package_components.reverse()  # find the last occurrence of 'models'
+                try:
+                    app_label_index = package_components.index(MODELS_MODULE_NAME) + 1
+                except ValueError:
+                    app_label_index = 1
+                kwargs = {"app_label": package_components[app_label_index]}
+
+            else:
+                kwargs = {"app_label": app_config.label}
 
-            model_module = sys.modules[new_class.__module__]
-            package_components = model_module.__name__.split('.')
-            package_components.reverse()  # find the last occurrence of 'models'
-            try:
-                app_label_index = package_components.index(MODELS_MODULE_NAME) + 1
-            except ValueError:
-                app_label_index = 1
-            kwargs = {"app_label": package_components[app_label_index]}
         else:
             kwargs = {}
 
@@ -150,12 +170,6 @@ class ModelBase(type):
                 new_class._default_manager = new_class._default_manager._copy_to_model(new_class)
                 new_class._base_manager = new_class._base_manager._copy_to_model(new_class)
 
-        # Bail out early if we have already created this class.
-        m = new_class._meta.app_cache.get_model(new_class._meta.app_label, name,
-                      seed_cache=False, only_installed=False)
-        if m is not None:
-            return m
-
         # Add all attributes to the class.
         for obj_name, obj in attrs.items():
             new_class.add_to_class(obj_name, obj)
@@ -273,14 +287,8 @@ class ModelBase(type):
             return new_class
 
         new_class._prepare()
-
-        new_class._meta.app_cache.register_model(new_class._meta.app_label, new_class)
-        # Because of the way imports happen (recursively), we may or may not be
-        # the first time this model tries to register with the framework. There
-        # should only be one class for each model, so we always return the
-        # registered version.
-        return new_class._meta.app_cache.get_model(new_class._meta.app_label, name,
-                         seed_cache=False, only_installed=False)
+        new_class._meta.apps.register_model(new_class._meta.app_label, new_class)
+        return new_class
 
     def copy_managers(cls, base_managers):
         # This is in-place sorting of an Options attribute, but that's fine.
@@ -1067,7 +1075,7 @@ def model_unpickle(model_id, attrs, factory):
     Used to unpickle Model subclasses with deferred fields.
     """
     if isinstance(model_id, tuple):
-        model = app_cache.get_model(*model_id)
+        model = apps.get_model(*model_id)
     else:
         # Backwards compat - the model was cached directly in earlier versions.
         model = model_id
diff --git a/django/db/models/fields/__init__.py b/django/db/models/fields/__init__.py
index a1b8ded06e..3465d4f163 100644
--- a/django/db/models/fields/__init__.py
+++ b/django/db/models/fields/__init__.py
@@ -10,7 +10,7 @@ import warnings
 from base64 import b64decode, b64encode
 from itertools import tee
 
-from django.core.apps import app_cache
+from django.apps import apps
 from django.db import connection
 from django.db.models.lookups import default_lookups
 from django.db.models.query_utils import QueryWrapper
@@ -53,7 +53,7 @@ BLANK_CHOICE_DASH = [("", "---------")]
 
 
 def _load_field(app_label, model_name, field_name):
-    return app_cache.get_model(app_label, model_name)._meta.get_field_by_name(field_name)[0]
+    return apps.get_model(app_label, model_name)._meta.get_field_by_name(field_name)[0]
 
 
 class FieldDoesNotExist(Exception):
@@ -290,7 +290,7 @@ class Field(object):
     def __reduce__(self):
         """
         Pickling should return the model._meta.fields instance of the field,
-        not a new copy of that field. So, we use the app cache to load the
+        not a new copy of that field. So, we use the app registry to load the
         model and then the field back.
         """
         if not hasattr(self, 'model'):
@@ -301,8 +301,8 @@ class Field(object):
             # values - so, this is very close to normal pickle.
             return _empty, (self.__class__,), self.__dict__
         if self.model._deferred:
-            # Deferred model will not be found from the app cache. This could
-            # be fixed by reconstructing the deferred model on unpickle.
+            # Deferred model will not be found from the app registry. This
+            # could be fixed by reconstructing the deferred model on unpickle.
             raise RuntimeError("Fields of deferred models can't be reduced")
         return _load_field, (self.model._meta.app_label, self.model._meta.object_name,
                              self.name)
@@ -756,7 +756,7 @@ class AutoField(Field):
         assert kwargs.get('primary_key', False) is True, \
             "%ss must have primary_key=True." % self.__class__.__name__
         kwargs['blank'] = True
-        Field.__init__(self, *args, **kwargs)
+        super(AutoField, self).__init__(*args, **kwargs)
 
     def deconstruct(self):
         name, path, args, kwargs = super(AutoField, self).deconstruct()
@@ -814,7 +814,7 @@ class BooleanField(Field):
 
     def __init__(self, *args, **kwargs):
         kwargs['blank'] = True
-        Field.__init__(self, *args, **kwargs)
+        super(BooleanField, self).__init__(*args, **kwargs)
 
     def deconstruct(self):
         name, path, args, kwargs = super(BooleanField, self).deconstruct()
@@ -926,7 +926,7 @@ class DateField(Field):
         if auto_now or auto_now_add:
             kwargs['editable'] = False
             kwargs['blank'] = True
-        Field.__init__(self, verbose_name, name, **kwargs)
+        super(DateField, self).__init__(verbose_name, name, **kwargs)
 
     def deconstruct(self):
         name, path, args, kwargs = super(DateField, self).deconstruct()
@@ -1138,7 +1138,7 @@ class DecimalField(Field):
     def __init__(self, verbose_name=None, name=None, max_digits=None,
                  decimal_places=None, **kwargs):
         self.max_digits, self.decimal_places = max_digits, decimal_places
-        Field.__init__(self, verbose_name, name, **kwargs)
+        super(DecimalField, self).__init__(verbose_name, name, **kwargs)
 
     def deconstruct(self):
         name, path, args, kwargs = super(DecimalField, self).deconstruct()
@@ -1210,7 +1210,7 @@ class EmailField(CharField):
         # compliant with RFCs 3696 and 5321
 
         kwargs['max_length'] = kwargs.get('max_length', 75)
-        CharField.__init__(self, *args, **kwargs)
+        super(EmailField, self).__init__(*args, **kwargs)
 
     def deconstruct(self):
         name, path, args, kwargs = super(EmailField, self).deconstruct()
@@ -1236,7 +1236,7 @@ class FilePathField(Field):
         self.path, self.match, self.recursive = path, match, recursive
         self.allow_files, self.allow_folders = allow_files, allow_folders
         kwargs['max_length'] = kwargs.get('max_length', 100)
-        Field.__init__(self, verbose_name, name, **kwargs)
+        super(FilePathField, self).__init__(verbose_name, name, **kwargs)
 
     def deconstruct(self):
         name, path, args, kwargs = super(FilePathField, self).deconstruct()
@@ -1367,7 +1367,7 @@ class IPAddressField(Field):
         warnings.warn("IPAddressField has been deprecated. Use GenericIPAddressField instead.",
                       PendingDeprecationWarning)
         kwargs['max_length'] = 15
-        Field.__init__(self, *args, **kwargs)
+        super(IPAddressField, self).__init__(*args, **kwargs)
 
     def deconstruct(self):
         name, path, args, kwargs = super(IPAddressField, self).deconstruct()
@@ -1396,7 +1396,8 @@ class GenericIPAddressField(Field):
             validators.ip_address_validators(protocol, unpack_ipv4)
         self.default_error_messages['invalid'] = invalid_error_message
         kwargs['max_length'] = 39
-        Field.__init__(self, verbose_name, name, *args, **kwargs)
+        super(GenericIPAddressField, self).__init__(verbose_name, name, *args,
+                                                    **kwargs)
 
     def deconstruct(self):
         name, path, args, kwargs = super(GenericIPAddressField, self).deconstruct()
@@ -1450,7 +1451,7 @@ class NullBooleanField(Field):
     def __init__(self, *args, **kwargs):
         kwargs['null'] = True
         kwargs['blank'] = True
-        Field.__init__(self, *args, **kwargs)
+        super(NullBooleanField, self).__init__(*args, **kwargs)
 
     def deconstruct(self):
         name, path, args, kwargs = super(NullBooleanField, self).deconstruct()
@@ -1599,7 +1600,7 @@ class TimeField(Field):
         if auto_now or auto_now_add:
             kwargs['editable'] = False
             kwargs['blank'] = True
-        Field.__init__(self, verbose_name, name, **kwargs)
+        super(TimeField, self).__init__(verbose_name, name, **kwargs)
 
     def deconstruct(self):
         name, path, args, kwargs = super(TimeField, self).deconstruct()
@@ -1674,7 +1675,7 @@ class URLField(CharField):
 
     def __init__(self, verbose_name=None, name=None, **kwargs):
         kwargs['max_length'] = kwargs.get('max_length', 200)
-        CharField.__init__(self, verbose_name, name, **kwargs)
+        super(URLField, self).__init__(verbose_name, name, **kwargs)
 
     def deconstruct(self):
         name, path, args, kwargs = super(URLField, self).deconstruct()
diff --git a/django/db/models/fields/related.py b/django/db/models/fields/related.py
index 2d3e4bc448..69fb3f8492 100644
--- a/django/db/models/fields/related.py
+++ b/django/db/models/fields/related.py
@@ -70,14 +70,14 @@ def add_lazy_relation(cls, field, relation, operation):
     # string right away. If get_model returns None, it means that the related
     # model isn't loaded yet, so we need to pend the relation until the class
     # is prepared.
-    model = cls._meta.app_cache.get_model(app_label, model_name,
-                      seed_cache=False, only_installed=False)
-    if model:
-        operation(field, model, cls)
-    else:
+    try:
+        model = cls._meta.apps.get_registered_model(app_label, model_name)
+    except LookupError:
         key = (app_label, model_name)
         value = (cls, field, operation)
-        cls._meta.app_cache.pending_lookups.setdefault(key, []).append(value)
+        cls._meta.apps._pending_lookups.setdefault(key, []).append(value)
+    else:
+        operation(field, model, cls)
 
 
 def do_pending_lookups(sender, **kwargs):
@@ -85,7 +85,7 @@ def do_pending_lookups(sender, **kwargs):
     Handle any pending relations to the sending model. Sent from class_prepared.
     """
     key = (sender._meta.app_label, sender.__name__)
-    for cls, field, operation in sender._meta.app_cache.pending_lookups.pop(key, []):
+    for cls, field, operation in sender._meta.apps._pending_lookups.pop(key, []):
         operation(field, sender, cls)
 
 signals.class_prepared.connect(do_pending_lookups)
@@ -1092,7 +1092,7 @@ class ForeignObject(RelatedField):
         if len(self.from_fields) < 1 or len(self.from_fields) != len(self.to_fields):
             raise ValueError('Foreign Object from and to fields must be the same non-zero length')
         if isinstance(self.rel.to, six.string_types):
-            raise ValueError('Related model %r cannot been resolved' % self.rel.to)
+            raise ValueError('Related model %r cannot be resolved' % self.rel.to)
         related_fields = []
         for index in range(len(self.from_fields)):
             from_field_name = self.from_fields[index]
@@ -1286,7 +1286,7 @@ class ForeignKey(ForeignObject):
     def __init__(self, to, to_field=None, rel_class=ManyToOneRel,
                  db_constraint=True, **kwargs):
         try:
-            to._meta.object_name.lower()
+            to._meta.model_name
         except AttributeError:  # to._meta doesn't exist, so it must be RECURSIVE_RELATIONSHIP_CONSTANT
             assert isinstance(to, six.string_types), "%s(%r) is invalid. First parameter to ForeignKey must be either a model, a model name, or the string %r" % (self.__class__.__name__, to, RECURSIVE_RELATIONSHIP_CONSTANT)
         else:
@@ -1502,7 +1502,7 @@ def create_many_to_many_intermediary_model(field, klass):
         'unique_together': (from_, to),
         'verbose_name': '%(from)s-%(to)s relationship' % {'from': from_, 'to': to},
         'verbose_name_plural': '%(from)s-%(to)s relationships' % {'from': from_, 'to': to},
-        'app_cache': field.model._meta.app_cache,
+        'apps': field.model._meta.apps,
     })
     # Construct and return the new class.
     return type(str(name), (models.Model,), {
diff --git a/django/db/models/loading.py b/django/db/models/loading.py
index 5745dbed4d..2d24ca646d 100644
--- a/django/db/models/loading.py
+++ b/django/db/models/loading.py
@@ -1,6 +1,6 @@
 import warnings
 
-from django.core.apps import app_cache
+from django.apps import apps
 
 warnings.warn(
     "The utilities in django.db.models.loading are deprecated "
@@ -12,24 +12,23 @@ __all__ = ('get_apps', 'get_app', 'get_models', 'get_model', 'register_models',
 
 # These methods were always module level, so are kept that way for backwards
 # compatibility.
-get_apps = app_cache.get_apps
-get_app_package = app_cache.get_app_package
-get_app_path = app_cache.get_app_path
-get_app_paths = app_cache.get_app_paths
-get_app = app_cache.get_app
-get_models = app_cache.get_models
-get_model = app_cache.get_model
-register_models = app_cache.register_models
-load_app = app_cache.load_app
-app_cache_ready = app_cache.app_cache_ready
+get_apps = apps.get_apps
+get_app_package = apps.get_app_package
+get_app_path = apps.get_app_path
+get_app_paths = apps.get_app_paths
+get_app = apps.get_app
+get_models = apps.get_models
+get_model = apps.get_model
+register_models = apps.register_models
+load_app = apps.load_app
+app_cache_ready = apps.app_cache_ready
 
 
 # This method doesn't return anything interesting in Django 1.6. Maintain it
 # just for backwards compatibility until this module is deprecated.
 def get_app_errors():
     try:
-        return app_cache.app_errors
+        return apps.app_errors
     except AttributeError:
-        app_cache.populate()
-        app_cache.app_errors = {}
-        return app_cache.app_errors
+        apps.app_errors = {}
+        return apps.app_errors
diff --git a/django/db/models/options.py b/django/db/models/options.py
index cd68d5eae9..414271a95e 100644
--- a/django/db/models/options.py
+++ b/django/db/models/options.py
@@ -1,28 +1,26 @@
 from __future__ import unicode_literals
 
-from collections import OrderedDict
-import re
 from bisect import bisect
+from collections import OrderedDict
 import warnings
 
+from django.apps import apps
 from django.conf import settings
-from django.core.apps import app_cache
 from django.db.models.fields.related import ManyToManyRel
 from django.db.models.fields import AutoField, FieldDoesNotExist
 from django.db.models.fields.proxy import OrderWrt
 from django.utils import six
 from django.utils.functional import cached_property
 from django.utils.encoding import force_text, smart_text, python_2_unicode_compatible
+from django.utils.text import camel_case_to_spaces
 from django.utils.translation import activate, deactivate_all, get_language, string_concat
 
-# Calculate the verbose_name by converting from InitialCaps to "lowercase with spaces".
-get_verbose_name = lambda class_name: re.sub('(((?<=[a-z])[A-Z])|([A-Z](?![A-Z]|$)))', ' \\1', class_name).lower().strip()
 
 DEFAULT_NAMES = ('verbose_name', 'verbose_name_plural', 'db_table', 'ordering',
                  'unique_together', 'permissions', 'get_latest_by',
                  'order_with_respect_to', 'app_label', 'db_tablespace',
                  'abstract', 'managed', 'proxy', 'swappable', 'auto_created',
-                 'index_together', 'app_cache', 'default_permissions',
+                 'index_together', 'apps', 'default_permissions',
                  'select_on_save')
 
 
@@ -44,9 +42,11 @@ def normalize_unique_together(unique_together):
 @python_2_unicode_compatible
 class Options(object):
     def __init__(self, meta, app_label=None):
-        self.local_fields, self.local_many_to_many = [], []
+        self.local_fields = []
+        self.local_many_to_many = []
         self.virtual_fields = []
-        self.model_name, self.verbose_name = None, None
+        self.model_name = None
+        self.verbose_name = None
         self.verbose_name_plural = None
         self.db_table = ''
         self.ordering = []
@@ -55,13 +55,15 @@ class Options(object):
         self.select_on_save = False
         self.default_permissions = ('add', 'change', 'delete')
         self.permissions = []
-        self.object_name, self.app_label = None, app_label
+        self.object_name = None
+        self.app_label = app_label
         self.get_latest_by = None
         self.order_with_respect_to = None
         self.db_tablespace = settings.DEFAULT_TABLESPACE
         self.meta = meta
         self.pk = None
-        self.has_auto_field, self.auto_field = False, None
+        self.has_auto_field = False
+        self.auto_field = None
         self.abstract = False
         self.managed = True
         self.proxy = False
@@ -88,17 +90,17 @@ class Options(object):
         # from *other* models. Needed for some admin checks. Internal use only.
         self.related_fkey_lookups = []
 
-        # A custom AppCache to use, if you're making a separate model set.
-        self.app_cache = app_cache
+        # A custom app registry to use, if you're making a separate model set.
+        self.apps = apps
 
     @property
     def app_config(self):
-        # Don't go through get_app_config to avoid triggering populate().
-        return self.app_cache.app_configs[self.app_label]
+        # Don't go through get_app_config to avoid triggering imports.
+        return self.apps.app_configs.get(self.app_label)
 
     @property
     def installed(self):
-        return self.app_config.installed
+        return self.app_config is not None
 
     def contribute_to_class(self, cls, name):
         from django.db import connection
@@ -109,7 +111,7 @@ class Options(object):
         # First, construct the default values for these options.
         self.object_name = cls.__name__
         self.model_name = self.object_name.lower()
-        self.verbose_name = get_verbose_name(self.object_name)
+        self.verbose_name = camel_case_to_spaces(self.object_name)
 
         # Store the original user-defined values for each option,
         # for use when serializing the model definition
@@ -440,7 +442,7 @@ class Options(object):
             if hasattr(f, 'related'):
                 cache[f.name] = cache[f.attname] = (
                     f.related, None if f.model == self.model else f.model, True, False)
-        if app_cache.app_cache_ready():
+        if apps.ready:
             self._name_map = cache
         return cache
 
@@ -516,7 +518,7 @@ class Options(object):
                     cache[obj] = model
         # Collect also objects which are in relation to some proxy child/parent of self.
         proxy_cache = cache.copy()
-        for klass in self.app_cache.get_models(include_auto_created=True, only_installed=False):
+        for klass in self.apps.get_models(include_auto_created=True):
             if not klass._meta.swapped:
                 for f in klass._meta.local_fields:
                     if f.rel and not isinstance(f.rel.to, six.string_types) and f.generate_reverse_relation:
@@ -559,14 +561,14 @@ class Options(object):
                     cache[obj] = parent
                 else:
                     cache[obj] = model
-        for klass in self.app_cache.get_models(only_installed=False):
+        for klass in self.apps.get_models():
             if not klass._meta.swapped:
                 for f in klass._meta.local_many_to_many:
                     if (f.rel
                             and not isinstance(f.rel.to, six.string_types)
                             and self == f.rel.to._meta):
                         cache[f.related] = None
-        if app_cache.app_cache_ready():
+        if apps.ready:
             self._related_many_to_many_cache = cache
         return cache
 
diff --git a/django/db/models/query_utils.py b/django/db/models/query_utils.py
index a7d98f60fe..b6971e9f24 100644
--- a/django/db/models/query_utils.py
+++ b/django/db/models/query_utils.py
@@ -7,6 +7,7 @@ circular import difficulties.
 """
 from __future__ import unicode_literals
 
+from django.apps import apps
 from django.db.backends import utils
 from django.utils import six
 from django.utils import tree
@@ -185,22 +186,28 @@ def deferred_class_factory(model, attrs):
     being replaced with DeferredAttribute objects. The "pk_value" ties the
     deferred attributes to a particular instance of the model.
     """
-    class Meta:
-        proxy = True
-        app_label = model._meta.app_label
-
-    # The app_cache wants a unique name for each model, otherwise the new class
-    # won't be created (we get an old one back). Therefore, we generate the
-    # name using the passed in attrs. It's OK to reuse an existing class
+    # The app registry wants a unique name for each model, otherwise the new
+    # class won't be created (we get an exception). Therefore, we generate
+    # the name using the passed in attrs. It's OK to reuse an existing class
     # object if the attrs are identical.
     name = "%s_Deferred_%s" % (model.__name__, '_'.join(sorted(list(attrs))))
     name = utils.truncate_name(name, 80, 32)
 
-    overrides = dict((attr, DeferredAttribute(attr, model)) for attr in attrs)
-    overrides["Meta"] = Meta
-    overrides["__module__"] = model.__module__
-    overrides["_deferred"] = True
-    return type(str(name), (model,), overrides)
+    try:
+        return apps.get_model(model._meta.app_label, name)
+
+    except LookupError:
+
+        class Meta:
+            proxy = True
+            app_label = model._meta.app_label
+
+        overrides = dict((attr, DeferredAttribute(attr, model)) for attr in attrs)
+        overrides["Meta"] = Meta
+        overrides["__module__"] = model.__module__
+        overrides["_deferred"] = True
+        return type(str(name), (model,), overrides)
+
 
 # The above function is also used to unpickle model instances with deferred
 # fields.
diff --git a/django/db/models/signals.py b/django/db/models/signals.py
index a6822309a3..627358ac63 100644
--- a/django/db/models/signals.py
+++ b/django/db/models/signals.py
@@ -1,6 +1,4 @@
-from collections import defaultdict
-
-from django.core.apps import app_cache
+from django.apps import apps
 from django.dispatch import Signal
 from django.utils import six
 
@@ -16,7 +14,7 @@ class ModelSignal(Signal):
 
     def __init__(self, *args, **kwargs):
         super(ModelSignal, self).__init__(*args, **kwargs)
-        self.unresolved_references = defaultdict(list)
+        self.unresolved_references = {}
         class_prepared.connect(self._resolve_references)
 
     def _resolve_references(self, sender, **kwargs):
@@ -35,18 +33,18 @@ class ModelSignal(Signal):
     def connect(self, receiver, sender=None, weak=True, dispatch_uid=None):
         if isinstance(sender, six.string_types):
             try:
-                app_label, object_name = sender.split('.')
+                app_label, model_name = sender.split('.')
             except ValueError:
                 raise ValueError(
                     "Specified sender must either be a model or a "
                     "model name of the 'app_label.ModelName' form."
                 )
-            sender = app_cache.get_model(app_label, object_name, only_installed=False)
-            if sender is None:
-                reference = (app_label, object_name)
-                self.unresolved_references[reference].append(
-                    (receiver, weak, dispatch_uid)
-                )
+            try:
+                sender = apps.get_registered_model(app_label, model_name)
+            except LookupError:
+                ref = (app_label, model_name)
+                refs = self.unresolved_references.setdefault(ref, [])
+                refs.append((receiver, weak, dispatch_uid))
                 return
         super(ModelSignal, self).connect(
             receiver, sender=sender, weak=weak, dispatch_uid=dispatch_uid
@@ -64,7 +62,8 @@ post_delete = ModelSignal(providing_args=["instance", "using"], use_caching=True
 
 m2m_changed = ModelSignal(providing_args=["action", "instance", "reverse", "model", "pk_set", "using"], use_caching=True)
 
-pre_migrate = Signal(providing_args=["app", "create_models", "verbosity", "interactive", "db"])
-pre_syncdb = pre_migrate
-post_migrate = Signal(providing_args=["class", "app", "created_models", "verbosity", "interactive", "db"])
-post_syncdb = post_migrate
+pre_migrate = Signal(providing_args=["app_config", "verbosity", "interactive", "db"])
+post_migrate = Signal(providing_args=["app_config", "verbosity", "interactive", "db"])
+
+pre_syncdb = Signal(providing_args=["app", "create_models", "verbosity", "interactive", "db"])
+post_syncdb = Signal(providing_args=["class", "app", "created_models", "verbosity", "interactive", "db"])
diff --git a/django/db/models/sql/expressions.py b/django/db/models/sql/expressions.py
index bd661b5adf..9f29e2ace5 100644
--- a/django/db/models/sql/expressions.py
+++ b/django/db/models/sql/expressions.py
@@ -111,6 +111,7 @@ class SQLEvaluator(object):
     def evaluate_date_modifier_node(self, node, qn, connection):
         timedelta = node.children.pop()
         sql, params = self.evaluate_node(node, qn, connection)
+        node.children.append(timedelta)
 
         if (timedelta.days == timedelta.seconds == timedelta.microseconds == 0):
             return sql, params
diff --git a/django/db/utils.py b/django/db/utils.py
index 4d53d252bf..0bcf33f252 100644
--- a/django/db/utils.py
+++ b/django/db/utils.py
@@ -278,10 +278,9 @@ class ConnectionRouter(object):
                     return allow
         return True
 
-    def get_migratable_models(self, app, db, include_auto_created=False):
+    def get_migratable_models(self, app_config, db, include_auto_created=False):
         """
         Return app models allowed to be synchronized on provided db.
         """
-        from django.core.apps import app_cache
-        return [model for model in app_cache.get_models(app, include_auto_created=include_auto_created)
-                if self.allow_migrate(db, model)]
+        models = app_config.get_models(include_auto_created=include_auto_created)
+        return [model for model in models if self.allow_migrate(db, model)]
diff --git a/django/forms/forms.py b/django/forms/forms.py
index 880a74f49e..bcc0d6dfa4 100644
--- a/django/forms/forms.py
+++ b/django/forms/forms.py
@@ -661,7 +661,7 @@ class BoundField(object):
         """
         Wrapper around the field widget's `id_for_label` method.
         Useful, for example, for focusing on this field regardless of whether
-        it has a single widget or a MutiWidget.
+        it has a single widget or a MultiWidget.
         """
         widget = self.field.widget
         id_ = widget.attrs.get('id') or self.auto_id
diff --git a/django/template/base.py b/django/template/base.py
index c314637c42..883609cf3e 100644
--- a/django/template/base.py
+++ b/django/template/base.py
@@ -5,6 +5,7 @@ from functools import partial
 from importlib import import_module
 from inspect import getargspec, getcallargs
 
+from django.apps import apps
 from django.conf import settings
 from django.template.context import (BaseContext, Context, RequestContext,  # NOQA: imported for backwards compatibility
     ContextPopException)
@@ -1302,9 +1303,12 @@ def get_templatetags_modules():
         # Populate list once per process. Mutate the local list first, and
         # then assign it to the global name to ensure there are no cases where
         # two threads try to populate it simultaneously.
-        for app_module in ['django'] + list(settings.INSTALLED_APPS):
+
+        templatetags_modules_candidates = ['django.templatetags']
+        templatetags_modules_candidates += ['%s.templatetags' % app_config.name
+            for app_config in apps.get_app_configs()]
+        for templatetag_module in templatetags_modules_candidates:
             try:
-                templatetag_module = '%s.templatetags' % app_module
                 import_module(templatetag_module)
                 _templatetags_modules.append(templatetag_module)
             except ImportError:
diff --git a/django/template/loaders/app_directories.py b/django/template/loaders/app_directories.py
index 4f8ddfccac..b66adaed08 100644
--- a/django/template/loaders/app_directories.py
+++ b/django/template/loaders/app_directories.py
@@ -3,34 +3,34 @@ Wrapper for loading templates from "templates" directories in INSTALLED_APPS
 packages.
 """
 
-from importlib import import_module
 import os
 import sys
 
+from django.apps import apps
 from django.conf import settings
-from django.core.exceptions import ImproperlyConfigured
 from django.template.base import TemplateDoesNotExist
 from django.template.loader import BaseLoader
 from django.utils._os import safe_join
 from django.utils import six
 
-# At compile time, cache the directories to search.
-if six.PY2:
-    fs_encoding = sys.getfilesystemencoding() or sys.getdefaultencoding()
-app_template_dirs = []
-for app in settings.INSTALLED_APPS:
-    try:
-        mod = import_module(app)
-    except ImportError as e:
-        raise ImproperlyConfigured('ImportError %s: %s' % (app, e.args[0]))
-    template_dir = os.path.join(os.path.dirname(mod.__file__), 'templates')
-    if os.path.isdir(template_dir):
-        if six.PY2:
-            template_dir = template_dir.decode(fs_encoding)
-        app_template_dirs.append(template_dir)
 
-# It won't change, so convert it to a tuple to save memory.
-app_template_dirs = tuple(app_template_dirs)
+def calculate_app_template_dirs():
+    if six.PY2:
+        fs_encoding = sys.getfilesystemencoding() or sys.getdefaultencoding()
+    app_template_dirs = []
+    for app_config in apps.get_app_configs():
+        if not app_config.path:
+            continue
+        template_dir = os.path.join(app_config.path, 'templates')
+        if os.path.isdir(template_dir):
+            if six.PY2:
+                template_dir = template_dir.decode(fs_encoding)
+            app_template_dirs.append(template_dir)
+    return tuple(app_template_dirs)
+
+
+# At compile time, cache the directories to search.
+app_template_dirs = calculate_app_template_dirs()
 
 
 class Loader(BaseLoader):
diff --git a/django/template/loaders/eggs.py b/django/template/loaders/eggs.py
index 04e4f73b7b..bb49b302c9 100644
--- a/django/template/loaders/eggs.py
+++ b/django/template/loaders/eggs.py
@@ -6,6 +6,7 @@ try:
 except ImportError:
     resource_string = None
 
+from django.apps import apps
 from django.conf import settings
 from django.template.base import TemplateDoesNotExist
 from django.template.loader import BaseLoader
@@ -23,12 +24,12 @@ class Loader(BaseLoader):
         """
         if resource_string is not None:
             pkg_name = 'templates/' + template_name
-            for app in settings.INSTALLED_APPS:
+            for app_config in apps.get_app_configs():
                 try:
-                    resource = resource_string(app, pkg_name)
+                    resource = resource_string(app_config.name, pkg_name)
                 except Exception:
                     continue
                 if six.PY2:
                     resource = resource.decode(settings.FILE_CHARSET)
-                return (resource, 'egg:%s:%s' % (app, pkg_name))
+                return (resource, 'egg:%s:%s' % (app_config.name, pkg_name))
         raise TemplateDoesNotExist(template_name)
diff --git a/django/test/__init__.py b/django/test/__init__.py
index 4b17ed18c9..c611ef6850 100644
--- a/django/test/__init__.py
+++ b/django/test/__init__.py
@@ -8,10 +8,10 @@ from django.test.testcases import (
     SimpleTestCase, LiveServerTestCase, skipIfDBFeature,
     skipUnlessDBFeature
 )
-from django.test.utils import override_settings
+from django.test.utils import modify_settings, override_settings
 
 __all__ = [
     'Client', 'RequestFactory', 'TestCase', 'TransactionTestCase',
     'SimpleTestCase', 'LiveServerTestCase', 'skipIfDBFeature',
-    'skipUnlessDBFeature', 'override_settings',
+    'skipUnlessDBFeature', 'modify_settings', 'override_settings',
 ]
diff --git a/django/test/client.py b/django/test/client.py
index 8c9a17564c..5dbc3e3568 100644
--- a/django/test/client.py
+++ b/django/test/client.py
@@ -8,6 +8,7 @@ from copy import copy
 from importlib import import_module
 from io import BytesIO
 
+from django.apps import apps
 from django.conf import settings
 from django.contrib.auth import authenticate, login, logout, get_user_model
 from django.core.handlers.base import BaseHandler
@@ -82,10 +83,9 @@ def closing_iterator_wrapper(iterable, close):
 
 class ClientHandler(BaseHandler):
     """
-    A HTTP Handler that can be used for testing purposes.
-    Uses the WSGI interface to compose requests, but returns the raw
-    HttpResponse object with the originating WSGIRequest attached to its
-    ``request_instance`` attribute.
+    A HTTP Handler that can be used for testing purposes. Uses the WSGI
+    interface to compose requests, but returns the raw HttpResponse object with
+    the originating WSGIRequest attached to its ``wsgi_request`` attribute.
     """
     def __init__(self, enforce_csrf_checks=True, *args, **kwargs):
         self.enforce_csrf_checks = enforce_csrf_checks
@@ -111,7 +111,7 @@ class ClientHandler(BaseHandler):
         response = self.get_response(request)
         # Attach the originating request to the response so that it could be
         # later retrieved.
-        response.request_instance = request
+        response.wsgi_request = request
 
         # We're emulating a WSGI server; we must call the close method
         # on completion.
@@ -389,7 +389,7 @@ class Client(RequestFactory):
         """
         Obtains the current session variables.
         """
-        if 'django.contrib.sessions' in settings.INSTALLED_APPS:
+        if apps.is_installed('django.contrib.sessions'):
             engine = import_module(settings.SESSION_ENGINE)
             cookie = self.cookies.get(settings.SESSION_COOKIE_NAME, None)
             if cookie:
@@ -550,11 +550,11 @@ class Client(RequestFactory):
         """
         user = authenticate(**credentials)
         if (user and user.is_active and
-                'django.contrib.sessions' in settings.INSTALLED_APPS):
+                apps.is_installed('django.contrib.sessions')):
             engine = import_module(settings.SESSION_ENGINE)
 
             # Create a fake request that goes through request middleware
-            request = self.request().request_instance
+            request = self.request().wsgi_request
 
             if self.session:
                 request.session = self.session
@@ -588,7 +588,7 @@ class Client(RequestFactory):
         Causes the authenticated user to be logged out.
         """
         # Create a fake request that goes through request middleware
-        request = self.request().request_instance
+        request = self.request().wsgi_request
 
         engine = import_module(settings.SESSION_ENGINE)
         UserModel = get_user_model()
diff --git a/django/test/runner.py b/django/test/runner.py
index 21e4a81604..d3c53ffc44 100644
--- a/django/test/runner.py
+++ b/django/test/runner.py
@@ -1,3 +1,4 @@
+from importlib import import_module
 import os
 from optparse import make_option
 import unittest
@@ -89,11 +90,11 @@ class DiscoverRunner(object):
                     break
                 kwargs['top_level_dir'] = top_level
 
-            if not (tests and tests.countTestCases()):
-                # if no tests found, it's probably a package; try discovery
+            if not (tests and tests.countTestCases()) and is_discoverable(label):
+                # Try discovery if path is a package or directory
                 tests = self.test_loader.discover(start_dir=label, **kwargs)
 
-                # make unittest forget the top-level dir it calculated from this
+                # Make unittest forget the top-level dir it calculated from this
                 # run, to support running tests from two different top-levels.
                 self.test_loader._top_level_dir = None
 
@@ -150,6 +151,22 @@ class DiscoverRunner(object):
         return self.suite_result(suite, result)
 
 
+def is_discoverable(label):
+    """
+    Check if a test label points to a python package or file directory.
+
+    Relative labels like "." and ".." are seen as directories.
+    """
+    try:
+        mod = import_module(label)
+    except (ImportError, TypeError):
+        pass
+    else:
+        return hasattr(mod, '__path__')
+
+    return os.path.isdir(os.path.abspath(label))
+
+
 def dependency_ordered(test_databases, dependencies):
     """
     Reorder test_databases into an order that honors the dependencies
diff --git a/django/test/signals.py b/django/test/signals.py
index 8086d50b32..d5b98081b9 100644
--- a/django/test/signals.py
+++ b/django/test/signals.py
@@ -27,6 +27,23 @@ def clear_cache_handlers(**kwargs):
         caches._caches = threading.local()
 
 
+@receiver(setting_changed)
+def update_installed_apps(**kwargs):
+    if kwargs['setting'] == 'INSTALLED_APPS':
+        # Rebuild any AppDirectoriesFinder instance.
+        from django.contrib.staticfiles.finders import get_finder
+        get_finder.cache_clear()
+        # Rebuild app_template_dirs cache.
+        from django.template.loaders import app_directories as mod
+        mod.app_template_dirs = mod.calculate_app_template_dirs()
+        # Rebuild templatetags module cache.
+        from django.template import base
+        base.templatetags_modules[:] = []
+        # Rebuild management commands cache
+        from django.core.management import get_commands
+        get_commands.cache_clear()
+
+
 @receiver(setting_changed)
 def update_connections_time_zone(**kwargs):
     if kwargs['setting'] == 'TIME_ZONE':
diff --git a/django/test/simple.py b/django/test/simple.py
index 6129ce1305..5f33044de6 100644
--- a/django/test/simple.py
+++ b/django/test/simple.py
@@ -9,7 +9,7 @@ import re
 import unittest as real_unittest
 import warnings
 
-from django.core.apps import app_cache
+from django.apps import apps
 from django.test import _doctest as doctest
 from django.test import runner
 from django.test.utils import compare_xml, strip_quotes
@@ -102,7 +102,7 @@ def get_tests(app_config):
     except ImportError:
         # Couldn't import tests.py. Was it due to a missing file, or
         # due to an import error in a tests.py that actually exists?
-        if not module_has_submodule(app_config.app_module, TEST_MODULE):
+        if not module_has_submodule(app_config.module, TEST_MODULE):
             test_module = None
         else:
             # The module exists, so there must be an import error in the test
@@ -168,7 +168,7 @@ def build_test(label):
         raise ValueError("Test label '%s' should be of the form app.TestCase "
                          "or app.TestCase.test_method" % label)
 
-    app_config = app_cache.get_app_config(parts[0])
+    app_config = apps.get_app_config(parts[0])
     models_module = app_config.models_module
     tests_module = get_tests(app_config)
 
@@ -237,10 +237,10 @@ class DjangoTestSuiteRunner(runner.DiscoverRunner):
                 if '.' in label:
                     suite.addTest(build_test(label))
                 else:
-                    app_config = app_cache.get_app_config(label)
+                    app_config = apps.get_app_config(label)
                     suite.addTest(build_suite(app_config))
         else:
-            for app_config in app_cache.get_app_configs():
+            for app_config in apps.get_app_configs():
                 suite.addTest(build_suite(app_config))
 
         if extra_tests:
diff --git a/django/test/testcases.py b/django/test/testcases.py
index 13f56fa6cc..056eb5469f 100644
--- a/django/test/testcases.py
+++ b/django/test/testcases.py
@@ -15,9 +15,9 @@ import unittest
 from unittest import skipIf         # NOQA: Imported here for backward compatibility
 from unittest.util import safe_repr
 
+from django.apps import apps
 from django.conf import settings
 from django.core import mail
-from django.core.apps import app_cache
 from django.core.exceptions import ValidationError, ImproperlyConfigured
 from django.core.handlers.wsgi import get_path_info, WSGIHandler
 from django.core.management import call_command
@@ -30,9 +30,9 @@ from django.forms.fields import CharField
 from django.http import QueryDict
 from django.test.client import Client
 from django.test.html import HTMLParseError, parse_html
-from django.test.signals import template_rendered
+from django.test.signals import setting_changed, template_rendered
 from django.test.utils import (CaptureQueriesContext, ContextList,
-    override_settings, compare_xml)
+    override_settings, modify_settings, compare_xml)
 from django.utils.encoding import force_text
 from django.utils import six
 from django.utils.six.moves.urllib.parse import urlsplit, urlunsplit, urlparse, unquote
@@ -164,7 +164,8 @@ class SimpleTestCase(unittest.TestCase):
     # The class we'll use for the test client self.client.
     # Can be overridden in derived classes.
     client_class = Client
-    _custom_settings = None
+    _overridden_settings = None
+    _modified_settings = None
 
     def __call__(self, result=None):
         """
@@ -197,9 +198,12 @@ class SimpleTestCase(unittest.TestCase):
         * If the class has a 'urls' attribute, replace ROOT_URLCONF with it.
         * Clearing the mail test outbox.
         """
-        if self._custom_settings:
-            self._overridden = override_settings(**self._custom_settings)
-            self._overridden.enable()
+        if self._overridden_settings:
+            self._overridden_context = override_settings(**self._overridden_settings)
+            self._overridden_context.enable()
+        if self._modified_settings:
+            self._modified_context = modify_settings(self._modified_settings)
+            self._modified_context.enable()
         self.client = self.client_class()
         self._urlconf_setup()
         mail.outbox = []
@@ -217,8 +221,10 @@ class SimpleTestCase(unittest.TestCase):
         * Putting back the original ROOT_URLCONF if it was changed.
         """
         self._urlconf_teardown()
-        if self._custom_settings:
-            self._overridden.disable()
+        if self._modified_settings:
+            self._modified_context.disable()
+        if self._overridden_settings:
+            self._overridden_context.disable()
 
     def _urlconf_teardown(self):
         set_urlconf(None)
@@ -233,6 +239,13 @@ class SimpleTestCase(unittest.TestCase):
         """
         return override_settings(**kwargs)
 
+    def modify_settings(self, **kwargs):
+        """
+        A context manager that temporarily applies changes a list setting and
+        reverts back to the original value when exiting the context.
+        """
+        return modify_settings(**kwargs)
+
     def assertRedirects(self, response, expected_url, status_code=302,
                         target_status_code=200, host=None, msg_prefix='',
                         fetch_redirect_response=True):
@@ -719,20 +732,29 @@ class TransactionTestCase(SimpleTestCase):
         """Performs any pre-test setup. This includes:
 
         * If the class has an 'available_apps' attribute, restricting the app
-          cache to these applications, then firing post_migrate -- it must run
-          with the correct set of applications for the test case.
+          registry to these applications, then firing post_migrate -- it must
+          run with the correct set of applications for the test case.
         * If the class has a 'fixtures' attribute, installing these fixtures.
         """
         super(TransactionTestCase, self)._pre_setup()
         if self.available_apps is not None:
-            app_cache.set_available_apps(self.available_apps)
+            apps.set_available_apps(self.available_apps)
+            setting_changed.send(sender=settings._wrapped.__class__,
+                                 setting='INSTALLED_APPS',
+                                 value=self.available_apps,
+                                 enter=True)
             for db_name in self._databases_names(include_mirrors=False):
                 flush.Command.emit_post_migrate(verbosity=0, interactive=False, database=db_name)
         try:
             self._fixture_setup()
         except Exception:
             if self.available_apps is not None:
-                app_cache.unset_available_apps()
+                apps.unset_available_apps()
+                setting_changed.send(sender=settings._wrapped.__class__,
+                                     setting='INSTALLED_APPS',
+                                     value=settings.INSTALLED_APPS,
+                                     enter=False)
+
             raise
 
     def _databases_names(self, include_mirrors=True):
@@ -786,7 +808,12 @@ class TransactionTestCase(SimpleTestCase):
             for conn in connections.all():
                 conn.close()
         finally:
-            app_cache.unset_available_apps()
+            if self.available_apps is not None:
+                apps.unset_available_apps()
+                setting_changed.send(sender=settings._wrapped.__class__,
+                                     setting='INSTALLED_APPS',
+                                     value=settings.INSTALLED_APPS,
+                                     enter=False)
 
     def _fixture_teardown(self):
         # Allow TRUNCATE ... CASCADE and don't emit the post_migrate signal
diff --git a/django/test/utils.py b/django/test/utils.py
index 550d7642b9..42cb127129 100644
--- a/django/test/utils.py
+++ b/django/test/utils.py
@@ -9,6 +9,7 @@ import warnings
 from functools import wraps
 from xml.dom.minidom import parseString, Node
 
+from django.apps import apps
 from django.conf import settings, UserSettingsHolder
 from django.core import mail
 from django.core.signals import request_started
@@ -23,8 +24,10 @@ from django.utils.translation import deactivate
 
 
 __all__ = (
-    'Approximate', 'ContextList', 'get_runner', 'override_settings',
-    'requires_tz_support', 'setup_test_environment', 'teardown_test_environment',
+    'Approximate', 'ContextList', 'get_runner',
+    'modify_settings', 'override_settings',
+    'requires_tz_support',
+    'setup_test_environment', 'teardown_test_environment',
 )
 
 RESTORE_LOADERS_ATTR = '_original_template_source_loaders'
@@ -204,11 +207,7 @@ class override_settings(object):
                 raise Exception(
                     "Only subclasses of Django SimpleTestCase can be decorated "
                     "with override_settings")
-            if test_func._custom_settings:
-                test_func._custom_settings = dict(
-                    test_func._custom_settings, **self.options)
-            else:
-                test_func._custom_settings = self.options
+            self.save_options(test_func)
             return test_func
         else:
             @wraps(test_func)
@@ -217,7 +216,23 @@ class override_settings(object):
                     return test_func(*args, **kwargs)
         return inner
 
+    def save_options(self, test_func):
+        if test_func._overridden_settings is None:
+            test_func._overridden_settings = self.options
+        else:
+            # Duplicate dict to prevent subclasses from altering their parent.
+            test_func._overridden_settings = dict(
+                test_func._overridden_settings, **self.options)
+
     def enable(self):
+        # Keep this code at the beginning to leave the settings unchanged
+        # in case it raises an exception because INSTALLED_APPS is invalid.
+        if 'INSTALLED_APPS' in self.options:
+            try:
+                apps.set_installed_apps(self.options['INSTALLED_APPS'])
+            except Exception:
+                apps.unset_installed_apps()
+                raise
         override = UserSettingsHolder(settings._wrapped)
         for key, new_value in self.options.items():
             setattr(override, key, new_value)
@@ -228,6 +243,8 @@ class override_settings(object):
                                  setting=key, value=new_value, enter=True)
 
     def disable(self):
+        if 'INSTALLED_APPS' in self.options:
+            apps.unset_installed_apps()
         settings._wrapped = self.wrapped
         del self.wrapped
         for key in self.options:
@@ -236,6 +253,53 @@ class override_settings(object):
                                  setting=key, value=new_value, enter=False)
 
 
+class modify_settings(override_settings):
+    """
+    Like override_settings, but makes it possible to append, prepend or remove
+    items instead of redefining the entire list.
+    """
+    def __init__(self, *args, **kwargs):
+        if args:
+            # Hack used when instaciating from SimpleTestCase._pre_setup.
+            assert not kwargs
+            self.operations = args[0]
+        else:
+            assert not args
+            self.operations = list(kwargs.items())
+
+    def save_options(self, test_func):
+        if test_func._modified_settings is None:
+            test_func._modified_settings = self.operations
+        else:
+            # Duplicate list to prevent subclasses from altering their parent.
+            test_func._modified_settings = list(
+                test_func._modified_settings) + self.operations
+
+    def enable(self):
+        self.options = {}
+        for name, operations in self.operations:
+            try:
+                # When called from SimpleTestCase._pre_setup, values may be
+                # overridden several times; cumulate changes.
+                value = self.options[name]
+            except KeyError:
+                value = list(getattr(settings, name, []))
+            for action, items in operations.items():
+                # items my be a single value or an iterable.
+                if isinstance(items, six.string_types):
+                    items = [items]
+                if action == 'append':
+                    value = value + [item for item in items if item not in value]
+                elif action == 'prepend':
+                    value = [item for item in items if item not in value] + value
+                elif action == 'remove':
+                    value = [item for item in value if item not in items]
+                else:
+                    raise ValueError("Unsupported action: %s" % action)
+            self.options[name] = value
+        super(modify_settings, self).enable()
+
+
 def compare_xml(want, got):
     """Tries to do a 'xml-comparison' of want and got.  Plain string
     comparison doesn't always work because, for example, attribute
diff --git a/django/utils/autoreload.py b/django/utils/autoreload.py
index 1913317822..94c74e582a 100644
--- a/django/utils/autoreload.py
+++ b/django/utils/autoreload.py
@@ -36,10 +36,9 @@ import sys
 import time
 import traceback
 
+from django.apps import apps
 from django.conf import settings
 from django.core.signals import request_finished
-from django.utils._os import upath
-from importlib import import_module
 try:
     from django.utils.six.moves import _thread as thread
 except ImportError:
@@ -91,10 +90,8 @@ def gen_filenames():
         basedirs = [os.path.join(os.path.dirname(os.path.dirname(__file__)),
                                  'conf', 'locale'),
                     'locale']
-        for appname in reversed(settings.INSTALLED_APPS):
-            app = import_module(appname)
-            basedirs.append(os.path.join(os.path.dirname(upath(app.__file__)),
-                                         'locale'))
+        for app_config in reversed(list(apps.get_app_configs())):
+            basedirs.append(os.path.join(app_config.path, 'locale'))
         basedirs.extend(settings.LOCALE_PATHS)
         basedirs = [os.path.abspath(basedir) for basedir in basedirs
                     if os.path.isdir(basedir)]
diff --git a/django/utils/cache.py b/django/utils/cache.py
index d89408a7a2..365733fedf 100644
--- a/django/utils/cache.py
+++ b/django/utils/cache.py
@@ -191,25 +191,25 @@ def _generate_cache_key(request, method, headerlist, key_prefix):
         value = request.META.get(header, None)
         if value is not None:
             ctx.update(force_bytes(value))
-    path = hashlib.md5(force_bytes(iri_to_uri(request.get_full_path())))
+    url = hashlib.md5(force_bytes(iri_to_uri(request.build_absolute_uri())))
     cache_key = 'views.decorators.cache.cache_page.%s.%s.%s.%s' % (
-        key_prefix, method, path.hexdigest(), ctx.hexdigest())
+        key_prefix, method, url.hexdigest(), ctx.hexdigest())
     return _i18n_cache_key_suffix(request, cache_key)
 
 
 def _generate_cache_header_key(key_prefix, request):
     """Returns a cache key for the header cache."""
-    path = hashlib.md5(force_bytes(iri_to_uri(request.get_full_path())))
+    url = hashlib.md5(force_bytes(iri_to_uri(request.build_absolute_uri())))
     cache_key = 'views.decorators.cache.cache_header.%s.%s' % (
-        key_prefix, path.hexdigest())
+        key_prefix, url.hexdigest())
     return _i18n_cache_key_suffix(request, cache_key)
 
 
 def get_cache_key(request, key_prefix=None, method='GET', cache=None):
     """
-    Returns a cache key based on the request path and query. It can be used
+    Returns a cache key based on the request URL and query. It can be used
     in the request phase because it pulls the list of headers to take into
-    account from the global path registry and uses those to build a cache key
+    account from the global URL registry and uses those to build a cache key
     to check against.
 
     If there is no headerlist stored, the page needs to be rebuilt, so this
@@ -229,9 +229,9 @@ def get_cache_key(request, key_prefix=None, method='GET', cache=None):
 
 def learn_cache_key(request, response, cache_timeout=None, key_prefix=None, cache=None):
     """
-    Learns what headers to take into account for some request path from the
-    response object. It stores those headers in a global path registry so that
-    later access to that path will know what headers to take into account
+    Learns what headers to take into account for some request URL from the
+    response object. It stores those headers in a global URL registry so that
+    later access to that URL will know what headers to take into account
     without building the response object itself. The headers are named in the
     Vary header of the response, but we want to prevent response generation.
 
@@ -264,7 +264,7 @@ def learn_cache_key(request, response, cache_timeout=None, key_prefix=None, cach
         return _generate_cache_key(request, request.method, headerlist, key_prefix)
     else:
         # if there is no Vary header, we still need a cache key
-        # for the request.get_full_path()
+        # for the request.build_absolute_uri()
         cache.set(cache_key, [], cache_timeout)
         return _generate_cache_key(request, request.method, [], key_prefix)
 
diff --git a/django/utils/log.py b/django/utils/log.py
index 488632882c..cf778b619b 100644
--- a/django/utils/log.py
+++ b/django/utils/log.py
@@ -1,8 +1,11 @@
 import logging
+import sys
+import warnings
 
 from django.conf import settings
 from django.core import mail
 from django.core.mail import get_connection
+from django.utils.module_loading import import_by_path
 from django.views.debug import ExceptionReporter, get_exception_reporter_filter
 
 # Imports kept for backwards-compatibility in Django 1.7.
@@ -61,6 +64,24 @@ DEFAULT_LOGGING = {
 }
 
 
+def configure_logging(logging_config, logging_settings):
+    if not sys.warnoptions:
+        # Route warnings through python logging
+        logging.captureWarnings(True)
+        # Allow DeprecationWarnings through the warnings filters
+        warnings.simplefilter("default", DeprecationWarning)
+
+    if logging_config:
+         # First find the logging configuration function ...
+        logging_config_func = import_by_path(logging_config)
+
+        logging_config_func(DEFAULT_LOGGING)
+
+        # ... then invoke it with the logging settings
+        if logging_settings:
+            logging_config_func(logging_settings)
+
+
 class AdminEmailHandler(logging.Handler):
     """An exception log handler that emails log entries to site admins.
 
diff --git a/django/utils/module_loading.py b/django/utils/module_loading.py
index 8868a2d3ab..bd012cd55b 100644
--- a/django/utils/module_loading.py
+++ b/django/utils/module_loading.py
@@ -1,5 +1,6 @@
 from __future__ import absolute_import  # Avoid importing `importlib` from this package.
 
+from contextlib import contextmanager
 import copy
 import imp
 from importlib import import_module
@@ -35,6 +36,18 @@ def import_by_path(dotted_path, error_prefix=''):
     return attr
 
 
+@contextmanager
+def import_lock():
+    """
+    Context manager that aquires the import lock.
+    """
+    imp.acquire_lock()
+    try:
+        yield
+    finally:
+        imp.release_lock()
+
+
 def autodiscover_modules(*args, **kwargs):
     """
     Auto-discover INSTALLED_APPS modules and fail silently when
@@ -45,18 +58,17 @@ def autodiscover_modules(*args, **kwargs):
     registry. This register_to object must have a _registry instance variable
     to access it.
     """
-    from django.conf import settings
+    from django.apps import apps
 
     register_to = kwargs.get('register_to')
-    for app in settings.INSTALLED_APPS:
-        mod = import_module(app)
+    for app_config in apps.get_app_configs():
         # Attempt to import the app's module.
         try:
             if register_to:
                 before_import_registry = copy.copy(register_to._registry)
 
             for module_to_search in args:
-                import_module('%s.%s' % (app, module_to_search))
+                import_module('%s.%s' % (app_config.name, module_to_search))
         except:
             # Reset the model registry to the state before the last import as
             # this import will have to reoccur on the next request and this
@@ -68,7 +80,7 @@ def autodiscover_modules(*args, **kwargs):
             # Decide whether to bubble up this error. If the app just
             # doesn't have an admin module, we can ignore the error
             # attempting to import it, otherwise we want it to bubble up.
-            if module_has_submodule(mod, module_to_search):
+            if module_has_submodule(app_config.module, module_to_search):
                 raise
 
 
diff --git a/django/utils/text.py b/django/utils/text.py
index d172dc91f8..f52050cccc 100644
--- a/django/utils/text.py
+++ b/django/utils/text.py
@@ -17,6 +17,7 @@ if six.PY2:
     # people rely on it being here.
     from django.utils.encoding import force_unicode  # NOQA
 
+
 # Capitalizes the first letter of a string.
 capfirst = lambda x: x and force_text(x)[0].upper() + force_text(x)[1:]
 capfirst = allow_lazy(capfirst, six.text_type)
@@ -25,6 +26,7 @@ capfirst = allow_lazy(capfirst, six.text_type)
 re_words = re.compile(r'<.*?>|((?:\w[-\w]*|&.*?;)+)', re.U | re.S)
 re_tag = re.compile(r'<(/)?([^ ]+?)(?:(\s*/)| .*?)?>', re.S)
 re_newlines = re.compile(r'\r\n|\r')  # Used in normalize_newlines
+re_camel_case = re.compile(r'(((?<=[a-z])[A-Z])|([A-Z](?![A-Z]|$)))')
 
 
 def wrap(text, width):
@@ -256,15 +258,6 @@ def normalize_newlines(text):
 normalize_newlines = allow_lazy(normalize_newlines, six.text_type)
 
 
-def recapitalize(text):
-    """Recapitalizes text, placing caps after end-of-sentence punctuation."""
-    text = force_text(text).lower()
-    capsRE = re.compile(r'(?:^|(?<=[\.\?\!] ))([a-z])')
-    text = capsRE.sub(lambda x: x.group(1).upper(), text)
-    return text
-recapitalize = allow_lazy(recapitalize)
-
-
 def phone2numeric(phone):
     """Converts a phone number with letters into its numeric equivalent."""
     char2number = {'a': '2', 'b': '2', 'c': '2', 'd': '3', 'e': '3', 'f': '3',
@@ -429,3 +422,11 @@ def slugify(value):
     value = re.sub('[^\w\s-]', '', value).strip().lower()
     return mark_safe(re.sub('[-\s]+', '-', value))
 slugify = allow_lazy(slugify, six.text_type)
+
+
+def camel_case_to_spaces(value):
+    """
+    Splits CamelCase and converts to lower case. Also strips leading and
+    trailing whitespace.
+    """
+    return re_camel_case.sub(r' \1', value).strip().lower()
diff --git a/django/utils/translation/trans_real.py b/django/utils/translation/trans_real.py
index e547800b92..29c133006e 100644
--- a/django/utils/translation/trans_real.py
+++ b/django/utils/translation/trans_real.py
@@ -7,10 +7,10 @@ import os
 import re
 import sys
 import gettext as gettext_module
-from importlib import import_module
 from threading import local
 import warnings
 
+from django.apps import apps
 from django.dispatch import receiver
 from django.test.signals import setting_changed
 from django.utils.encoding import force_str, force_text
@@ -179,10 +179,8 @@ def translation(language):
                     res.merge(t)
             return res
 
-        for appname in reversed(settings.INSTALLED_APPS):
-            app = import_module(appname)
-            apppath = os.path.join(os.path.dirname(upath(app.__file__)), 'locale')
-
+        for app_config in reversed(list(apps.get_app_configs())):
+            apppath = os.path.join(app_config.path, 'locale')
             if os.path.isdir(apppath):
                 res = _merge(apppath)
 
diff --git a/django/views/debug.py b/django/views/debug.py
index 8f7f9dc00a..4f2097600f 100644
--- a/django/views/debug.py
+++ b/django/views/debug.py
@@ -1149,7 +1149,7 @@ DEFAULT_URLCONF_TEMPLATE = """
 <div id="instructions">
   <p>
     Of course, you haven't actually done any work yet.
-    Next, start your first app by running <code>python manage.py startapp [appname]</code>.
+    Next, start your first app by running <code>python manage.py startapp [app_label]</code>.
   </p>
 </div>
 
diff --git a/django/views/generic/dates.py b/django/views/generic/dates.py
index d221c2c087..2011c6f4be 100644
--- a/django/views/generic/dates.py
+++ b/django/views/generic/dates.py
@@ -482,7 +482,7 @@ class YearArchiveView(MultipleObjectTemplateResponseMixin, BaseYearArchiveView):
 
 class BaseMonthArchiveView(YearMixin, MonthMixin, BaseDateListView):
     """
-    List of objects published in a given year.
+    List of objects published in a given month.
     """
     date_list_period = 'day'
 
@@ -516,7 +516,7 @@ class BaseMonthArchiveView(YearMixin, MonthMixin, BaseDateListView):
 
 class MonthArchiveView(MultipleObjectTemplateResponseMixin, BaseMonthArchiveView):
     """
-    List of objects published in a given year.
+    List of objects published in a given month.
     """
     template_name_suffix = '_archive_month'
 
diff --git a/django/views/i18n.py b/django/views/i18n.py
index 751905efaf..7182f4f3cd 100644
--- a/django/views/i18n.py
+++ b/django/views/i18n.py
@@ -4,6 +4,7 @@ import os
 import gettext as gettext_module
 
 from django import http
+from django.apps import apps
 from django.conf import settings
 from django.template import Context, Template
 from django.utils.translation import check_for_language, to_locale, get_language
@@ -187,7 +188,10 @@ def render_javascript_catalog(catalog=None, plural=None):
 
 def get_javascript_catalog(locale, domain, packages):
     default_locale = to_locale(settings.LANGUAGE_CODE)
-    packages = [p for p in packages if p == 'django.conf' or p in settings.INSTALLED_APPS]
+    app_configs = apps.get_app_configs()
+    allowable_packages = set(app_config.name for app_config in app_configs)
+    allowable_packages.add('django.conf')
+    packages = [p for p in packages if p in allowable_packages]
     t = {}
     paths = []
     en_selected = locale.startswith('en')
diff --git a/docs/conf.py b/docs/conf.py
index 49e70fab84..6bc293d02a 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -110,7 +110,7 @@ pygments_style = 'trac'
 # Links to Python's docs should reference the most recent version of the 2.x
 # branch, which is located at this URL.
 intersphinx_mapping = {
-    'python': ('http://docs.python.org/2.7', None),
+    'python': ('http://docs.python.org/', None),
     'sphinx': ('http://sphinx-doc.org/', None),
     'six': ('http://pythonhosted.org/six/', None),
     'simplejson': ('http://simplejson.readthedocs.org/en/latest/', None),
diff --git a/docs/faq/general.txt b/docs/faq/general.txt
index 801cb334ca..6bee5a1fdd 100644
--- a/docs/faq/general.txt
+++ b/docs/faq/general.txt
@@ -47,7 +47,7 @@ Is Django stable?
 -----------------
 
 Yes, it's quite stable. World Online has been using Django for many years. Sites built on
-Django have weathered traffic spikes of over one million hits an hour.
+Django have weathered traffic spikes of over 50 thousand hits per second.
 
 Does Django scale?
 ------------------
diff --git a/docs/howto/custom-management-commands.txt b/docs/howto/custom-management-commands.txt
index 2325e32ac2..b5d461e2ce 100644
--- a/docs/howto/custom-management-commands.txt
+++ b/docs/howto/custom-management-commands.txt
@@ -199,8 +199,8 @@ All attributes can be set in your derived class and can be used in
 
   A string listing the arguments accepted by the command,
   suitable for use in help messages; e.g., a command which takes
-  a list of application names might set this to '<appname
-  appname ...>'.
+  a list of application names might set this to '<app_label
+  app_label ...>'.
 
 .. attribute:: BaseCommand.can_import_settings
 
@@ -313,17 +313,34 @@ BaseCommand subclasses
 
 .. class:: AppCommand
 
-A management command which takes one or more installed application
-names as arguments, and does something with each of them.
+A management command which takes one or more installed application labels as
+arguments, and does something with each of them.
 
-Rather than implementing :meth:`~BaseCommand.handle`, subclasses must implement
-:meth:`~AppCommand.handle_app`, which will be called once for each application.
+Rather than implementing :meth:`~BaseCommand.handle`, subclasses must
+implement :meth:`~AppCommand.handle_app_config`, which will be called once for
+each application.
 
-.. method:: AppCommand.handle_app(app, **options)
+.. method:: AppCommand.handle_app_config(app_config, **options)
 
-    Perform the command's actions for ``app``, which will be the
-    Python module corresponding to an application name given on
-    the command line.
+    Perform the command's actions for ``app_config``, which will be an
+    :class:`~django.apps.AppConfig` instance corresponding to an application
+    label given on the command line.
+
+.. versionchanged:: 1.7
+
+    Previously, :class:`AppCommand` subclasses had to implement
+    ``handle_app(app, **options)`` where ``app`` was a models module. The new
+    API makes it possible to handle applications without a models module. The
+    fastest way to migrate is as follows::
+
+        def handle_app_config(app_config, **options):
+            if app_config.models_module is None:
+                return                                  # Or raise an exception.
+            app = app_config.models_module
+            # Copy the implementation of handle_app(app_config, **options) here.
+
+    However, you may be able to simplify the implementation by using directly
+    the attributes of ``app_config``.
 
 .. class:: LabelCommand
 
diff --git a/docs/howto/custom-model-fields.txt b/docs/howto/custom-model-fields.txt
index 6054a83f10..b7bcefad53 100644
--- a/docs/howto/custom-model-fields.txt
+++ b/docs/howto/custom-model-fields.txt
@@ -458,11 +458,14 @@ For example::
             else:
                 return 'timestamp'
 
-The :meth:`.db_type` method is only called by Django when the framework
+The :meth:`.db_type` method is called by Django when the framework
 constructs the ``CREATE TABLE`` statements for your application -- that is,
-when you first create your tables. It's not called at any other time, so it can
-afford to execute slightly complex code, such as the
-``connection.settings_dict`` check in the above example.
+when you first create your tables. It is also called when constructing a 
+``WHERE`` clause that includes the model field -- that is, when you retrieve data
+using QuerySet methods like ``get()``, ``filter()``, and ``exclude()`` and have
+the model field as an argument. It's not called at any other time, so it can afford to
+execute slightly complex code, such as the ``connection.settings_dict`` check in
+the above example.
 
 Some database column types accept parameters, such as ``CHAR(25)``, where the
 parameter ``25`` represents the maximum column length. In cases like these,
diff --git a/docs/howto/custom-template-tags.txt b/docs/howto/custom-template-tags.txt
index 1f6d2d5c75..b5cbf571b7 100644
--- a/docs/howto/custom-template-tags.txt
+++ b/docs/howto/custom-template-tags.txt
@@ -339,6 +339,34 @@ Template filter code falls into one of two situations:
    handle the auto-escaping issues and return a safe string, the
    ``is_safe`` flag won't change anything either way.
 
+.. warning:: Avoiding XSS vulnerabilities when reusing built-in filters
+
+    Be careful when reusing Django's built-in filters. You'll need to pass
+    ``autoescape=True`` to the filter in order to get the proper autoescaping
+    behavior and avoid a cross-site script vulnerability.
+
+    For example, if you wanted to write a custom filter called
+    ``urlize_and_linebreaks`` that combined the :tfilter:`urlize` and
+    :tfilter:`linebreaksbr` filters, the filter would look like::
+
+        from django.template.defaultfilters import linebreaksbr, urlize
+
+        @register.filter
+        def urlize_and_linebreaks(text):
+            return linebreaksbr(urlize(text, autoescape=True), autoescape=True)
+
+    Then:
+
+    .. code-block:: html+django
+
+        {{ comment|urlize_and_linebreaks }}
+
+    would be equivalent to:
+
+    .. code-block:: html+django
+
+        {{ comment|urlize|linebreaksbr }}
+
 .. _filters-timezones:
 
 Filters and time zones
diff --git a/docs/howto/deployment/wsgi/apache-auth.txt b/docs/howto/deployment/wsgi/apache-auth.txt
index 80219ffdf4..98bafad530 100644
--- a/docs/howto/deployment/wsgi/apache-auth.txt
+++ b/docs/howto/deployment/wsgi/apache-auth.txt
@@ -38,6 +38,7 @@ only authenticated users to be able to view:
 .. code-block:: apache
 
     WSGIScriptAlias / /path/to/mysite.com/mysite/wsgi.py
+    WSGIPythonPath /path/to/mysite.com
 
     WSGIProcessGroup %{GLOBAL}
     WSGIApplicationGroup django
@@ -76,7 +77,6 @@ function:
 .. code-block:: python
 
     import os
-    import sys
 
     os.environ['DJANGO_SETTINGS_MODULE'] = 'mysite.settings'
 
diff --git a/docs/howto/initial-data.txt b/docs/howto/initial-data.txt
index 61885a0803..d003db6497 100644
--- a/docs/howto/initial-data.txt
+++ b/docs/howto/initial-data.txt
@@ -150,13 +150,13 @@ Database-backend-specific SQL data
 There's also a hook for backend-specific SQL data. For example, you
 can have separate initial-data files for PostgreSQL and SQLite. For
 each app, Django looks for a file called
-``<appname>/sql/<modelname>.<backend>.sql``, where ``<appname>`` is
+``<app_label>/sql/<modelname>.<backend>.sql``, where ``<app_label>`` is
 your app directory, ``<modelname>`` is the model's name in lowercase
 and ``<backend>`` is the last part of the module name provided for the
 :setting:`ENGINE <DATABASE-ENGINE>` in your settings file (e.g., if you have
 defined a database with an :setting:`ENGINE <DATABASE-ENGINE>` value of
 ``django.db.backends.sqlite3``, Django will look for
-``<appname>/sql/<modelname>.sqlite3.sql``).
+``<app_label>/sql/<modelname>.sqlite3.sql``).
 
 Backend-specific SQL data is executed before non-backend-specific SQL
 data. For example, if your app contains the files ``sql/person.sql``
diff --git a/docs/howto/upgrade-version.txt b/docs/howto/upgrade-version.txt
index 34cb3e65d6..82666d677b 100644
--- a/docs/howto/upgrade-version.txt
+++ b/docs/howto/upgrade-version.txt
@@ -54,7 +54,7 @@ The most convenient way is to use pip_ with the ``--upgrade`` or ``-U`` flag:
 
 .. code-block:: bash
 
-   pip install -U Django
+   $ pip install -U Django
 
 pip_ also automatically uninstalls the previous version of Django.
 
diff --git a/docs/index.txt b/docs/index.txt
index bd3baf8a9c..f37a597276 100644
--- a/docs/index.txt
+++ b/docs/index.txt
@@ -179,6 +179,9 @@ testing of Django applications:
   :doc:`Overview <topics/settings>` |
   :doc:`Full list of settings <ref/settings>`
 
+* **Applications:**
+  :doc:`Overview <ref/applications>`
+
 * **Exceptions:**
   :doc:`Overview <ref/exceptions>`
 
diff --git a/docs/internals/committers.txt b/docs/internals/committers.txt
index 0da26a31eb..58f0de4a84 100644
--- a/docs/internals/committers.txt
+++ b/docs/internals/committers.txt
@@ -394,10 +394,10 @@ Tim Graham
     a continuous integration server, and likes proving that Django is a good
     choice for enterprise software.
 
-    He works in a `management consulting company`_ in Paris, France.
+    He's the CTO of Oscaro_, an e-commerce company based in Paris, France.
 
     .. _Aymeric Augustin: https://myks.org/
-    .. _management consulting company: http://www.polyconseil.fr/
+    .. _Oscaro: http://www.oscaro.com/
 
 `Claude Paroz`_
     Claude is a former teacher who fell in love with free software at the
diff --git a/docs/internals/contributing/writing-code/unit-tests.txt b/docs/internals/contributing/writing-code/unit-tests.txt
index 2bbd9dcf0e..36f767614a 100644
--- a/docs/internals/contributing/writing-code/unit-tests.txt
+++ b/docs/internals/contributing/writing-code/unit-tests.txt
@@ -13,8 +13,8 @@ The tests cover:
 We appreciate any and all contributions to the test suite!
 
 The Django tests all use the testing infrastructure that ships with Django for
-testing applications. See :doc:`Testing Django applications
-</topics/testing/overview>` for an explanation of how to write new tests.
+testing applications. See :doc:`/topics/testing/overview` for an explanation of
+how to write new tests.
 
 .. _running-unit-tests:
 
@@ -30,15 +30,17 @@ sample settings module that uses the SQLite database. To run the tests:
 
 .. code-block:: bash
 
-    git clone git@github.com:django/django.git django-repo
-    cd django-repo/tests
-    PYTHONPATH=..:$PYTHONPATH ./runtests.py
+   $ git clone git@github.com:django/django.git django-repo
+   $ cd django-repo/tests
+   $ PYTHONPATH=..:$PYTHONPATH ./runtests.py
 
 .. versionchanged:: 1.7
 
-Older versions of Django required specifying a settings file::
+Older versions of Django required specifying a settings file:
 
-    PYTHONPATH=..:$PYTHONPATH python ./runtests.py --settings=test_sqlite
+.. code-block:: bash
+
+   $ PYTHONPATH=..:$PYTHONPATH python ./runtests.py --settings=test_sqlite
 
 ``runtests.py`` now uses ``test_sqlite`` by default if settings aren't provided
 through either ``--settings`` or :envvar:`DJANGO_SETTINGS_MODULE`.
@@ -111,7 +113,7 @@ internationalization, type:
 
 .. code-block:: bash
 
-    ./runtests.py --settings=path.to.settings generic_relations i18n
+   $ ./runtests.py --settings=path.to.settings generic_relations i18n
 
 How do you find out the names of individual tests? Look in ``tests/`` — each
 directory name there is the name of a test. Contrib app names are also valid
@@ -123,13 +125,13 @@ of the ``i18n`` module, type:
 
 .. code-block:: bash
 
-    ./runtests.py --settings=path.to.settings i18n.tests.TranslationTests
+   $ ./runtests.py --settings=path.to.settings i18n.tests.TranslationTests
 
 Going beyond that, you can specify an individual test method like this:
 
 .. code-block:: bash
 
-    ./runtests.py --settings=path.to.settings i18n.tests.TranslationTests.test_lazy_objects
+   $ ./runtests.py --settings=path.to.settings i18n.tests.TranslationTests.test_lazy_objects
 
 Running the Selenium tests
 ~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -141,7 +143,7 @@ the tests with the ``--selenium`` option:
 
 .. code-block:: bash
 
-    ./runtests.py --settings=test_sqlite --selenium admin_inlines
+   $ ./runtests.py --settings=test_sqlite --selenium admin_inlines
 
 
 .. _running-unit-tests-dependencies:
@@ -165,9 +167,11 @@ dependencies:
 
 You can find these dependencies in `pip requirements files`_ inside the
 ``tests/requirements`` directory of the Django source tree and install them
-like so::
+like so:
 
-    pip install -r tests/requirements/py2.txt  # Python 3: py3.txt
+.. code-block:: bash
+
+   $ pip install -r tests/requirements/py2.txt  # Python 3: py3.txt
 
 You can also install the database adapter(s) of your choice using
 ``oracle.txt``, ``mysql.txt``, or ``postgres.txt``.
@@ -200,13 +204,17 @@ Contributors are encouraged to run coverage on the test suite to identify areas
 that need additional tests. The coverage tool installation and use is described
 in :ref:`testing code coverage<topics-testing-code-coverage>`.
 
-To run coverage on the Django test suite using the standard test settings::
+To run coverage on the Django test suite using the standard test settings:
 
-    coverage run ./runtests.py --settings=test_sqlite
+.. code-block:: bash
 
-After running coverage, generate the html report by running::
+   $ coverage run ./runtests.py --settings=test_sqlite
 
-    coverage html
+After running coverage, generate the html report by running:
+
+.. code-block:: bash
+
+   $ coverage html
 
 When running coverage for the Django tests, the included ``.coveragerc``
 settings file  defines ``coverage_html`` as the output directory for the report
@@ -222,10 +230,11 @@ Tests for contrib apps go in their respective directories under
 ``django/contrib``, in a ``tests.py`` file. You can split the tests over
 multiple modules by using a ``tests`` directory in the normal Python way.
 
-For the tests to be found, a ``models.py`` file must exist, even if it's empty.
 If you have URLs that need to be mapped, put them in ``tests/urls.py``.
 
 To run tests for just one contrib app (e.g. ``auth``), use the same
-method as above::
+method as above:
 
-    ./runtests.py --settings=settings django.contrib.auth
+.. code-block:: bash
+
+   $ ./runtests.py --settings=settings django.contrib.auth
diff --git a/docs/internals/deprecation.txt b/docs/internals/deprecation.txt
index ef2561a05d..514561e1ff 100644
--- a/docs/internals/deprecation.txt
+++ b/docs/internals/deprecation.txt
@@ -165,20 +165,25 @@ these changes.
 * The ``syncdb`` command will be removed.
 
 * ``django.db.models.signals.pre_syncdb`` and
-  ``django.db.models.signals.post_syncdb`` will be removed, and
-  ``django.db.models.signals.pre_migrate`` and
-  ``django.db.models.signals.post_migrate`` will lose their
-  ``create_models`` and ``created_models`` arguments.
+  ``django.db.models.signals.post_syncdb`` will be removed.
 
 * ``allow_syncdb`` on database routers will no longer automatically become
   ``allow_migrate``.
 
+* All models will need to be defined inside an installed application or
+  declare an explicit :attr:`~django.db.models.Options.app_label`.
+  Furthermore, it won't be possible to import them before their application
+  is loaded. In particular, it won't be possible to import models inside
+  the root package of their application.
+
 * If models are organized in a package, Django will no longer look for
   :ref:`initial SQL data<initial-sql>` in ``myapp/models/sql/``. Move your
   custom SQL files to ``myapp/sql/``.
 
 * The model and form ``IPAddressField`` will be removed.
 
+* ``AppCommand.handle_app()`` will no longer be supported.
+
 * FastCGI support via the ``runfcgi`` management command will be
   removed. Please deploy your project using WSGI.
 
@@ -222,9 +227,7 @@ these changes.
 * ``django.core.cache.get_cache`` will be removed. Add suitable entries
   to :setting:`CACHES` and use :data:`django.core.cache.caches` instead.
 
-* ``django.db.models.loading`` will be removed. Use the new application
-  loading APIs instead. Several undocumented methods of the ``AppCache`` class
-  will also be removed.
+* ``django.db.models.loading`` will be removed.
 
 * Passing callable arguments to querysets will no longer be possible.
 
diff --git a/docs/intro/contributing.txt b/docs/intro/contributing.txt
index 8f41b71056..9c9482d20a 100644
--- a/docs/intro/contributing.txt
+++ b/docs/intro/contributing.txt
@@ -20,8 +20,8 @@ For this tutorial, we expect that you have at least a basic understanding of
 how Django works. This means you should be comfortable going through the
 existing tutorials on :doc:`writing your first Django app</intro/tutorial01>`.
 In addition, you should have a good understanding of Python itself. But if you
-don't, "Dive Into Python" (for `Python 2`__, for `Python 3`__) is a fantastic
-(and free) online book for beginning Python programmers.
+don't, `Dive Into Python`__ is a fantastic (and free) online book for
+beginning Python programmers.
 
 Those of you who are unfamiliar with version control systems and Trac will find
 that this tutorial and its links include just enough information to get started.
@@ -37,7 +37,6 @@ so that it can be of use to the widest audience.
     to |django-developers| or drop by `#django-dev on irc.freenode.net`__ to
     chat with other Django users who might be able to help.
 
-__ http://diveintopython.net/toc/index.html
 __ http://diveintopython3.net/
 __ irc://irc.freenode.net/django-dev
 
@@ -238,7 +237,7 @@ widget. Before we make those changes though, we're going to write a couple
 tests to verify that our modification functions correctly and continues to
 function correctly in the future.
 
-Navigate to Django's ``tests/admin_widgets/`` folder and
+Navigate to Django's ``tests/regressiontests/admin_widgets/`` folder and
 open the ``tests.py`` file. Add the following code on line 269 right before the
 ``AdminFileWidgetTest`` class::
 
@@ -282,7 +281,7 @@ correctly in a couple different situations.
     computer programming, so there's lots of information out there:
 
     * A good first look at writing tests for Django can be found in the
-      documentation on :doc:`Testing Django applications </topics/testing/overview>`.
+      documentation on :doc:`/topics/testing/overview`.
     * Dive Into Python (a free online book for beginning Python developers)
       includes a great `introduction to Unit Testing`__.
     * After reading those, if you want something a little meatier to sink
@@ -468,10 +467,11 @@ This patch file contains all your changes and should look this:
 
      Relationship fields
      ===================
-    diff --git a/tests/admin_widgets/tests.py b/tests/admin_widgets/tests.py
+    diff --git a/tests/regressiontests/admin_widgets/tests.py b/tests/regressiontests/admin_widgets/tests.py
     index 4b11543..94acc6d 100644
-    --- a/tests/admin_widgets/tests.py
-    +++ b/tests/admin_widgets/tests.py
+    --- a/tests/regressiontests/admin_widgets/tests.py
+    +++ b/tests/regressiontests/admin_widgets/tests.py
+
     @@ -265,6 +265,35 @@ class AdminSplitDateTimeWidgetTest(DjangoTestCase):
                          '<p class="datetime">Datum: <input value="01.12.2007" type="text" class="vDateField" name="test_0" size="10" /><br />Zeit: <input value="09:30:00" type="text" class="vTimeField" name="test_1" size="8" /></p>',
                      )
diff --git a/docs/intro/index.txt b/docs/intro/index.txt
index a7872017b9..18664ef053 100644
--- a/docs/intro/index.txt
+++ b/docs/intro/index.txt
@@ -29,14 +29,10 @@ place: read this material to quickly get up and running.
     `list of Python resources for non-programmers`_
 
     If you already know a few other languages and want to get up to speed with
-    Python quickly, we recommend "Dive Into Python" (for `Python 2`_, for
-    `Python 3`_, also available in a
-    `dead-tree version`_). If that's not quite your style, there are quite
-    a few other `books about Python`_.
+    Python quickly, we recommend `Dive Into Python`_. If that's not quite your
+    style, there are many other `books about Python`_.
 
     .. _python: http://python.org/
     .. _list of Python resources for non-programmers: https://wiki.python.org/moin/BeginnersGuide/NonProgrammers
-    .. _Python 2: http://diveintopython.net/
-    .. _Python 3: http://diveintopython3.net/
-    .. _dead-tree version: http://www.amazon.com/exec/obidos/ASIN/1590593561/ref=nosim/jacobian20
+    .. _Dive Into Python: http://diveintopython3.net/
     .. _books about Python: https://wiki.python.org/moin/PythonBooks
diff --git a/docs/intro/install.txt b/docs/intro/install.txt
index 3ef59dcafb..1d58b5dc3f 100644
--- a/docs/intro/install.txt
+++ b/docs/intro/install.txt
@@ -15,8 +15,8 @@ SQLite_ so you won't need to set up a database just yet.
 
 .. _sqlite: http://sqlite.org/
 
-Get Python at http://www.python.org. If you're running Linux or Mac OS X, you
-probably already have it installed.
+Get the latest version of Python at http://www.python.org/download/ or with
+your operating system's package manager.
 
 .. admonition:: Django on Jython
 
@@ -28,8 +28,8 @@ probably already have it installed.
 You can verify that Python is installed by typing ``python`` from your shell;
 you should see something like::
 
-    Python 2.7.3 (default, Jan  2 2013, 13:56:14)
-    [GCC 4.7.2] on linux2
+    Python 3.3.3 (default, Nov 26 2013, 13:33:18)
+    [GCC 4.8.2] on linux
     Type "help", "copyright", "credits" or "license" for more information.
     >>>
 
diff --git a/docs/intro/overview.txt b/docs/intro/overview.txt
index 2a1b979a20..6ec3baf0ec 100644
--- a/docs/intro/overview.txt
+++ b/docs/intro/overview.txt
@@ -22,7 +22,7 @@ code.
 .. _object-relational mapper: http://en.wikipedia.org/wiki/Object-relational_mapping
 
 The :doc:`data-model syntax </topics/db/models>` offers many rich ways of
-representing your models -- so far, it's been solving two years' worth of
+representing your models -- so far, it's been solving many years' worth of
 database-schema problems. Here's a quick example, which might be saved in
 the file ``mysite/news/models.py``::
 
@@ -31,8 +31,7 @@ the file ``mysite/news/models.py``::
     class Reporter(models.Model):
         full_name = models.CharField(max_length=70)
 
-        # On Python 3: def __str__(self):
-        def __unicode__(self):
+        def __str__(self):              # __unicode__ on Python 2
             return self.full_name
 
     class Article(models.Model):
@@ -41,8 +40,7 @@ the file ``mysite/news/models.py``::
         content = models.TextField()
         reporter = models.ForeignKey(Reporter)
 
-        # On Python 3: def __str__(self):
-        def __unicode__(self):
+        def __str__(self):              # __unicode__ on Python 2
             return self.headline
 
 Install it
@@ -127,7 +125,7 @@ necessary:
     # The API follows relationships as far as you need, performing efficient
     # JOINs for you behind the scenes.
     # This finds all articles by a reporter whose name starts with "John".
-    >>> Article.objects.filter(reporter__full_name__startswith="John")
+    >>> Article.objects.filter(reporter__full_name__startswith='John')
     [<Article: Django is cool>]
 
     # Change an object by altering its attributes and calling save().
@@ -224,11 +222,12 @@ Generally, a view retrieves data according to the parameters, loads a template
 and renders the template with the retrieved data. Here's an example view for
 ``year_archive`` from above::
 
-    from django.shortcuts import render_to_response
+    from django.shortcuts import render
 
     def year_archive(request, year):
         a_list = Article.objects.filter(pub_date__year=year)
-        return render_to_response('news/year_archive.html', {'year': year, 'article_list': a_list})
+        context = {'year': year, 'article_list': a_list}
+        return render(request, 'news/year_archive.html', context)
 
 This example uses Django's :doc:`template system </topics/templates>`, which has
 several powerful features but strives to stay simple enough for non-programmers
@@ -265,7 +264,7 @@ might look like:
 
 Variables are surrounded by double-curly braces. ``{{ article.headline }}``
 means "Output the value of the article's headline attribute." But dots aren't
-used only for attribute lookup: They also can do dictionary-key lookup, index
+used only for attribute lookup. They also can do dictionary-key lookup, index
 lookup and function calls.
 
 Note ``{{ article.pub_date|date:"F j, Y" }}`` uses a Unix-style "pipe" (the "|"
@@ -278,7 +277,7 @@ template filters <howto-writing-custom-template-filters>`. You can write
 :doc:`custom template tags </howto/custom-template-tags>`, which run custom
 Python code behind the scenes.
 
-Finally, Django uses the concept of "template inheritance": That's what the
+Finally, Django uses the concept of "template inheritance". That's what the
 ``{% extends "base.html" %}`` does. It means "First load the template called
 'base', which has defined a bunch of blocks, and fill the blocks with the
 following blocks." In short, that lets you dramatically cut down on redundancy
@@ -306,8 +305,8 @@ easy as changing a single file -- the base template.
 
 It also lets you create multiple versions of a site, with different base
 templates, while reusing child templates. Django's creators have used this
-technique to create strikingly different cell-phone editions of sites -- simply
-by creating a new base template.
+technique to create strikingly different mobile versions of sites -- simply by
+creating a new base template.
 
 Note that you don't have to use Django's template system if you prefer another
 system. While Django's template system is particularly well-integrated with
diff --git a/docs/intro/reusable-apps.txt b/docs/intro/reusable-apps.txt
index 8959aae06a..7f1d984d1f 100644
--- a/docs/intro/reusable-apps.txt
+++ b/docs/intro/reusable-apps.txt
@@ -42,9 +42,10 @@ projects and ready to publish for others to install and use.
     bar``. For a directory (like ``polls``) to form a package, it must contain
     a special file ``__init__.py``, even if this file is empty.
 
-    A Django *app* is just a Python package that is specifically intended for
-    use in a Django project. An app may also use common Django conventions,
-    such as having a ``models.py`` file.
+    A Django *application* is just a Python package that is specifically
+    intended for use in a Django project. An application may use common Django
+    conventions, such as having ``models``, ``tests``, ``urls``, and ``views``
+    submodules.
 
     Later on we use the term *packaging* to describe the process of making a
     Python package easy for others to install. It can be a little confusing, we
@@ -128,11 +129,10 @@ this. For a small app like polls, this process isn't too difficult.
        This helps others looking for Django apps identify your app as Django
        specific.
 
-       The application names (that is, the final dotted part of the
-       path to the module containing ``models.py``) defined in
-       :setting:`INSTALLED_APPS` *must* be unique. Avoid using the
-       same name as any of the Django :doc:`contrib packages
-       </ref/contrib/index>`, for example ``auth``, ``admin`` or
+       Application labels (that is, the final part of the dotted path to
+       application packages) *must* be unique in :setting:`INSTALLED_APPS`.
+       Avoid using the same label as any of the Django :doc:`contrib packages
+       </ref/contrib/index>`, for example ``auth``, ``admin``, or
        ``messages``.
 
 2. Move the ``polls`` directory into the ``django-polls`` directory.
@@ -215,9 +215,10 @@ this. For a small app like polls, this process isn't too difficult.
                'License :: OSI Approved :: BSD License', # example license
                'Operating System :: OS Independent',
                'Programming Language :: Python',
-               # replace these appropriately if you are using Python 3
-               'Programming Language :: Python :: 2',
-               'Programming Language :: Python :: 2.7',
+               # Replace these appropriately if you are stuck on Python 2.
+               'Programming Language :: Python :: 3',
+               'Programming Language :: Python :: 3.2',
+               'Programming Language :: Python :: 3.3',
                'Topic :: Internet :: WWW/HTTP',
                'Topic :: Internet :: WWW/HTTP :: Dynamic Content',
            ],
diff --git a/docs/intro/tutorial01.txt b/docs/intro/tutorial01.txt
index d8e62a70ed..3fa07e132c 100644
--- a/docs/intro/tutorial01.txt
+++ b/docs/intro/tutorial01.txt
@@ -17,18 +17,17 @@ tell Django is installed and which version by running the following command:
 
 .. code-block:: bash
 
-    python -c "import django; print(django.get_version())"
+    $ python -c "import django; print(django.get_version())"
 
 If Django is installed, you should see the version of your installation. If it
 isn't, you'll get an error telling "No module named django".
 
-This tutorial is written for Django |version| and Python 2.x. If the Django
-version doesn't match, you can refer to the tutorial for your version of
-Django by using the version switcher at the bottom right corner of this page,
-or update Django to the newest version. If you are using Python 3.x, be aware
-that your code may need to differ from what is in the tutorial and you should
-continue using the tutorial only if you know what you are doing with Python
-3.x.
+This tutorial is written for Django |version| and Python 3.2 or later. If the
+Django version doesn't match, you can refer to the tutorial for your version
+of Django by using the version switcher at the bottom right corner of this
+page, or update Django to the newest version. If you are still using Python
+2.7, you will need to adjust the code samples slightly, as described in
+comments.
 
 See :doc:`How to install Django </topics/install>` for advice on how to remove
 older versions of Django and install a newer one.
@@ -55,7 +54,7 @@ code, then run the following command:
 
 .. code-block:: bash
 
-   django-admin.py startproject mysite
+   $ django-admin.py startproject mysite
 
 This will create a ``mysite`` directory in your current directory. If it didn't
 work, see :ref:`troubleshooting-django-admin-py`.
@@ -131,8 +130,13 @@ The development server
 ----------------------
 
 Let's verify this worked. Change into the outer :file:`mysite` directory, if
-you haven't already, and run the command ``python manage.py runserver``. You'll
-see the following output on the command line:
+you haven't already, and run the command:
+
+.. code-block:: bash
+
+   $ python manage.py runserver
+
+You'll see the following output on the command line:
 
 .. parsed-literal::
 
@@ -149,7 +153,7 @@ purely in Python. We've included this with Django so you can develop things
 rapidly, without having to deal with configuring a production server -- such as
 Apache -- until you're ready for production.
 
-Now's a good time to note: **Don't** use this server in anything resembling a
+Now's a good time to note: **don't** use this server in anything resembling a
 production environment. It's intended only for use while developing. (We're in
 the business of making Web frameworks, not Web servers.)
 
@@ -185,9 +189,8 @@ It worked!
 
     The development server automatically reloads Python code for each request
     as needed. You don't need to restart the server for code changes to take
-    effect. However, some actions like adding files or compiling translation
-    files don't trigger a restart, so you'll have to restart the server in
-    these cases.
+    effect. However, some actions like adding files don't trigger a restart,
+    so you'll have to restart the server in these cases.
 
 Database setup
 --------------
@@ -209,8 +212,8 @@ settings:
   ``'django.db.backends.sqlite3'``,
   ``'django.db.backends.postgresql_psycopg2'``,
   ``'django.db.backends.mysql'``, or
-  ``'django.db.backends.oracle'``. Other backends are :setting:`also available
-  <DATABASE-ENGINE>`.
+  ``'django.db.backends.oracle'``. Other backends are :ref:`also available
+  <third-party-notes>`.
 
 * :setting:`NAME` -- The name of your database. If you're using SQLite, the
   database will be a file on your computer; in that case, :setting:`NAME`
@@ -568,9 +571,11 @@ make new ones - it specialises in upgrading your database live, without
 losing data. We'll cover them in more depth in a later part of the tutorial,
 but for now, remember the three-step guide to making model changes:
 
-* Change your models (in models.py)
-* Run ``python manage.py makemigrations`` to create migrations for those changes
-* Run ``python manage.py migrate`` to apply those changes to the database.
+* Change your models (in ``models.py``).
+* Run :djadmin:`python manage.py makemigrations <makemigrations>` to create
+  migrations for those changes
+* Run :djadmin:`python manage.py migrate <migrate>` to apply those changes to
+  the database.
 
 The reason there's separate commands to make and apply migrations is because
 you'll commit migrations to your version control system and ship them with
@@ -597,9 +602,19 @@ the Python import path to your :file:`mysite/settings.py` file.
 .. admonition:: Bypassing manage.py
 
     If you'd rather not use :file:`manage.py`, no problem. Just set the
-    ``DJANGO_SETTINGS_MODULE`` environment variable to ``mysite.settings`` and
-    run ``python`` from the same directory :file:`manage.py` is in (or ensure
-    that directory is on the Python path, so that ``import mysite`` works).
+    :envvar:`DJANGO_SETTINGS_MODULE` environment variable to
+    ``mysite.settings``, start a plain Python shell, and set up Django::
+
+    >>> import django
+    >>> django.setup()
+
+    If this raises an :exc:`~exceptions.AttributeError`, you're probably using
+    a version of Django that doesn't match this tutorial version. You'll want
+    to either switch to the older tutorial or the newer Django version.
+
+    You must run ``python`` from the same directory :file:`manage.py` is in,
+    or ensure that directory is on the Python path, so that ``import mysite``
+    works.
 
     For more information on all of this, see the :doc:`django-admin.py
     documentation </ref/django-admin>`.
@@ -647,9 +662,8 @@ Once you're in the shell, explore the :doc:`database API </topics/db/queries>`::
 Wait a minute. ``<Question: Question object>`` is, utterly, an unhelpful representation
 of this object. Let's fix that by editing the ``Question`` model (in the
 ``polls/models.py`` file) and adding a
-:meth:`~django.db.models.Model.__unicode__` method to both ``Question`` and
-``Choice``. On Python 3, simply replace ``__unicode__`` by ``__str__`` in the
-following example:
+:meth:`~django.db.models.Model.__str__` method to both ``Question`` and
+``Choice``:
 
 .. snippet::
     :filename: polls/models.py
@@ -658,42 +672,35 @@ following example:
 
     class Question(models.Model):
         # ...
-        def __unicode__(self):  # Python 3: def __str__(self):
+        def __str__(self):              # __unicode__ on Python 2
             return self.question_text
 
     class Choice(models.Model):
         # ...
-        def __unicode__(self):  # Python 3: def __str__(self):
+        def __str__(self):              # __unicode__ on Python 2
             return self.choice_text
 
-It's important to add :meth:`~django.db.models.Model.__unicode__` methods (or
-:meth:`~django.db.models.Model.__str__` on Python 3) to your models, not only
-for your own sanity when dealing with the interactive prompt, but also because
-objects' representations are used throughout Django's automatically-generated
-admin.
+It's important to add :meth:`~django.db.models.Model.__str__` methods to your
+models, not only for your own sanity when dealing with the interactive prompt,
+but also because objects' representations are used throughout Django's
+automatically-generated admin.
 
-.. admonition:: ``__unicode__`` or ``__str__``?
+.. admonition:: ``__str__`` or ``__unicode__``?
 
-    On Python 3, things are simpler, just use
-    :meth:`~django.db.models.Model.__str__` and forget about
-    :meth:`~django.db.models.Model.__unicode__`.
+    On Python 3, it's easy, just use
+    :meth:`~django.db.models.Model.__str__`.
 
-    If you're familiar with Python 2, you might be in the habit of adding
-    :meth:`~django.db.models.Model.__str__` methods to your classes, not
-    :meth:`~django.db.models.Model.__unicode__` methods. We use
-    :meth:`~django.db.models.Model.__unicode__` here because Django models deal
-    with Unicode by default. All data stored in your database is converted to
-    Unicode when it's returned.
+    On Python 2, you should define :meth:`~django.db.models.Model.__unicode__`
+    methods returning ``unicode`` values instead. Django models have a default
+    :meth:`~django.db.models.Model.__str__` method that calls
+    :meth:`~django.db.models.Model.__unicode__` and converts the result to a
+    UTF-8 bytestring. This means that ``unicode(p)`` will return a Unicode
+    string, and ``str(p)`` will return a bytestring, with characters encoded
+    as UTF-8. Python does the opposite: ``object`` has a ``__unicode__``
+    method that calls ``__str__`` and interprets the result as an ASCII
+    bytestring. This difference can create confusion.
 
-    Django models have a default :meth:`~django.db.models.Model.__str__` method
-    that calls :meth:`~django.db.models.Model.__unicode__` and converts the
-    result to a UTF-8 bytestring. This means that ``unicode(p)`` will return a
-    Unicode string, and ``str(p)`` will return a normal string, with characters
-    encoded as UTF-8.
-
-    If all of this is gibberish to you, just remember to add
-    :meth:`~django.db.models.Model.__unicode__` methods to your models. With any
-    luck, things should Just Work for you.
+    If all of this is gibberish to you, just use Python 3.
 
 Note these are normal Python methods. Let's add a custom method, just for
 demonstration:
diff --git a/docs/intro/tutorial02.txt b/docs/intro/tutorial02.txt
index b703200428..11c0bece6b 100644
--- a/docs/intro/tutorial02.txt
+++ b/docs/intro/tutorial02.txt
@@ -469,7 +469,7 @@ template directory in the source code of Django itself
 
     .. code-block:: bash
 
-        python -c "
+        $ python -c "
         import sys
         sys.path = sys.path[1:]
         import django
diff --git a/docs/man/daily_cleanup.1 b/docs/man/daily_cleanup.1
deleted file mode 100644
index dfcde1dff7..0000000000
--- a/docs/man/daily_cleanup.1
+++ /dev/null
@@ -1,34 +0,0 @@
-.TH "daily_cleanup.py" "1" "August 2007" "Django Project" ""
-.SH "NAME"
-daily_cleanup.py \- Database clean-up for the Django Web framework
-.SH "SYNOPSIS"
-.B daily_cleanup.py
-
-.SH "DESCRIPTION"
-Removes stale session data from a Django database. This means, any session data
-which has an expiry date prior to the date the script is run.
-.sp
-The script can be run manually or can be scheduled to run at regular
-intervals as a
-.BI cron
-job.
-
-.SH "ENVIRONMENT"
-.TP
-.I DJANGO_SETTINGS_MODULE
-This environment variable defines the settings module to be read.
-It should be in Python-import form, e.g. "myproject.settings".
-
-.SH "SEE ALSO"
-The sessions documentation:
-.sp
-.I http://docs.djangoproject.com/en/dev/topics/http/sessions/
-
-.SH "AUTHORS/CREDITS"
-Originally developed at World Online in Lawrence, Kansas, USA. Refer to the
-AUTHORS file in the Django distribution for contributors.
-
-.SH "LICENSE"
-New BSD license. For the full license text refer to the LICENSE file in the
-Django distribution.
-
diff --git a/docs/man/django-admin.1 b/docs/man/django-admin.1
index c72c3520b5..c9932ac36f 100644
--- a/docs/man/django-admin.1
+++ b/docs/man/django-admin.1
@@ -40,7 +40,7 @@ Displays differences between the current
 and Django's default settings. Settings that don't appear in the defaults are
 followed by "###".
 .TP
-.BI "dumpdata [" "\-\-all" "] [" "\-\-format=FMT" "] [" "\-\-indent=NUM" "] [" "\-\-natural=NATURAL" "] [" "appname appname appname.Model ..." "]"
+.BI "dumpdata [" "\-\-all" "] [" "\-\-format=FMT" "] [" "\-\-indent=NUM" "] [" "\-\-natural=NATURAL" "] [" "app_label app_label app_label.Model ..." "]"
 Outputs to standard output all data in the database associated with the named
 application(s).
 .TP
@@ -54,7 +54,7 @@ model module.
 .BI "loaddata [" "fixture fixture ..." "]"
 Searches for and loads the contents of the named fixture into the database.
 .TP
-.BI "install [" "appname ..." "]"
+.BI "install [" "app_label ..." "]"
 Executes
 .B sqlall
 for the given app(s) in the current database.
@@ -79,33 +79,33 @@ The
 option forces the use of the standard Python interpreter even when IPython is
 installed.
 .TP
-.BI "sql [" "appname ..." "]"
+.BI "sql [" "app_label ..." "]"
 Prints the CREATE TABLE SQL statements for the given app name(s).
 .TP
-.BI "sqlall [" "appname ..." "]"
+.BI "sqlall [" "app_label ..." "]"
 Prints the CREATE TABLE, initial\-data and CREATE INDEX SQL statements for the
 given model module name(s).
 .TP
-.BI "sqlclear [" "appname ..." "]"
+.BI "sqlclear [" "app_label ..." "]"
 Prints the DROP TABLE SQL statements for the given app name(s).
 .TP
-.BI "sqlcustom [" "appname ..." "]"
+.BI "sqlcustom [" "app_label ..." "]"
 Prints the custom SQL statements for the given app name(s).
 .TP
-.BI "sqlflush [" "appname ..." "]"
+.BI "sqlflush [" "app_label ..." "]"
 Prints the SQL statements that would be executed for the "flush" command.
 .TP
-.BI "sqlindexes [" "appname ..." "]"
+.BI "sqlindexes [" "app_label ..." "]"
 Prints the CREATE INDEX SQL statements for the given model module name(s).
 .TP
-.BI "sqlinitialdata [" "appname ..." "]"
+.BI "sqlinitialdata [" "app_label ..." "]"
 Prints the initial INSERT SQL statements for the given app name(s).
 .TP
-.BI "sqlsequencereset [" "appname ..." "]"
+.BI "sqlsequencereset [" "app_label ..." "]"
 Prints the SQL statements for resetting PostgreSQL sequences for the
 given app name(s).
 .TP
-.BI "startapp [" "\-\-template=PATH_OR_URL" "] [" "\-\-extension=EXTENSION" "] [" "\-\-name=FILENAME" "] [" "appname" "] [" "destination" "]"
+.BI "startapp [" "\-\-template=PATH_OR_URL" "] [" "\-\-extension=EXTENSION" "] [" "\-\-name=FILENAME" "] [" "app_label" "] [" "destination" "]"
 Creates a Django app directory structure for the given app name in
 the current directory or the optional destination.
 .TP
@@ -117,7 +117,7 @@ in the current directory or the optional destination.
 Runs migrations for apps containing migrations, and just creates missing tables
 for apps without migrations.
 .TP
-.BI "test [" "\-\-verbosity" "] [" "\-\-failfast" "] [" "appname ..." "]"
+.BI "test [" "\-\-verbosity" "] [" "\-\-failfast" "] [" "app_label ..." "]"
 Runs the test suite for the specified applications, or the entire project if
 no apps are specified
 .TP
diff --git a/docs/ref/applications.txt b/docs/ref/applications.txt
new file mode 100644
index 0000000000..e496f24487
--- /dev/null
+++ b/docs/ref/applications.txt
@@ -0,0 +1,226 @@
+============
+Applications
+============
+
+.. module:: django.apps
+
+.. versionadded:: 1.7
+
+Django contains a registry of installed applications that stores configuration
+and provides introspection. It also maintains a list of available :doc:`models
+</topics/db/models>`.
+
+This registry is simply called :attr:`~django.apps.apps` and it's available in
+:mod:`django.apps`::
+
+    >>> from django.apps import apps
+    >>> apps.get_app_config('admin').verbose_name
+    'Admin'
+
+Projects and applications
+=========================
+
+Django has historically used the term **project** to describe an installation
+of Django. A project is defined primarily by a settings module.
+
+The term **application** describes a Python package that provides some set of
+features. Applications may be reused in various projects.
+
+.. note::
+    This terminology is somewhat confusing these days as it became common to
+    use the phrase "web app" to describe what equates to a Django project.
+
+Applications include some combination of models, views, templates, template
+tags, static files, URLs, middleware, etc. They're generally wired into
+projects with the :setting:`INSTALLED_APPS` setting and optionally with other
+mechanisms such as URLconfs, the :setting:`MIDDLEWARE_CLASSES` setting, or
+template inheritance.
+
+It is important to understand that a Django application is just a set of code
+that interacts with various parts of the framework. There's no such thing as
+an ``Application`` object. However, there's a few places where Django needs to
+interact with installed applications, mainly for configuration and also for
+introspection. That's why the application registry maintains metadata in an
+:class:`~django.apps.AppConfig` instance for each installed application.
+
+Configuring applications
+========================
+
+To configure an application, subclass :class:`~django.apps.AppConfig` and put
+the dotted path to that subclass in :setting:`INSTALLED_APPS`.
+
+Django uses the default :class:`~django.apps.AppConfig` class when
+:setting:`INSTALLED_APPS` simply contains the dotted path to an application
+module.
+
+For application authors
+-----------------------
+
+If you're creating a pluggable app called "Rock ’n’ roll", here's how you
+would provide a proper name for the admin::
+
+    # rock_n_roll/apps.py
+
+    from django.apps import AppConfig
+
+    class RockNRollConfig(AppConfig):
+        name = 'rock_n_roll'
+        verbose_name = "Rock ’n’ roll"
+
+You would then tell your users to add ``'rock_n_roll.apps.RockNRollConfig'``
+to their :setting:`INSTALLED_APPS`.
+
+The recommended convention is to put the configuration class in a submodule of
+the application called ``apps``. However, this isn't enforced by Django.
+
+You must include the :attr:`~django.apps.AppConfig.name` attribute for Django
+to determine which application this configuration applies to. You can define
+any attributes documented in the :class:`~django.apps.AppConfig` API
+reference.
+
+For application users
+---------------------
+
+If you're using "Rock ’n’ roll" in a project called ``anthology``, but you
+want it to show up as "Gypsy jazz" instead, you can provide your own
+configuration::
+
+    # anthology/apps.py
+
+    from rock_n_roll.app import RockNRollConfig
+
+    class GypsyJazzConfig(RockNRollConfig):
+        verbose_name = "Gypsy jazz"
+
+    # anthology/settings.py
+
+    INSTALLED_APPS = [
+        'anthology.apps.GypsyJazzConfig',
+        # ...
+    ]
+
+Again, defining project-specific configuration classes in a submodule called
+``apps`` is a convention, not a requirement.
+
+Application configuration
+=========================
+
+.. class:: AppConfig
+
+    Application configuration objects store metadata for an application. Some
+    attributes can be configured in :class:`~django.apps.AppConfig`
+    subclasses. Others are set by Django and read-only.
+
+Configurable attributes
+-----------------------
+
+.. attribute:: AppConfig.name
+
+    Full Python path to the application, e.g. ``'django.contrib.admin'``.
+
+    This attribute defines which application the configuration applies to. It
+    must be set in all :class:`~django.apps.AppConfig` subclasses.
+
+    It must be unique across a Django project.
+
+.. attribute:: AppConfig.label
+
+    Short name for the application, e.g. ``'admin'``
+
+    This attribute allows relabelling an application when two applications
+    have conflicting labels. It defaults to the last component of ``name``.
+    It should be a valid Python identifier.
+
+    It must be unique across a Django project.
+
+.. attribute:: AppConfig.verbose_name
+
+    Human-readable name for the application, e.g. "Admin".
+
+    This attribute defaults to ``label.title()``.
+
+Read-only attributes
+--------------------
+
+.. attribute:: AppConfig.path
+
+    Filesystem path to the application directory, e.g.
+    ``'/usr/lib/python2.7/dist-packages/django/contrib/admin'``.
+
+    It may be ``None`` if the application isn't stored in a directory, for
+    instance if it's loaded from an egg.
+
+.. attribute:: AppConfig.module
+
+    Root module for the application, e.g. ``<module 'django.contrib.admin' from
+    'django/contrib/admin/__init__.pyc'>``.
+
+.. attribute:: AppConfig.models_module
+
+    Module containing the models, e.g. ``<module 'django.contrib.admin.models'
+    from 'django/contrib/admin/models.pyc'>``.
+
+    It may be ``None`` if the application doesn't contain a ``models`` module.
+
+Methods
+-------
+
+.. method:: AppConfig.get_models()
+
+    Returns an iterable of :class:`~django.db.models.Model` classes.
+
+.. method:: AppConfig.get_model(model_name)
+
+    Returns the :class:`~django.db.models.Model` with the given
+    ``model_name``. Raises :exc:`~exceptions.LookupError` if no such model
+    exists. ``model_name`` is case-insensitive.
+
+.. method:: AppConfig.ready()
+
+    Subclasses can override this method to perform initialization tasks such
+    as registering signals. It is called as soon as the registry is fully
+    populated.
+
+    You cannot import models in modules that define application configuration
+    classes, but you can use :meth:`get_model` to access a model class by
+    name, like this::
+
+        def ready(self):
+            MyModel = self.get_model('MyModel')
+
+Application registry
+====================
+
+.. data:: apps
+
+    The application registry provides the following public API. Methods that
+    aren't listed below are considered private and may change without notice.
+
+.. method:: apps.ready()
+
+    Returns ``True`` if the registry is fully populated.
+
+.. method:: apps.get_app_configs()
+
+    Returns an iterable of :class:`~django.apps.AppConfig` instances.
+
+.. method:: apps.get_app_config(app_label)
+
+    Returns an :class:`~django.apps.AppConfig` for the application with the
+    given ``app_label``. Raises :exc:`~exceptions.LookupError` if no such
+    application exists.
+
+.. method:: apps.is_installed(app_name)
+
+    Checks whether an application with the given name exists in the registry.
+    ``app_name`` is the full name of the app, e.g. 'django.contrib.admin'.
+
+    Unlike :meth:`~django.apps.apps.get_app_config`, this method can be called
+    safely at import time. If the registry is still being populated, it may
+    return ``False``, even though the app will become available later.
+
+.. method:: apps.get_model(app_label, model_name)
+
+    Returns the :class:`~django.db.models.Model` with the given ``app_label``
+    and ``model_name``. Raises :exc:`~exceptions.LookupError` if no such
+    application or model exists. ``model_name`` is case-insensitive.
diff --git a/docs/ref/contrib/admin/admindocs.txt b/docs/ref/contrib/admin/admindocs.txt
index f903e8efff..c5386c5b2f 100644
--- a/docs/ref/contrib/admin/admindocs.txt
+++ b/docs/ref/contrib/admin/admindocs.txt
@@ -44,8 +44,8 @@ hyperlinks to other components:
 =================   =======================
 Django Component    reStructuredText roles
 =================   =======================
-Models              ``:model:`appname.ModelName```
-Views               ``:view:`appname.view_name```
+Models              ``:model:`app_label.ModelName```
+Views               ``:view:`app_label.view_name```
 Template tags       ``:tag:`tagname```
 Template filters    ``:filter:`filtername```
 Templates           ``:template:`path/to/template.html```
diff --git a/docs/ref/contrib/auth.txt b/docs/ref/contrib/auth.txt
index 154c0ab75b..ac78da1ece 100644
--- a/docs/ref/contrib/auth.txt
+++ b/docs/ref/contrib/auth.txt
@@ -128,6 +128,10 @@ Methods
         the :attr:`~django.contrib.auth.models.User.last_name`, with a space in
         between.
 
+    .. method:: get_short_name()
+
+        Returns the :attr:`~django.contrib.auth.models.User.first_name`.
+
     .. method:: set_password(raw_password)
 
         Sets the user's password to the given raw string, taking care of the
diff --git a/docs/ref/contrib/gis/forms-api.txt b/docs/ref/contrib/gis/forms-api.txt
index 435bcfc8b1..a556fac1fc 100644
--- a/docs/ref/contrib/gis/forms-api.txt
+++ b/docs/ref/contrib/gis/forms-api.txt
@@ -156,6 +156,20 @@ Widget classes
     This is the default widget used by all GeoDjango form fields.
     ``template_name`` is ``gis/openlayers.html``.
 
+    ``OpenLayersWidget`` and :class:`OSMWidget` use the ``openlayers.js`` file
+    hosted on the ``openlayers.org`` Web site. This works for basic usage
+    during development, but isn't appropropriate for a production deployment as
+    ``openlayers.org/api/`` has no guaranteed uptime and runs on a slow server.
+    You are therefore advised to subclass these widgets in order to specify
+    your own version of the ``openlayers.js`` file in the ``js`` property of
+    the inner ``Media`` class (see :ref:`assets-as-a-static-definition`). You
+    can host a copy of ``openlayers.js``
+    `tailored to your needs`_ on your own server or refer to a copy from a
+    content-delivery network like http://cdnjs.com/. This will also allow
+    you to serve the JavaScript file(s) using the ``https`` protocol if needed.
+
+    .. _tailored to your needs: http://docs.openlayers.org/library/deploying.html
+
 ``OSMWidget``
 
 .. class:: OSMWidget
@@ -163,3 +177,9 @@ Widget classes
     This widget uses an OpenStreetMap base layer (Mapnik) to display geographic
     objects on.
     ``template_name`` is ``gis/openlayers-osm.html``.
+
+    The :class:`OpenLayersWidget` note about JavaScript file hosting above also
+    applies here. See also this `FAQ answer`_ about ``https`` access to map
+    tiles.
+
+    .. _FAQ answer: https://help.openstreetmap.org/questions/10920/how-to-embed-a-map-in-my-https-site
diff --git a/docs/ref/contrib/gis/geos.txt b/docs/ref/contrib/gis/geos.txt
index d557af96a3..4a2a26b725 100644
--- a/docs/ref/contrib/gis/geos.txt
+++ b/docs/ref/contrib/gis/geos.txt
@@ -282,10 +282,6 @@ Returns the EWKB of this Geometry in hexadecimal form.  This is an
 extension of the WKB specification that includes the SRID value
 that are a part of this geometry.
 
-.. note::
-
-   GEOS 3.1 is *required* if you want valid 3D HEXEWKB.
-
 .. attribute:: GEOSGeometry.json
 
 Returns the GeoJSON representation of the geometry.
@@ -307,7 +303,7 @@ geometry.  This should only be used for geometries with an SRID of
 .. attribute:: GEOSGeometry.ogr
 
 Returns an :class:`~django.contrib.gis.gdal.OGRGeometry` object
-correspondg to the GEOS geometry.
+corresponding to the GEOS geometry.
 
 .. note::
 
@@ -329,10 +325,6 @@ Return the EWKB representation of this Geometry as a Python buffer.
 This is an extension of the WKB specification that includes any SRID
 value that are a part of this geometry.
 
-.. note::
-
-   GEOS 3.1 is *required* if you want valid 3D EWKB.
-
 .. attribute:: GEOSGeometry.wkt
 
 Returns the Well-Known Text of the geometry (an OGC standard).
@@ -533,14 +525,10 @@ a :class:`Polygon`).
 
 .. attribute:: GEOSGeometry.prepared
 
-.. note::
-
-    Support for prepared geometries requires GEOS 3.1.
-
 Returns a GEOS ``PreparedGeometry`` for the contents of this geometry.
 ``PreparedGeometry`` objects are optimized for the contains, intersects,
-and covers operations.  Refer to the :ref:`prepared-geometries` documentation
-for more information.
+covers, crosses, disjoint, overlaps, touches and within operations. Refer to
+the :ref:`prepared-geometries` documentation for more information.
 
 .. attribute:: GEOSGeometry.srs
 
@@ -553,7 +541,7 @@ corresponding to the SRID of the geometry or ``None``.
 
 .. method:: GEOSGeometry.transform(ct, clone=False)
 
-Transforms the geometry according to the given coordinate transformation paramter
+Transforms the geometry according to the given coordinate transformation parameter
 (``ct``), which may be an integer SRID, spatial reference WKT string,
 a PROJ.4 string, a :class:`~django.contrib.gis.gdal.SpatialReference` object, or a
 :class:`~django.contrib.gis.gdal.CoordTransform` object. By default, the geometry
@@ -710,10 +698,6 @@ Geometry Collections
    more efficient (faster) than trying to union the geometries together
    individually. [#fncascadedunion]_
 
-   .. note::
-
-       GEOS 3.1 is *required* to peform cascaded unions.
-
 ``GeometryCollection``
 ----------------------
 
@@ -740,10 +724,6 @@ geometry can be orders of magnitude faster -- the more complex the geometry
 that is prepared, the larger the speedup in the operation.  For more information,
 please consult the `GEOS wiki page on prepared geometries <http://trac.osgeo.org/geos/wiki/PreparedGeometry>`_.
 
-.. note::
-
-   GEOS 3.1 is *required* in order to use prepared geometries.
-
 For example::
 
     >>> from django.contrib.gis.geos import Point, Polygon
@@ -766,8 +746,48 @@ For example::
 
   .. method:: covers(other)
 
+  .. method:: crosses(other)
+
+    .. versionadded:: 1.7
+
+    .. note::
+
+       GEOS 3.3 is *required* to use this predicate.
+
+  .. method:: disjoint(other)
+
+    .. versionadded:: 1.7
+
+    .. note::
+
+       GEOS 3.3 is *required* to use this predicate.
+
   .. method:: intersects(other)
 
+  .. method:: overlaps(other)
+
+    .. versionadded:: 1.7
+
+    .. note::
+
+       GEOS 3.3 is *required* to use this predicate.
+
+  .. method:: touches(other)
+
+    .. versionadded:: 1.7
+
+    .. note::
+
+       GEOS 3.3 is *required* to use this predicate.
+
+  .. method:: within(other)
+
+    .. versionadded:: 1.7
+
+    .. note::
+
+       GEOS 3.3 is *required* to use this predicate.
+
 Geometry Factories
 ==================
 
diff --git a/docs/ref/contrib/gis/install/geolibs.txt b/docs/ref/contrib/gis/install/geolibs.txt
index 508bf7809c..a529a497d2 100644
--- a/docs/ref/contrib/gis/install/geolibs.txt
+++ b/docs/ref/contrib/gis/install/geolibs.txt
@@ -10,7 +10,7 @@ geospatial libraries:
 ========================  ====================================  ================================  ==========================
 Program                   Description                           Required                          Supported Versions
 ========================  ====================================  ================================  ==========================
-:ref:`GEOS <ref-geos>`    Geometry Engine Open Source           Yes                               3.3, 3.2, 3.1, 3.0
+:ref:`GEOS <ref-geos>`    Geometry Engine Open Source           Yes                               3.3, 3.2, 3.1
 `PROJ.4`_                 Cartographic Projections library      Yes (PostgreSQL and SQLite only)  4.8, 4.7, 4.6, 4.5, 4.4
 :ref:`GDAL <ref-gdal>`    Geospatial Data Abstraction Library   No (but, required for SQLite)     1.9, 1.8, 1.7, 1.6
 :ref:`GeoIP <ref-geoip>`  IP-based geolocation library          No                                1.4
@@ -20,7 +20,6 @@ Program                   Description                           Required
 
 ..
     Libs release dates:
-    GEOS 3.0.0 2008-08-14
     GEOS 3.1.0 2009-03-11
     GEOS 3.2.0 2009-12-14
     GEOS 3.3.0 2011-05-30
diff --git a/docs/ref/contrib/gis/model-api.txt b/docs/ref/contrib/gis/model-api.txt
index 81b619e338..10cc2957d8 100644
--- a/docs/ref/contrib/gis/model-api.txt
+++ b/docs/ref/contrib/gis/model-api.txt
@@ -172,8 +172,7 @@ three-dimensonal support.
 
 .. note::
 
-    At this time 3D support requires that GEOS 3.1 be installed, and is
-    limited only to the PostGIS spatial backend.
+    At this time 3D support is limited to the PostGIS spatial backend.
 
 ``geography``
 -------------
diff --git a/docs/ref/contrib/redirects.txt b/docs/ref/contrib/redirects.txt
index e987e3961c..80f0f3bc90 100644
--- a/docs/ref/contrib/redirects.txt
+++ b/docs/ref/contrib/redirects.txt
@@ -89,6 +89,8 @@ Middleware
 
     .. attribute:: response_gone_class
 
+        ..  versionadded:: 1.7
+
         The :class:`~django.http.HttpResponse` class used when a
         :class:`~django.contrib.redirects.models.Redirect` is not
         found for the requested path or has a blank ``new_path``
@@ -98,6 +100,8 @@ Middleware
 
     .. attribute:: response_redirect_class
 
+        ..  versionadded:: 1.7
+
         The :class:`~django.http.HttpResponse` class that handles the
         redirect.
 
diff --git a/docs/ref/databases.txt b/docs/ref/databases.txt
index f04b8830f7..f7c4f0f9fb 100644
--- a/docs/ref/databases.txt
+++ b/docs/ref/databases.txt
@@ -305,6 +305,17 @@ The Django adapter is currently only available in the Dev branch.
 
 .. _release branches: http://dev.mysql.com/downloads/connector/python/
 
+.. _mysql-time-zone-definitions:
+
+Time zone definitions
+---------------------
+
+If you plan on using Django's :doc:`timezone support </topics/i18n/timezones>`,
+use `mysql_tzinfo_to_sql`_ to load time zone tables into the MySQL database.
+This needs to be done just once for your MySQL server, not per database.
+
+.. _mysql_tzinfo_to_sql: http://dev.mysql.com/doc/refman/5.5/en/mysql-tzinfo-to-sql.html
+
 Creating your database
 ----------------------
 
diff --git a/docs/ref/django-admin.txt b/docs/ref/django-admin.txt
index cac7a5bc22..06f589ee63 100644
--- a/docs/ref/django-admin.txt
+++ b/docs/ref/django-admin.txt
@@ -14,6 +14,12 @@ two things for you before delegating to ``django-admin.py``:
 * It sets the :envvar:`DJANGO_SETTINGS_MODULE` environment variable so that
   it points to your project's ``settings.py`` file.
 
+* It calls ``django.setup()`` to initialize various internals of Django.
+
+.. versionadded:: 1.7
+
+    ``django.setup()`` didn't exist in previous versions of Django.
+
 The ``django-admin.py`` script should be on your system path if you installed
 Django via its ``setup.py`` utility. If it's not on your path, you can find it
 in ``site-packages/django/bin`` within your Python installation. Consider
@@ -38,8 +44,8 @@ Usage
 
 .. code-block:: bash
 
-    django-admin.py <command> [options]
-    manage.py <command> [options]
+    $ django-admin.py <command> [options]
+    $ manage.py <command> [options]
 
 ``command`` should be one of the commands listed in this document.
 ``options``, which is optional, should be zero or more of the options available
@@ -183,8 +189,8 @@ if they have Django's default value. Such settings are prefixed by ``"###"``.
 
     The :djadminopt:`--all` option was added.
 
-dumpdata <appname appname appname.Model ...>
---------------------------------------------
+dumpdata <app_label app_label app_label.Model ...>
+--------------------------------------------------
 
 .. django-admin:: dumpdata
 
@@ -217,10 +223,10 @@ easy for humans to read, so you can use the ``--indent`` option to
 pretty-print the output with a number of indentation spaces.
 
 The :djadminopt:`--exclude` option may be provided to prevent specific
-applications or models (specified as in the form of ``appname.ModelName``) from
-being dumped. If you specify a model name to ``dumpdata``, the dumped output
-will be restricted to that model, rather than the entire application. You can
-also mix application names and model names.
+applications or models (specified as in the form of ``app_label.ModelName``)
+from being dumped. If you specify a model name to ``dumpdata``, the dumped
+output will be restricted to that model, rather than the entire application.
+You can also mix application names and model names.
 
 The :djadminopt:`--database` option can be used to specify the database
 from which data will be dumped.
@@ -398,7 +404,7 @@ directories will be included in the search path. For example::
 
     django-admin.py loaddata foo/bar/mydata.json
 
-would search ``<appname>/fixtures/foo/bar/mydata.json`` for each installed
+would search ``<app_label>/fixtures/foo/bar/mydata.json`` for each installed
 application,  ``<dirname>/foo/bar/mydata.json`` for each directory in
 :setting:`FIXTURE_DIRS`, and the literal path ``foo/bar/mydata.json``.
 
@@ -587,8 +593,8 @@ Use the ``--keep-pot`` option to prevent Django from deleting the temporary
 .pot files it generates before creating the .po file. This is useful for
 debugging errors which may prevent the final language files from being created.
 
-makemigrations [<appname>]
---------------------------
+makemigrations [<app_label>]
+----------------------------
 
 .. django-admin:: makemigrations
 
@@ -610,8 +616,8 @@ for advanced users and should not be used unless you are familiar with
 the migration format, migration operations, and the dependencies between
 your migrations.
 
-migrate [<appname> [<migrationname>]]
--------------------------------------
+migrate [<app_label> [<migrationname>]]
+---------------------------------------
 
 .. django-admin:: migrate
 
@@ -625,10 +631,10 @@ The behavior of this command changes depending on the arguments provided:
 
 * No arguments: All migrated apps have all of their migrations run,
   and all unmigrated apps are synchronized with the database,
-* ``<appname>``: The specified app has its migrations run, up to the most
+* ``<app_label>``: The specified app has its migrations run, up to the most
   recent migration. This may involve running other apps' migrations too, due
   to dependencies.
-* ``<appname> <migrationname>``: Brings the database schema to a state where it
+* ``<app_label> <migrationname>``: Brings the database schema to a state where it
   would have just run the given migration, but no further - this may involve
   unapplying migrations if you have previously migrated past the named
   migration. Use the name `zero` to unapply all migrations for an app.
@@ -942,8 +948,8 @@ behavior you can use the ``--no-startup`` option. e.g.::
 
     The ``--no-startup`` option was added in Django 1.6.
 
-sql <appname appname ...>
--------------------------
+sql <app_label app_label ...>
+-----------------------------
 
 .. django-admin:: sql
 
@@ -952,8 +958,8 @@ Prints the CREATE TABLE SQL statements for the given app name(s).
 The :djadminopt:`--database` option can be used to specify the database for
 which to print the SQL.
 
-sqlall <appname appname ...>
-----------------------------
+sqlall <app_label app_label ...>
+--------------------------------
 
 .. django-admin:: sqlall
 
@@ -965,8 +971,8 @@ specify initial data.
 The :djadminopt:`--database` option can be used to specify the database for
 which to print the SQL.
 
-sqlclear <appname appname ...>
-------------------------------
+sqlclear <app_label app_label ...>
+----------------------------------
 
 .. django-admin:: sqlclear
 
@@ -975,19 +981,19 @@ Prints the DROP TABLE SQL statements for the given app name(s).
 The :djadminopt:`--database` option can be used to specify the database for
 which to print the SQL.
 
-sqlcustom <appname appname ...>
--------------------------------
+sqlcustom <app_label app_label ...>
+-----------------------------------
 
 .. django-admin:: sqlcustom
 
 Prints the custom SQL statements for the given app name(s).
 
 For each model in each specified app, this command looks for the file
-``<appname>/sql/<modelname>.sql``, where ``<appname>`` is the given app name and
-``<modelname>`` is the model's name in lowercase. For example, if you have an
-app ``news`` that includes a ``Story`` model, ``sqlcustom`` will attempt
-to read a file ``news/sql/story.sql`` and append it to the output of this
-command.
+``<app_label>/sql/<modelname>.sql``, where ``<app_label>`` is the given app
+name and ``<modelname>`` is the model's name in lowercase. For example, if you
+have an app ``news`` that includes a ``Story`` model, ``sqlcustom`` will
+attempt to read a file ``news/sql/story.sql`` and append it to the output of
+this command.
 
 Each of the SQL files, if given, is expected to contain valid SQL. The SQL
 files are piped directly into the database after all of the models'
@@ -999,8 +1005,8 @@ Note that the order in which the SQL files are processed is undefined.
 The :djadminopt:`--database` option can be used to specify the database for
 which to print the SQL.
 
-sqldropindexes <appname appname ...>
-------------------------------------
+sqldropindexes <app_label app_label ...>
+----------------------------------------
 
 .. django-admin:: sqldropindexes
 
@@ -1022,8 +1028,8 @@ command.
 The :djadminopt:`--database` option can be used to specify the database for
 which to print the SQL.
 
-sqlindexes <appname appname ...>
---------------------------------
+sqlindexes <app_label app_label ...>
+------------------------------------
 
 .. django-admin:: sqlindexes
 
@@ -1032,8 +1038,8 @@ Prints the CREATE INDEX SQL statements for the given app name(s).
 The :djadminopt:`--database` option can be used to specify the database for
 which to print the SQL.
 
-sqlmigrate <appname> <migrationname>
-------------------------------------
+sqlmigrate <app_label> <migrationname>
+--------------------------------------
 
 .. django-admin:: sqlmigrate
 
@@ -1050,8 +1056,8 @@ By default, the SQL created is for running the migration in the forwards
 direction. Pass ``--backwards`` to generate the SQL for
 un-applying the migration instead.
 
-sqlsequencereset <appname appname ...>
---------------------------------------
+sqlsequencereset <app_label app_label ...>
+------------------------------------------
 
 .. django-admin:: sqlsequencereset
 
@@ -1066,8 +1072,8 @@ of sync with its automatically incremented field data.
 The :djadminopt:`--database` option can be used to specify the database for
 which to print the SQL.
 
-startapp <appname> [destination]
---------------------------------
+startapp <app_label> [destination]
+----------------------------------
 
 .. django-admin:: startapp
 
diff --git a/docs/ref/forms/api.txt b/docs/ref/forms/api.txt
index ef4da9479e..c8f302b924 100644
--- a/docs/ref/forms/api.txt
+++ b/docs/ref/forms/api.txt
@@ -205,6 +205,40 @@ precedence::
     <tr><th>Url:</th><td><input type="url" name="url" /></td></tr>
     <tr><th>Comment:</th><td><input type="text" name="comment" /></td></tr>
 
+Accessing the fields from the form
+----------------------------------
+
+.. attribute:: Form.fields
+
+You can access the fields of :class:`Form` instance from its ``fields``
+attribute::
+
+    >>> for row in f.fields.values(): print(row)
+    ...
+    <django.forms.fields.CharField object at 0x7ffaac632510>
+    <django.forms.fields.URLField object at 0x7ffaac632f90>
+    <django.forms.fields.CharField object at 0x7ffaac3aa050>
+    >>> f.fields['name']
+    <django.forms.fields.CharField object at 0x7ffaac6324d0>
+
+You can alter the field of :class:`Form` instance to change the way it is
+presented in the form::
+
+    >>> f.as_table().split('\n')[0]
+    '<tr><th>Name:</th><td><input name="name" type="text" value="instance" /></td></tr>'
+    >>> f.fields['name'].label = "Username"
+    >>> f.as_table().split('\n')[0]
+    '<tr><th>Username:</th><td><input name="name" type="text" value="instance" /></td></tr>'
+
+Beware not to alter the ``base_fields`` attribute because this modification
+will influence all subsequent ``ContactForm`` instances within the same Python
+process::
+
+    >>> f.base_fields['name'].label = "Username"
+    >>> another_f = CommentForm(auto_id=False)
+    >>> another_f.as_table().split('\n')[0]
+    '<tr><th>Username:</th><td><input name="name" type="text" value="class" /></td></tr>'
+
 Accessing "clean" data
 ----------------------
 
diff --git a/docs/ref/forms/fields.txt b/docs/ref/forms/fields.txt
index f2cd122526..62273fd38e 100644
--- a/docs/ref/forms/fields.txt
+++ b/docs/ref/forms/fields.txt
@@ -936,7 +936,7 @@ Slightly complex built-in ``Field`` classes
                                   required=False),
                     )
                     super(PhoneField, self).__init__(
-                        self, error_messages=error_messages, fields=fields,
+                        error_messages=error_messages, fields=fields,
                         require_all_fields=False, *args, **kwargs)
 
     .. attribute:: MultiValueField.widget
diff --git a/docs/ref/index.txt b/docs/ref/index.txt
index 1d71b62f41..6d7bfd4da4 100644
--- a/docs/ref/index.txt
+++ b/docs/ref/index.txt
@@ -5,6 +5,7 @@ API Reference
 .. toctree::
    :maxdepth: 1
 
+   applications
    class-based-views/index
    clickjacking
    contrib/index
diff --git a/docs/ref/models/options.txt b/docs/ref/models/options.txt
index c1bf34ba86..ba07dfaeb9 100644
--- a/docs/ref/models/options.txt
+++ b/docs/ref/models/options.txt
@@ -33,7 +33,7 @@ Available ``Meta`` options
     .. versionadded:: 1.7
 
         ``app_label`` is no longer required for models that are defined
-        in a ``models`` package within an app.
+        outside the ``models`` module of an application.
 
 ``db_table``
 ------------
@@ -81,7 +81,7 @@ Django quotes column and table names behind the scenes.
 
        db_table = '"name_left_in_lowercase"'
 
-   Such quoted names can also be used with Django's other supported database 
+   Such quoted names can also be used with Django's other supported database
    backends; except for Oracle, however, the quotes have no effect. See the
    :ref:`Oracle notes <oracle-notes>` for more details.
 
diff --git a/docs/ref/settings.txt b/docs/ref/settings.txt
index 3e625ace85..4181d152ef 100644
--- a/docs/ref/settings.txt
+++ b/docs/ref/settings.txt
@@ -1285,18 +1285,43 @@ INSTALLED_APPS
 
 Default: ``()`` (Empty tuple)
 
-A tuple of strings designating all applications that are enabled in this Django
-installation. Each string should be a full Python path to a Python package that
-contains a Django application, as created by :djadmin:`django-admin.py startapp
-<startapp>`.
+A tuple of strings designating all applications that are enabled in this
+Django installation. Each string should be a dotted Python path to:
 
-.. admonition:: App names must be unique
+* an application configuration class, or
+* a package containing a application.
 
-    The application names (that is, the final dotted part of the
-    path to the module containing ``models.py``) defined in
-    :setting:`INSTALLED_APPS` *must* be unique. For example, you can't
-    include both ``django.contrib.auth`` and ``myproject.auth`` in
-    INSTALLED_APPS.
+:doc:`Learn more about application configurations </ref/applications>`.
+
+.. versionchanged:: 1.7
+
+    :setting:`INSTALLED_APPS` now supports application configurations.
+
+.. admonition:: Use the application registry for introspection
+
+    Your code should never access :setting:`INSTALLED_APPS` directly. Use
+    :attr:`django.apps.apps` instead.
+
+.. admonition:: Application names and labels must be unique in
+                :setting:`INSTALLED_APPS`
+
+    Application :attr:`names <django.apps.AppConfig.name>` — the dotted Python
+    path to the application package — must be unique. There is no way to
+    include the same application twice, short of duplicating its code under
+    another name.
+
+    Application :attr:`labels <django.apps.AppConfig.label>` — by default the
+    final part of the name — must be unique too. For example, you can't
+    include both ``django.contrib.auth`` and ``myproject.auth``. However, you
+    can relabel an application with a custom configuration that defines a
+    different :attr:`~django.apps.AppConfig.label`.
+
+    These rules apply regardless of whether :setting:`INSTALLED_APPS`
+    references application configuration classes on application packages.
+
+When several applications provide different versions of the same resource
+(template, static file, management command, translation), the application
+listed first in :setting:`INSTALLED_APPS` has precedence.
 
 .. setting:: INTERNAL_IPS
 
@@ -2527,7 +2552,7 @@ Settings for :mod:`django.contrib.staticfiles`.
 STATIC_ROOT
 -----------
 
-Default: ``''`` (Empty string)
+Default: ``None``
 
 The absolute path to the directory where :djadmin:`collectstatic` will collect
 static files for deployment.
diff --git a/docs/ref/signals.txt b/docs/ref/signals.txt
index 1abfed8806..5c3d544c5a 100644
--- a/docs/ref/signals.txt
+++ b/docs/ref/signals.txt
@@ -354,6 +354,12 @@ Sent whenever a model class has been "prepared" -- that is, once model has
 been defined and registered with Django's model system. Django uses this
 signal internally; it's not generally used in third-party applications.
 
+Since this signal is sent during the app registry population process, and
+:meth:`AppConfig.ready() <django.apps.AppConfig.ready>` runs after the app
+registry is fully populated, receivers cannot be connected in that method.
+One possibility is to connect them ``AppConfig.__init__()`` instead, taking
+care not to import models or trigger calls to the app registry.
+
 Arguments that are sent with this signal:
 
 ``sender``
@@ -381,12 +387,10 @@ handlers are registered anywhere else they may not be loaded by
 Arguments sent with this signal:
 
 ``sender``
-    The ``models`` module of the app about to be migrated/synced.
-    For example, if :djadmin:`migrate` is about to install
-    an app called ``"foo.bar.myapp"``, ``sender`` will be the
-    ``foo.bar.myapp.models`` module.
+    An :class:`~django.apps.AppConfig` instance for the application about to
+    be migrated/synced.
 
-``app``
+``app_config``
     Same as ``sender``.
 
 ``verbosity``
@@ -415,14 +419,48 @@ pre_syncdb
 
 .. deprecated:: 1.7
 
-    This signal has been renamed to :data:`~django.db.models.signals.pre_migrate`.
+    This signal has been replaced by :data:`~django.db.models.signals.pre_migrate`.
 
-Alias of :data:`django.db.models.signals.pre_migrate`. As long as this alias
-is present, for backwards-compatibility this signal has an extra argument it sends:
+Sent by the :djadmin:`syncdb` command before it starts to install an
+application.
+
+Any handlers that listen to this signal need to be written in a particular
+place: a ``management`` module in one of your :setting:`INSTALLED_APPS`. If
+handlers are registered anywhere else they may not be loaded by
+:djadmin:`syncdb`.
+
+Arguments sent with this signal:
+
+``sender``
+    The ``models`` module that was just installed. That is, if
+    :djadmin:`syncdb` just installed an app called ``"foo.bar.myapp"``,
+    ``sender`` will be the ``foo.bar.myapp.models`` module.
+
+``app``
+    Same as ``sender``.
 
 ``create_models``
-    A list of the model classes from any app which :djadmin:`migrate` is
-    going to create, **only if the app has no migrations**.
+    A list of the model classes from any app which :djadmin:`syncdb` plans to
+    create.
+
+
+``verbosity``
+    Indicates how much information manage.py is printing on screen. See
+    the :djadminopt:`--verbosity` flag for details.
+
+    Functions which listen for :data:`pre_syncdb` should adjust what they
+    output to the screen based on the value of this argument.
+
+``interactive``
+    If ``interactive`` is ``True``, it's safe to prompt the user to input
+    things on the command line. If ``interactive`` is ``False``, functions
+    which listen for this signal should not try to prompt for anything.
+
+    For example, the :mod:`django.contrib.auth` app only prompts to create a
+    superuser when ``interactive`` is ``True``.
+
+``db``
+    The alias of database on which a command will operate.
 
 post_migrate
 ------------
@@ -444,11 +482,10 @@ idempotent changes (e.g. no database alterations) as this may cause the
 Arguments sent with this signal:
 
 ``sender``
-    The ``models`` module that was just installed. That is, if
-    :djadmin:`migrate` just installed an app called ``"foo.bar.myapp"``,
-    ``sender`` will be the ``foo.bar.myapp.models`` module.
+    An :class:`~django.apps.AppConfig` instance for the application that was
+    just installed.
 
-``app``
+``app_config``
     Same as ``sender``.
 
 ``verbosity``
@@ -489,14 +526,62 @@ post_syncdb
 
 .. deprecated:: 1.7
 
-    This signal has been renamed to :data:`~django.db.models.signals.post_migrate`.
+    This signal has been replaced by :data:`~django.db.models.signals.post_migrate`.
 
-Alias of :data:`django.db.models.signals.post_migrate`. As long as this alias
-is present, for backwards-compatibility this signal has an extra argument it sends:
+Sent by the :djadmin:`syncdb` command after it installs an application, and the
+:djadmin:`flush` command.
+
+Any handlers that listen to this signal need to be written in a particular
+place: a ``management`` module in one of your :setting:`INSTALLED_APPS`. If
+handlers are registered anywhere else they may not be loaded by
+:djadmin:`syncdb`. It is important that handlers of this signal perform
+idempotent changes (e.g. no database alterations) as this may cause the
+:djadmin:`flush` management command to fail if it also ran during the
+:djadmin:`syncdb` command.
+
+Arguments sent with this signal:
+
+``sender``
+    The ``models`` module that was just installed. That is, if
+    :djadmin:`syncdb` just installed an app called ``"foo.bar.myapp"``,
+    ``sender`` will be the ``foo.bar.myapp.models`` module.
+
+``app``
+    Same as ``sender``.
 
 ``created_models``
-    A list of the model classes from any app which :djadmin:`migrate` has
-    created, **only if the app has no migrations**.
+    A list of the model classes from any app which :djadmin:`syncdb` has
+    created so far.
+
+``verbosity``
+    Indicates how much information manage.py is printing on screen. See
+    the :djadminopt:`--verbosity` flag for details.
+
+    Functions which listen for :data:`post_syncdb` should adjust what they
+    output to the screen based on the value of this argument.
+
+``interactive``
+    If ``interactive`` is ``True``, it's safe to prompt the user to input
+    things on the command line. If ``interactive`` is ``False``, functions
+    which listen for this signal should not try to prompt for anything.
+
+    For example, the :mod:`django.contrib.auth` app only prompts to create a
+    superuser when ``interactive`` is ``True``.
+
+``db``
+    The database alias used for synchronization. Defaults to the ``default``
+    database.
+
+For example, ``yourapp/management/__init__.py`` could be written like::
+
+    from django.db.models.signals import post_syncdb
+    import yourapp.models
+
+    def my_callback(sender, **kwargs):
+        # Your specific logic here
+        pass
+
+    post_syncdb.connect(my_callback, sender=yourapp.models)
 
 Request/response signals
 ========================
diff --git a/docs/ref/validators.txt b/docs/ref/validators.txt
index 92e257ca85..1b706ab8e3 100644
--- a/docs/ref/validators.txt
+++ b/docs/ref/validators.txt
@@ -87,10 +87,24 @@ to, or in lieu of custom ``field.clean()`` methods.
 
 ``URLValidator``
 ----------------
-.. class:: URLValidator()
+.. class:: URLValidator([schemes=None, regex=None, message=None, code=None])
 
     A :class:`RegexValidator` that ensures a value looks like a URL, and raises
-    an error code of ``'invalid'`` if it doesn't.
+    an error code of ``'invalid'`` if it doesn't. In addition to the optional
+    arguments of its parent :class:`RegexValidator` class, ``URLValidator``
+    accepts an extra optional attribute:
+
+    .. attribute:: schemes
+
+        URL/URI scheme list to validate against. If not provided, the default
+        list is ``['http', 'https', 'ftp', 'ftps']``. As a reference, the IANA
+        Web site provides a full list of `valid URI schemes`_.
+
+        .. _valid URI schemes: https://www.iana.org/assignments/uri-schemes/uri-schemes.xhtml
+
+    .. versionchanged:: 1.7
+
+        The optional ``schemes`` attribute was added.
 
 ``validate_email``
 ------------------
diff --git a/docs/releases/1.6.2.txt b/docs/releases/1.6.2.txt
index cae18b86fa..6043d21815 100644
--- a/docs/releases/1.6.2.txt
+++ b/docs/releases/1.6.2.txt
@@ -9,4 +9,13 @@ This is Django 1.6.2, a bugfix release for Django 1.6.
 Bug fixes
 =========
 
-...
+* Prevented the base geometry object of a prepared geometry to be garbage
+  collected, which could lead to crash Django (#21662).
+
+* Fixed a crash when executing the :djadmin:`changepassword` command when the
+  user object representation contained non-ASCII characters (#21627).
+
+* The :djadmin:`collectstatic` command will raise an error rather than
+  default to using the current working directory if :setting:`STATIC_ROOT` is
+  not set. Combined with the ``--clear`` option, the previous behavior could
+  wipe anything below the current working directory.
diff --git a/docs/releases/1.7.txt b/docs/releases/1.7.txt
index 3a1568fe45..9fcad38931 100644
--- a/docs/releases/1.7.txt
+++ b/docs/releases/1.7.txt
@@ -47,17 +47,52 @@ but a few of the key features are:
 * A new ``makemigrations`` command provides an easy way to autodetect changes
   to your models and make migrations for them.
 
-* :data:`~django.db.models.signals.pre_syncdb` and
-  :data:`~django.db.models.signals.post_syncdb` have been renamed to
+  :data:`~django.db.models.signals.pre_syncdb` and
+  :data:`~django.db.models.signals.post_syncdb` have been replaced by
   :data:`~django.db.models.signals.pre_migrate` and
-  :data:`~django.db.models.signals.post_migrate` respectively. The
-  ``create_models``/``created_models`` argument has also been deprecated.
+  :data:`~django.db.models.signals.post_migrate` respectively. These new
+  signals have slightly different arguments. Check the documentation for
+  details.
 
 * The ``allow_syncdb`` method on database routers is now called ``allow_migrate``,
   but still performs the same function. Routers with ``allow_syncdb`` methods
   will still work, but that method name is deprecated and you should change
   it as soon as possible (nothing more than renaming is required).
 
+App-loading refactor
+~~~~~~~~~~~~~~~~~~~~
+
+Historically, Django applications were tightly linked to models. A singleton
+known as the "app cache" dealt with both installed applications and models.
+The models module was used as an identifier for applications in many APIs.
+
+As the concept of :doc:`Django applications </ref/applications>` matured, this
+code showed some shortcomings. It has been refactored into an "app registry"
+where models modules no longer have a central role and where it's possible to
+attach configuration data to applications.
+
+Improvements thus far include:
+
+* Applications can run code at startup, before Django does anything else, with
+  the :meth:`~django.apps.AppConfig.ready` method of their configuration.
+
+* Application labels are assigned correctly to models even when they're
+  defined outside of ``models.py``. You don't have to set
+  :attr:`~django.db.models.Options.app_label` explicitly any more.
+
+* It is possible to omit ``models.py`` entirely if an application doesn't
+  have any models.
+
+* Applications can be relabeled with the :attr:`~django.apps.AppConfig.label`
+  attribute of application configurations, to work around label conflicts.
+
+* The name of applications can be customized in the admin with the
+  :attr:`~django.apps.AppConfig.verbose_name` of application configurations.
+
+* Django imports all application configurations and models as soon as it
+  starts, through a deterministic and straightforward process. This should
+  make it easier to diagnose import issues such as import loops.
+
 New method on Field subclasses
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -211,6 +246,10 @@ Minor features
 * The default OpenLayers library version included in widgets has been updated
   from 2.11 to 2.13.
 
+* Prepared geometries now also support the ``crosses``, ``disjoint``,
+  ``overlaps``, ``touches`` and ``within`` predicates, if GEOS 3.3 or later is
+  installed.
+
 :mod:`django.contrib.messages`
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
@@ -431,9 +470,6 @@ Models
   ``Meta`` option allows you to customize (or disable) creation of the default
   add, change, and delete permissions.
 
-* :attr:`~django.db.models.Options.app_label` is no longer required for models
-  that are defined in a ``models`` package within an app.
-
 * Explicit :class:`~django.db.models.OneToOneField` for
   :ref:`multi-table-inheritance` are now discovered in abstract classes.
 
@@ -543,6 +579,16 @@ Tests
 * :meth:`~django.test.TransactionTestCase.assertNumQueries` now prints
   out the list of executed queries if the assertion fails.
 
+* The ``WSGIRequest`` instance generated by the test handler is now attached to
+  the :attr:`django.test.Response.wsgi_request` attribute.
+
+Validators
+^^^^^^^^^^
+
+* :class:`~django.core.validators.URLValidator` now accepts an optional
+  ``schemes`` argument which allows customization of the accepted URI schemes
+  (instead of the defaults ``http(s)`` and ``ftp(s)``).
+
 Backwards incompatible changes in 1.7
 =====================================
 
@@ -566,6 +612,122 @@ For apps with migrations, ``allow_migrate`` will now get passed
 without custom attributes, methods or managers. Make sure your ``allow_migrate``
 methods are only referring to fields or other items in ``model._meta``.
 
+App-loading changes
+~~~~~~~~~~~~~~~~~~~
+
+Start-up sequence
+^^^^^^^^^^^^^^^^^
+
+Django 1.7 loads application configurations and models as soon as it starts.
+While this behavior is more straightforward and is believed to be more robust,
+regressions cannot be ruled out. You may encounter the following exceptions:
+
+* ``RuntimeError: App registry isn't ready yet.`` This happens when importing
+  an application configuration or a models module triggers code that depends
+  on the app registry.
+
+  For example, :func:`~django.utils.translation.ugettext()` uses the app
+  registry to look up translation catalogs in applications. To translate at
+  import time, you need :func:`~django.utils.translation.ugettext_lazy()`
+  instead. (Using :func:`~django.utils.translation.ugettext()` would be a bug,
+  because the translation would happen at import time, rather than at each
+  request depending on the active language.)
+
+  Executing database queries with the ORM at import time in models modules
+  will also trigger this exception. The ORM cannot function properly until all
+  models are available.
+
+* ``ImportError: cannot import name ...`` This happens if the import sequence
+  ends up in a loop.
+
+  To eliminate such problems, you should minimize dependencies between your
+  models modules and do as little work as possible at import time. To avoid
+  executing code at import time, you can move it into a function and cache its
+  results. The code will be executed when you first need its results. This
+  concept is known as "lazy evaluation".
+
+Standalone scripts
+^^^^^^^^^^^^^^^^^^
+
+If you're using Django in a plain Python script — rather than a management
+command — and you rely on the :envvar:`DJANGO_SETTINGS_MODULE` environment
+variable, you must now explicitly initialize Django at the beginning of your
+script with::
+
+    >>> import django
+    >>> django.setup()
+
+Otherwise, you will hit ``RuntimeError: App registry isn't ready yet.``
+
+App registry consistency
+^^^^^^^^^^^^^^^^^^^^^^^^
+
+It is no longer possible to have multiple installed applications with the same
+label. In previous versions of Django, this didn't always work correctly, but
+didn't crash outright either.
+
+If you have two apps with the same label, you should create an
+:class:`~django.apps.AppConfig` for one of them and override its
+:class:`~django.apps.AppConfig.label` there. You should then adjust your code
+wherever it references this application or its models with the old label.
+
+It isn't possible to import the same model twice through different paths any
+more. As of Django 1.6, this may happen only if you're manually putting a
+directory and a subdirectory on :envvar:`PYTHONPATH`. Refer to the section on
+the new project layout in the :doc:`1.4 release notes </releases/1.4>` for
+migration instructions.
+
+You should make sure that:
+
+* All models are defined in applications that are listed in
+  :setting:`INSTALLED_APPS` or have an explicit
+  :attr:`~django.db.models.Options.app_label`.
+
+* Models aren't imported as a side-effect of loading their application.
+  Specifically, you shouldn't import models in the root module of an
+  application nor in the module that define its configuration class.
+
+Django will enforce these requirements as of version 1.9, after a deprecation
+period.
+
+Subclassing AppCommand
+^^^^^^^^^^^^^^^^^^^^^^
+
+Subclasses of :class:`~django.core.management.AppCommand` must now implement a
+:meth:`~django.core.management.AppCommand.handle_app_config` method instead of
+``handle_app()``. This method receives an :class:`~django.apps.AppConfig`
+instance instead of a models module.
+
+Introspecting applications
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Since :setting:`INSTALLED_APPS` now supports application configuration classes
+in addition to application modules, you should review code that accesses this
+setting directly and use the app registry (:attr:`django.apps.apps`) instead.
+
+The app registry has preserved some features of the old app cache. Even though
+the app cache was a private API, obsolete methods and arguments will be
+removed through a standard deprecation path, with the exception of the
+following changes that take effect immediately:
+
+* ``get_model`` raises :exc:`~exceptions.LookupError` instead of returning
+  ``None`` when no model is found.
+
+* The ``only_installed`` argument of ``get_model`` and ``get_models`` no
+  longer exists, nor does the ``seed_cache`` argument of ``get_model``.
+
+Management commands and order of :setting:`INSTALLED_APPS`
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+When several applications provide management commands with the same name,
+Django loads the command from the application that comes first in
+:setting:`INSTALLED_APPS`. Previous versions loaded the command from the
+application that came last.
+
+This brings discovery of management commands in line with other parts of
+Django that rely on the order of :setting:`INSTALLED_APPS`, such as static
+files, templates, and translations.
+
 Behavior of ``LocMemCache`` regarding pickle errors
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -578,6 +740,19 @@ cache-specific errors. This has been fixed in Django 1.7, see
 
 .. _Ticket #21200: https://code.djangoproject.com/ticket/21200
 
+Cache keys are now generated from the request's absolute URL
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Previous versions of Django generated cache keys using a request's path and
+query string but not the scheme or host. If a Django application was serving
+multiple subdomains or domains, cache keys could collide. In Django 1.7, cache
+keys vary by the absolute URL of the request including scheme, host, path, and
+query string. For example, the URL portion of a cache key is now generated from
+``http://www.example.com/path/to/?key=val`` rather than ``/path/to/?key=val``.
+The cache keys generated by Django 1.7 will be different from the keys
+generated by older versions of Django. After upgrading to Django 1.7, the first
+request to any previously cached URL will be a cache miss .
+
 Passing ``None`` to ``Manager.db_manager()``
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -722,6 +897,8 @@ Miscellaneous
   ``select_related('foo').select_related('bar')``. Previously the latter would
   have been equivalent to ``select_related('bar')``.
 
+* GeoDjango dropped support for GEOS < 3.1.
+
 Features deprecated in 1.7
 ==========================
 
diff --git a/docs/topics/auth/customizing.txt b/docs/topics/auth/customizing.txt
index 7b15a2f8d3..bdb5b19894 100644
--- a/docs/topics/auth/customizing.txt
+++ b/docs/topics/auth/customizing.txt
@@ -477,7 +477,7 @@ password resets. You must then provide some key implementation details:
         as the identifying field::
 
             class MyUser(AbstractBaseUser):
-                identifier = models.CharField(max_length=40, unique=True, db_index=True)
+                identifier = models.CharField(max_length=40, unique=True)
                 ...
                 USERNAME_FIELD = 'identifier'
 
@@ -965,7 +965,6 @@ authentication app::
             verbose_name='email address',
             max_length=255,
             unique=True,
-            db_index=True,
         )
         date_of_birth = models.DateField()
         is_active = models.BooleanField(default=True)
diff --git a/docs/topics/cache.txt b/docs/topics/cache.txt
index 7ef7285fb7..37e94957db 100644
--- a/docs/topics/cache.txt
+++ b/docs/topics/cache.txt
@@ -1046,13 +1046,19 @@ the contents of a Web page depend on a user's language preference, the page is
 said to "vary on language."
 
 By default, Django's cache system creates its cache keys using the requested
-path and query -- e.g., ``"/stories/2005/?order_by=author"``. This means every
+fully-qualified URL -- e.g.,
+``"http://www.example.com/stories/2005/?order_by=author"``. This means every
 request to that URL will use the same cached version, regardless of user-agent
 differences such as cookies or language preferences. However, if this page
 produces different content based on some difference in request headers -- such
 as a cookie, or a language, or a user-agent -- you'll need to use the ``Vary``
 header to tell caching mechanisms that the page output depends on those things.
 
+.. versionchanged:: 1.7
+
+    Cache keys use the request's fully-qualified URL rather than just the path
+    and query string.
+
 To do this in Django, use the convenient
 :func:`django.views.decorators.vary.vary_on_headers` view decorator, like so::
 
diff --git a/docs/topics/db/sql.txt b/docs/topics/db/sql.txt
index 1369ed84f5..1b806ca42f 100644
--- a/docs/topics/db/sql.txt
+++ b/docs/topics/db/sql.txt
@@ -23,11 +23,11 @@ return model instances:
 
 .. method:: Manager.raw(raw_query, params=None, translations=None)
 
-This method method takes a raw SQL query, executes it, and returns a
+This method takes a raw SQL query, executes it, and returns a
 ``django.db.models.query.RawQuerySet`` instance. This ``RawQuerySet`` instance
-can be iterated over just like an normal QuerySet to provide object instances.
+can be iterated over just like a normal QuerySet to provide object instances.
 
-This is best illustrated with an example. Suppose you've got the following model::
+This is best illustrated with an example. Suppose you have the following model::
 
     class Person(models.Model):
         first_name = models.CharField(...)
@@ -108,7 +108,7 @@ write::
     >>> first_person = Person.objects.raw('SELECT * from myapp_person')[0]
 
 However, the indexing and slicing are not performed at the database level. If
-you have a big amount of ``Person`` objects in your database, it is more
+you have a large number of ``Person`` objects in your database, it is more
 efficient to limit the query at the SQL level::
 
     >>> first_person = Person.objects.raw('SELECT * from myapp_person LIMIT 1')[0]
@@ -323,4 +323,4 @@ is equivalent to:
     try:
         c.execute(...)
     finally:
-        c.close()
\ No newline at end of file
+        c.close()
diff --git a/docs/topics/email.txt b/docs/topics/email.txt
index 058a007721..6b93d7d2b8 100644
--- a/docs/topics/email.txt
+++ b/docs/topics/email.txt
@@ -629,6 +629,5 @@ the email body. You then only need to set the :setting:`EMAIL_HOST` and
 :setting:`EMAIL_PORT` accordingly. For a more detailed discussion of SMTP
 server options, see the Python documentation for the :mod:`smtpd` module.
 
-For information about unit-testing the sending of emails in your
-application, see the :ref:`topics-testing-email` section of :doc:`Testing
-Django applications </topics/testing/overview>`.
+For information about unit-testing the sending of emails in your application,
+see the :ref:`topics-testing-email` section of the testing documentation.
diff --git a/docs/topics/http/sessions.txt b/docs/topics/http/sessions.txt
index f7e8807945..2cf4751212 100644
--- a/docs/topics/http/sessions.txt
+++ b/docs/topics/http/sessions.txt
@@ -655,8 +655,8 @@ Session security
 ================
 
 Subdomains within a site are able to set cookies on the client for the whole
-domain. This makes session fixation possible if all subdomains are not
-controlled by trusted users (or, are at least unable to set cookies).
+domain. This makes session fixation possible if cookies are permitted from
+subdomains not controlled by trusted users.
 
 For example, an attacker could log into ``good.example.com`` and get a valid
 session for their account. If the attacker has control over ``bad.example.com``,
diff --git a/docs/topics/http/urls.txt b/docs/topics/http/urls.txt
index d72d1a26e6..36a43ed704 100644
--- a/docs/topics/http/urls.txt
+++ b/docs/topics/http/urls.txt
@@ -178,8 +178,8 @@ The URLconf doesn't look at the request method. In other words, all request
 methods -- ``POST``, ``GET``, ``HEAD``, etc. -- will be routed to the same
 function for the same URL.
 
-Notes on capturing text in URLs
-===============================
+Captured arguments are always strings
+=====================================
 
 Each captured argument is sent to the view as a plain Python string, regardless
 of what sort of match the regular expression makes. For example, in this
@@ -190,6 +190,9 @@ URLconf line::
 ...the ``year`` argument to ``news.views.year_archive()`` will be a string, not
 an integer, even though the ``\d{4}`` will only match integer strings.
 
+Specifying defaults for view arguments
+======================================
+
 A convenient trick is to specify default parameters for your views' arguments.
 Here's an example URLconf and view::
 
@@ -866,7 +869,7 @@ For example::
         url(r'^advanced/$', 'apps.help.views.views.advanced'),
     )
 
-    url(r'^help/', include(help_patterns, 'bar', 'foo')),
+    url(r'^help/', include((help_patterns, 'bar', 'foo'))),
 
 This will include the nominated URL patterns into the given application and
 instance namespace.
@@ -877,3 +880,8 @@ attribute: A 3-tuple that contains all the patterns in the corresponding admin
 site, plus the application namespace ``'admin'``, and the name of the admin
 instance. It is this ``urls`` attribute that you ``include()`` into your
 projects ``urlpatterns`` when you deploy an Admin instance.
+
+Be sure to pass a tuple to ``include()``. If you simply pass three arguments:
+``include(help_patterns, 'bar', 'foo')``, Django won't throw an error but due
+to the signature of ``include()``, ``'bar'`` will be the instance namespace and
+``'foo'`` will be the application namespace instead of vice versa.
diff --git a/docs/topics/i18n/timezones.txt b/docs/topics/i18n/timezones.txt
index 5e3a482154..839813a823 100644
--- a/docs/topics/i18n/timezones.txt
+++ b/docs/topics/i18n/timezones.txt
@@ -649,6 +649,12 @@ Troubleshooting
        >>> local.date()
        datetime.date(2012, 3, 3)
 
+4. **I get an error** "``Are time zone definitions for your database and pytz
+   installed?``" **pytz is installed, so I guess the problem is my database?**
+
+   If you are using MySQL, see the :ref:`mysql-time-zone-definitions` section
+   of the MySQL notes for instructions on loading time zone definitions.
+
 Usage
 -----
 
diff --git a/docs/topics/i18n/translation.txt b/docs/topics/i18n/translation.txt
index cc4c24d364..f3f871617b 100644
--- a/docs/topics/i18n/translation.txt
+++ b/docs/topics/i18n/translation.txt
@@ -206,7 +206,9 @@ For example::
 In this example the number of objects is passed to the translation
 languages as the ``count`` variable.
 
-Lets see a slightly more complex usage example::
+Note that pluralization is complicated and works differently in each language.
+Comparing ``count`` to 1 isn't always the correct rule. This code looks
+sophisticated, but will produce incorrect results for some languages::
 
     from django.utils.translation import ungettext
     from myapp.models import Report
@@ -218,42 +220,45 @@ Lets see a slightly more complex usage example::
         name = Report._meta.verbose_name_plural
 
     text = ungettext(
-            'There is %(count)d %(name)s available.',
-            'There are %(count)d %(name)s available.',
-            count
+        'There is %(count)d %(name)s available.',
+        'There are %(count)d %(name)s available.',
+        count
     ) % {
         'count': count,
         'name': name
     }
 
-Here we reuse localizable, hopefully already translated literals (contained in
-the ``verbose_name`` and ``verbose_name_plural`` model ``Meta`` options) for
-other parts of the sentence so all of it is consistently based on the
-cardinality of the elements at play.
+Don't try to implement your own singular-or-plural logic, it won't be correct.
+In a case like this, consider something like the following::
+
+    text = ungettext(
+        'There is %(count)d %(name)s object available.',
+        'There are %(count)d %(name)s objects available.',
+        count
+    ) % {
+        'count': count,
+        'name': Report._meta.verbose_name,
+    }
 
 .. _pluralization-var-notes:
 
 .. note::
 
-    When using this technique, make sure you use a single name for every
-    extrapolated variable included in the literal. In the example above note how
-    we used the ``name`` Python variable in both translation strings. This
-    example would fail::
+    When using ``ungettext()``, make sure you use a single name for every
+    extrapolated variable included in the literal. In the examples above, note
+    how we used the ``name`` Python variable in both translation strings. This
+    example, besides being incorrect in some languages as noted above, would
+    fail::
 
-        from django.utils.translation import ungettext
-        from myapp.models import Report
-
-        count = Report.objects.count()
-        d = {
-            'count': count,
+        text = ungettext(
+            'There is %(count)d %(name)s available.',
+            'There are %(count)d %(plural_name)s available.',
+            count
+        ) % {
+            'count': Report.objects.count(),
             'name': Report._meta.verbose_name,
             'plural_name': Report._meta.verbose_name_plural
         }
-        text = ungettext(
-                'There is %(count)d %(name)s available.',
-                'There are %(count)d %(plural_name)s available.',
-                count
-        ) % d
 
     You would get an error when running :djadmin:`django-admin.py
     compilemessages <compilemessages>`::
diff --git a/docs/topics/install.txt b/docs/topics/install.txt
index d14f40a7bb..c410f86831 100644
--- a/docs/topics/install.txt
+++ b/docs/topics/install.txt
@@ -10,8 +10,8 @@ Install Python
 Being a Python Web framework, Django requires Python. It works with Python 2.7,
 3.2 or 3.3.
 
-Get Python at http://www.python.org. If you're running Linux or Mac OS X, you
-probably already have it installed.
+Get the latest version of Python at http://www.python.org/download/ or with
+your operating system's package manager.
 
 .. admonition:: Django on Jython
 
diff --git a/docs/topics/logging.txt b/docs/topics/logging.txt
index 15c1aa9dd8..751563e4b9 100644
--- a/docs/topics/logging.txt
+++ b/docs/topics/logging.txt
@@ -222,21 +222,46 @@ set to ``True`` (which is the default) the default configuration is completely
 overridden. Alternatively you can redefine some or all of the loggers by
 setting ``disable_existing_loggers`` to ``False``.
 
-Logging is configured as soon as settings have been loaded
-(either manually using :func:`~django.conf.settings.configure` or when at least
-one setting is accessed). Since the loading of settings is one of the first
-things that Django does, you can be certain that loggers are always ready for
-use in your project code.
+Logging is configured as part of the general Django ``setup()`` function.
+Therefore, you can be certain that loggers are always ready for use in your
+project code.
 
 .. _dictConfig format: http://docs.python.org/library/logging.config.html#configuration-dictionary-schema
 
-An example
-----------
+Examples
+--------
 
 The full documentation for `dictConfig format`_ is the best source of
 information about logging configuration dictionaries. However, to give
-you a taste of what is possible, here is an example of a fairly
-complex logging setup, configured using :func:`logging.config.dictConfig`::
+you a taste of what is possible, here are a couple examples.
+
+First, here's a simple configuration which writes all request logging from the
+:ref:`django-request-logger` logger to a local file::
+
+    LOGGING = {
+        'version': 1,
+        'disable_existing_loggers': False,
+        'handlers': {
+            'file': {
+                'level': 'DEBUG',
+                'class': 'logging.FileHandler',
+                'filename': '/path/to/django/debug.log',
+            },
+        },
+        'loggers': {
+            'django.request': {
+                'handlers': ['file'],
+                'level': 'DEBUG',
+                'propagate': True,
+            },
+        },
+    }
+
+If you use this example, be sure to change the ``'filename'`` path to a
+location that's writable by the user that's running the Django application.
+
+Second, here's an example of a fairly complex logging setup, configured using
+:func:`logging.config.dictConfig`::
 
     LOGGING = {
         'version': 1,
@@ -396,6 +421,8 @@ Django provides four built-in loggers.
 ``django`` is the catch-all logger. No messages are posted directly to
 this logger.
 
+.. _django-request-logger:
+
 ``django.request``
 ~~~~~~~~~~~~~~~~~~
 
@@ -414,9 +441,9 @@ Messages to this logger have the following extra context:
 ``django.db.backends``
 ~~~~~~~~~~~~~~~~~~~~~~
 
-Messages relating to the interaction of code with the database.
-For example, every SQL statement executed by a request is logged
-at the ``DEBUG`` level to this logger.
+Messages relating to the interaction of code with the database. For example,
+every application-level SQL statement executed by a request is logged at the
+``DEBUG`` level to this logger.
 
 Messages to this logger have the following extra context:
 
@@ -428,6 +455,11 @@ For performance reasons, SQL logging is only enabled when
 ``settings.DEBUG`` is set to ``True``, regardless of the logging
 level or handlers that are installed.
 
+This logging does not include framework-level initialization (e.g.
+``SET TIMEZONE``) or transaction management queries (e.g. ``BEGIN``,
+``COMMIT``, and ``ROLLBACK``). Turn on query logging in your database if you
+wish the view all database queries.
+
 ``django.security.*``
 ~~~~~~~~~~~~~~~~~~~~~~
 
diff --git a/docs/topics/migrations.txt b/docs/topics/migrations.txt
index ead5ecffdb..6621c4e959 100644
--- a/docs/topics/migrations.txt
+++ b/docs/topics/migrations.txt
@@ -264,7 +264,7 @@ If your app already has models and database tables, and doesn't have migrations
 yet (for example, you created it against a previous Django version), you'll
 need to convert it to use migrations; this is a simple process::
 
-    $ python manage.py makemigrations yourappname
+    $ python manage.py makemigrations your_app_label
 
 This will make a new initial migration for your app. Now, when you run
 :djadmin:`migrate`, Django will detect that you have an initial migration
diff --git a/docs/topics/signals.txt b/docs/topics/signals.txt
index 587590096c..ee6fb847a2 100644
--- a/docs/topics/signals.txt
+++ b/docs/topics/signals.txt
@@ -48,8 +48,7 @@ Listening to signals
 ====================
 
 To receive a signal, you need to register a *receiver* function that gets
-called when the signal is sent by using the
-:meth:`.Signal.connect` method:
+called when the signal is sent by using the :meth:`Signal.connect` method:
 
 .. method:: Signal.connect(receiver, [sender=None, weak=True, dispatch_uid=None])
 
@@ -115,8 +114,13 @@ manual connect route:
 
     request_finished.connect(my_callback)
 
-Alternatively, you can use a ``receiver`` decorator when you define your
-receiver:
+Alternatively, you can use a :func:`receiver` decorator:
+
+.. function:: receiver(signal)
+
+    :param signal: A signal or a list of signals to connect a function to.
+
+Here's how you connect with the decorator:
 
 .. code-block:: python
 
@@ -129,16 +133,25 @@ receiver:
 
 Now, our ``my_callback`` function will be called each time a request finishes.
 
-Note that ``receiver`` can also take a list of signals to connect a function
-to.
 
 .. admonition:: Where should this code live?
 
-    You can put signal handling and registration code anywhere you like.
-    However, you'll need to make sure that the module it's in gets imported
-    early on so that the signal handling gets registered before any signals need
-    to be sent. This makes your app's ``models.py`` a good place to put
-    registration of signal handlers.
+    Strictly speaking, signal handling and registration code can live anywhere
+    you like, although it's recommended to avoid the application's root module
+    and its ``models`` module to minimize side-effects of importing code.
+
+    In practice, signal handlers are usually defined in a ``signals``
+    submodule of the application they relate to. Signal receivers are
+    connected in the :meth:`~django.apps.AppConfig.ready` method of your
+    application configuration class. If you're using the :func:`receiver`
+    decorator, simply import the ``signals`` submodule inside
+    :meth:`~django.apps.AppConfig.ready`.
+
+    .. versionchanged:: 1.7
+
+        Since :meth:`~django.apps.AppConfig.ready` didn't exist in previous
+        versions of Django, signal registration usually happened in the
+        ``models`` module.
 
 .. _connecting-to-specific-signals:
 
@@ -178,10 +191,9 @@ particular signal.
 Preventing duplicate signals
 ----------------------------
 
-In some circumstances, the module in which you are connecting signals may be
-imported multiple times. This can cause your receiver function to be
-registered more than once, and thus called multiples times for a single signal
-event.
+In some circumstances, the code connecting receivers to signals may run
+multiple times. This can cause your receiver function to be registered more
+than once, and thus called multiples times for a single signal event.
 
 If this behavior is problematic (such as when using signals to
 send an email whenever a model is saved), pass a unique identifier as
diff --git a/docs/topics/testing/index.txt b/docs/topics/testing/index.txt
index 1a99a399b4..e8cab96277 100644
--- a/docs/topics/testing/index.txt
+++ b/docs/topics/testing/index.txt
@@ -2,12 +2,6 @@
 Testing in Django
 =================
 
-.. toctree::
-   :hidden:
-
-   overview
-   advanced
-
 Automated testing is an extremely useful bug-killing tool for the modern
 Web developer. You can use a collection of tests -- a **test suite** -- to
 solve, or avoid, a number of problems:
@@ -28,9 +22,6 @@ it should be doing.
 
 The best part is, it's really easy.
 
-Where to go from here
-=====================
-
 The preferred way to write tests in Django is using the :mod:`unittest` module
 built in to the Python standard library. This is covered in detail in the
 :doc:`overview` document.
@@ -38,3 +29,10 @@ built in to the Python standard library. This is covered in detail in the
 You can also use any *other* Python test framework; Django provides an API and
 tools for that kind of integration. They are described in the
 :ref:`other-testing-frameworks` section of :doc:`advanced`.
+
+.. toctree::
+   :maxdepth: 1
+
+   overview
+   tools
+   advanced
diff --git a/docs/topics/testing/overview.txt b/docs/topics/testing/overview.txt
index f8464638c2..078c2a1da9 100644
--- a/docs/topics/testing/overview.txt
+++ b/docs/topics/testing/overview.txt
@@ -1,14 +1,15 @@
-===========================
-Testing Django applications
-===========================
+=========================
+Writing and running tests
+=========================
 
 .. module:: django.test
    :synopsis: Testing tools for Django applications.
 
 .. seealso::
 
-    The :doc:`testing tutorial </intro/tutorial05>` and the
-    :doc:`advanced testing topics </topics/testing/advanced>`.
+    The :doc:`testing tutorial </intro/tutorial05>`, the :doc:`testing tools
+    reference </topics/testing/tools>`, and the :doc:`advanced testing topics
+    </topics/testing/advanced>`.
 
 This document is split into two primary sections. First, we explain how to write
 tests with Django. Then, we explain how to run them.
@@ -302,1535 +303,3 @@ to a faster hashing algorithm::
 
 Don't forget to also include in :setting:`PASSWORD_HASHERS` any hashing
 algorithm used in fixtures, if any.
-
-Testing tools
-=============
-
-Django provides a small set of tools that come in handy when writing tests.
-
-.. _test-client:
-
-The test client
----------------
-
-The test client is a Python class that acts as a dummy Web browser, allowing
-you to test your views and interact with your Django-powered application
-programmatically.
-
-Some of the things you can do with the test client are:
-
-* Simulate GET and POST requests on a URL and observe the response --
-  everything from low-level HTTP (result headers and status codes) to
-  page content.
-
-* See the chain of redirects (if any) and check the URL and status code at
-  each step.
-
-* Test that a given request is rendered by a given Django template, with
-  a template context that contains certain values.
-
-Note that the test client is not intended to be a replacement for Selenium_ or
-other "in-browser" frameworks. Django's test client has a different focus. In
-short:
-
-* Use Django's test client to establish that the correct template is being
-  rendered and that the template is passed the correct context data.
-
-* Use in-browser frameworks like Selenium_ to test *rendered* HTML and the
-  *behavior* of Web pages, namely JavaScript functionality. Django also
-  provides special support for those frameworks; see the section on
-  :class:`~django.test.LiveServerTestCase` for more details.
-
-A comprehensive test suite should use a combination of both test types.
-
-Overview and a quick example
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-To use the test client, instantiate ``django.test.Client`` and retrieve
-Web pages::
-
-    >>> from django.test import Client
-    >>> c = Client()
-    >>> response = c.post('/login/', {'username': 'john', 'password': 'smith'})
-    >>> response.status_code
-    200
-    >>> response = c.get('/customer/details/')
-    >>> response.content
-    '<!DOCTYPE html...'
-
-As this example suggests, you can instantiate ``Client`` from within a session
-of the Python interactive interpreter.
-
-Note a few important things about how the test client works:
-
-* The test client does *not* require the Web server to be running. In fact,
-  it will run just fine with no Web server running at all! That's because
-  it avoids the overhead of HTTP and deals directly with the Django
-  framework. This helps make the unit tests run quickly.
-
-* When retrieving pages, remember to specify the *path* of the URL, not the
-  whole domain. For example, this is correct::
-
-      >>> c.get('/login/')
-
-  This is incorrect::
-
-      >>> c.get('http://www.example.com/login/')
-
-  The test client is not capable of retrieving Web pages that are not
-  powered by your Django project. If you need to retrieve other Web pages,
-  use a Python standard library module such as :mod:`urllib` or
-  :mod:`urllib2`.
-
-* To resolve URLs, the test client uses whatever URLconf is pointed-to by
-  your :setting:`ROOT_URLCONF` setting.
-
-* Although the above example would work in the Python interactive
-  interpreter, some of the test client's functionality, notably the
-  template-related functionality, is only available *while tests are
-  running*.
-
-  The reason for this is that Django's test runner performs a bit of black
-  magic in order to determine which template was loaded by a given view.
-  This black magic (essentially a patching of Django's template system in
-  memory) only happens during test running.
-
-* By default, the test client will disable any CSRF checks
-  performed by your site.
-
-  If, for some reason, you *want* the test client to perform CSRF
-  checks, you can create an instance of the test client that
-  enforces CSRF checks. To do this, pass in the
-  ``enforce_csrf_checks`` argument when you construct your
-  client::
-
-      >>> from django.test import Client
-      >>> csrf_client = Client(enforce_csrf_checks=True)
-
-Making requests
-~~~~~~~~~~~~~~~
-
-Use the ``django.test.Client`` class to make requests.
-
-.. class:: Client(enforce_csrf_checks=False, **defaults)
-
-    It requires no arguments at time of construction. However, you can use
-    keywords arguments to specify some default headers. For example, this will
-    send a ``User-Agent`` HTTP header in each request::
-
-        >>> c = Client(HTTP_USER_AGENT='Mozilla/5.0')
-
-    The values from the ``extra`` keywords arguments passed to
-    :meth:`~django.test.Client.get()`,
-    :meth:`~django.test.Client.post()`, etc. have precedence over
-    the defaults passed to the class constructor.
-
-    The ``enforce_csrf_checks`` argument can be used to test CSRF
-    protection (see above).
-
-    Once you have a ``Client`` instance, you can call any of the following
-    methods:
-
-    .. method:: Client.get(path, data={}, follow=False, secure=False, **extra)
-
-        .. versionadded:: 1.7
-
-            The ``secure`` argument was added.
-
-        Makes a GET request on the provided ``path`` and returns a ``Response``
-        object, which is documented below.
-
-        The key-value pairs in the ``data`` dictionary are used to create a GET
-        data payload. For example::
-
-            >>> c = Client()
-            >>> c.get('/customers/details/', {'name': 'fred', 'age': 7})
-
-        ...will result in the evaluation of a GET request equivalent to::
-
-            /customers/details/?name=fred&age=7
-
-        The ``extra`` keyword arguments parameter can be used to specify
-        headers to be sent in the request. For example::
-
-            >>> c = Client()
-            >>> c.get('/customers/details/', {'name': 'fred', 'age': 7},
-            ...       HTTP_X_REQUESTED_WITH='XMLHttpRequest')
-
-        ...will send the HTTP header ``HTTP_X_REQUESTED_WITH`` to the
-        details view, which is a good way to test code paths that use the
-        :meth:`django.http.HttpRequest.is_ajax()` method.
-
-        .. admonition:: CGI specification
-
-            The headers sent via ``**extra`` should follow CGI_ specification.
-            For example, emulating a different "Host" header as sent in the
-            HTTP request from the browser to the server should be passed
-            as ``HTTP_HOST``.
-
-            .. _CGI: http://www.w3.org/CGI/
-
-        If you already have the GET arguments in URL-encoded form, you can
-        use that encoding instead of using the data argument. For example,
-        the previous GET request could also be posed as::
-
-        >>> c = Client()
-        >>> c.get('/customers/details/?name=fred&age=7')
-
-        If you provide a URL with both an encoded GET data and a data argument,
-        the data argument will take precedence.
-
-        If you set ``follow`` to ``True`` the client will follow any redirects
-        and a ``redirect_chain`` attribute will be set in the response object
-        containing tuples of the intermediate urls and status codes.
-
-        If you had a URL ``/redirect_me/`` that redirected to ``/next/``, that
-        redirected to ``/final/``, this is what you'd see::
-
-            >>> response = c.get('/redirect_me/', follow=True)
-            >>> response.redirect_chain
-            [(u'http://testserver/next/', 302), (u'http://testserver/final/', 302)]
-
-        If you set ``secure`` to ``True`` the client will emulate an HTTPS
-        request.
-
-    .. method:: Client.post(path, data={}, content_type=MULTIPART_CONTENT, follow=False, secure=False, **extra)
-
-        Makes a POST request on the provided ``path`` and returns a
-        ``Response`` object, which is documented below.
-
-        The key-value pairs in the ``data`` dictionary are used to submit POST
-        data. For example::
-
-            >>> c = Client()
-            >>> c.post('/login/', {'name': 'fred', 'passwd': 'secret'})
-
-        ...will result in the evaluation of a POST request to this URL::
-
-            /login/
-
-        ...with this POST data::
-
-            name=fred&passwd=secret
-
-        If you provide ``content_type`` (e.g. :mimetype:`text/xml` for an XML
-        payload), the contents of ``data`` will be sent as-is in the POST
-        request, using ``content_type`` in the HTTP ``Content-Type`` header.
-
-        If you don't provide a value for ``content_type``, the values in
-        ``data`` will be transmitted with a content type of
-        :mimetype:`multipart/form-data`. In this case, the key-value pairs in
-        ``data`` will be encoded as a multipart message and used to create the
-        POST data payload.
-
-        To submit multiple values for a given key -- for example, to specify
-        the selections for a ``<select multiple>`` -- provide the values as a
-        list or tuple for the required key. For example, this value of ``data``
-        would submit three selected values for the field named ``choices``::
-
-            {'choices': ('a', 'b', 'd')}
-
-        Submitting files is a special case. To POST a file, you need only
-        provide the file field name as a key, and a file handle to the file you
-        wish to upload as a value. For example::
-
-            >>> c = Client()
-            >>> with open('wishlist.doc') as fp:
-            ...     c.post('/customers/wishes/', {'name': 'fred', 'attachment': fp})
-
-        (The name ``attachment`` here is not relevant; use whatever name your
-        file-processing code expects.)
-
-        Note that if you wish to use the same file handle for multiple
-        ``post()`` calls then you will need to manually reset the file
-        pointer between posts. The easiest way to do this is to
-        manually close the file after it has been provided to
-        ``post()``, as demonstrated above.
-
-        You should also ensure that the file is opened in a way that
-        allows the data to be read. If your file contains binary data
-        such as an image, this means you will need to open the file in
-        ``rb`` (read binary) mode.
-
-        The ``extra`` argument acts the same as for :meth:`Client.get`.
-
-        If the URL you request with a POST contains encoded parameters, these
-        parameters will be made available in the request.GET data. For example,
-        if you were to make the request::
-
-        >>> c.post('/login/?visitor=true', {'name': 'fred', 'passwd': 'secret'})
-
-        ... the view handling this request could interrogate request.POST
-        to retrieve the username and password, and could interrogate request.GET
-        to determine if the user was a visitor.
-
-        If you set ``follow`` to ``True`` the client will follow any redirects
-        and a ``redirect_chain`` attribute will be set in the response object
-        containing tuples of the intermediate urls and status codes.
-
-        If you set ``secure`` to ``True`` the client will emulate an HTTPS
-        request.
-
-    .. method:: Client.head(path, data={}, follow=False, secure=False, **extra)
-
-        Makes a HEAD request on the provided ``path`` and returns a
-        ``Response`` object. This method works just like :meth:`Client.get`,
-        including the ``follow``, ``secure`` and ``extra`` arguments, except
-        it does not return a message body.
-
-    .. method:: Client.options(path, data='', content_type='application/octet-stream', follow=False, secure=False, **extra)
-
-        Makes an OPTIONS request on the provided ``path`` and returns a
-        ``Response`` object. Useful for testing RESTful interfaces.
-
-        When ``data`` is provided, it is used as the request body, and
-        a ``Content-Type`` header is set to ``content_type``.
-
-        The ``follow``, ``secure`` and ``extra`` arguments act the same as for
-        :meth:`Client.get`.
-
-    .. method:: Client.put(path, data='', content_type='application/octet-stream', follow=False, secure=False, **extra)
-
-        Makes a PUT request on the provided ``path`` and returns a
-        ``Response`` object. Useful for testing RESTful interfaces.
-
-        When ``data`` is provided, it is used as the request body, and
-        a ``Content-Type`` header is set to ``content_type``.
-
-        The ``follow``, ``secure`` and ``extra`` arguments act the same as for
-        :meth:`Client.get`.
-
-    .. method:: Client.patch(path, data='', content_type='application/octet-stream', follow=False, secure=False, **extra)
-
-        Makes a PATCH request on the provided ``path`` and returns a
-        ``Response`` object. Useful for testing RESTful interfaces.
-
-        The ``follow``, ``secure`` and ``extra`` arguments act the same as for
-        :meth:`Client.get`.
-
-    .. method:: Client.delete(path, data='', content_type='application/octet-stream', follow=False, secure=False, **extra)
-
-        Makes an DELETE request on the provided ``path`` and returns a
-        ``Response`` object. Useful for testing RESTful interfaces.
-
-        When ``data`` is provided, it is used as the request body, and
-        a ``Content-Type`` header is set to ``content_type``.
-
-        The ``follow``, ``secure`` and ``extra`` arguments act the same as for
-        :meth:`Client.get`.
-
-    .. method:: Client.login(**credentials)
-
-        If your site uses Django's :doc:`authentication system</topics/auth/index>`
-        and you deal with logging in users, you can use the test client's
-        ``login()`` method to simulate the effect of a user logging into the
-        site.
-
-        After you call this method, the test client will have all the cookies
-        and session data required to pass any login-based tests that may form
-        part of a view.
-
-        The format of the ``credentials`` argument depends on which
-        :ref:`authentication backend <authentication-backends>` you're using
-        (which is configured by your :setting:`AUTHENTICATION_BACKENDS`
-        setting). If you're using the standard authentication backend provided
-        by Django (``ModelBackend``), ``credentials`` should be the user's
-        username and password, provided as keyword arguments::
-
-            >>> c = Client()
-            >>> c.login(username='fred', password='secret')
-
-            # Now you can access a view that's only available to logged-in users.
-
-        If you're using a different authentication backend, this method may
-        require different credentials. It requires whichever credentials are
-        required by your backend's ``authenticate()`` method.
-
-        ``login()`` returns ``True`` if it the credentials were accepted and
-        login was successful.
-
-        Finally, you'll need to remember to create user accounts before you can
-        use this method. As we explained above, the test runner is executed
-        using a test database, which contains no users by default. As a result,
-        user accounts that are valid on your production site will not work
-        under test conditions. You'll need to create users as part of the test
-        suite -- either manually (using the Django model API) or with a test
-        fixture. Remember that if you want your test user to have a password,
-        you can't set the user's password by setting the password attribute
-        directly -- you must use the
-        :meth:`~django.contrib.auth.models.User.set_password()` function to
-        store a correctly hashed password. Alternatively, you can use the
-        :meth:`~django.contrib.auth.models.UserManager.create_user` helper
-        method to create a new user with a correctly hashed password.
-
-        .. versionadded:: 1.7
-
-            Requests made with :meth:`~django.test.Client.login` go through the
-            request middleware. If you need to control the environment, you can
-            do so at :class:`~django.test.Client` instantiation or with the
-            `Client.defaults` attribute.
-
-    .. method:: Client.logout()
-
-        If your site uses Django's :doc:`authentication system</topics/auth/index>`,
-        the ``logout()`` method can be used to simulate the effect of a user
-        logging out of your site.
-
-        After you call this method, the test client will have all the cookies
-        and session data cleared to defaults. Subsequent requests will appear
-        to come from an :class:`~django.contrib.auth.models.AnonymousUser`.
-
-        .. versionadded:: 1.7
-
-            Requests made with :meth:`~django.test.Client.logout` go through the
-            request middleware. If you need to control the environment, you can
-            do so at :class:`~django.test.Client` instantiation or with the
-            `Client.defaults` attribute.
-
-Testing responses
-~~~~~~~~~~~~~~~~~
-
-The ``get()`` and ``post()`` methods both return a ``Response`` object. This
-``Response`` object is *not* the same as the ``HttpResponse`` object returned
-Django views; the test response object has some additional data useful for
-test code to verify.
-
-Specifically, a ``Response`` object has the following attributes:
-
-.. class:: Response()
-
-    .. attribute:: client
-
-        The test client that was used to make the request that resulted in the
-        response.
-
-    .. attribute:: content
-
-        The body of the response, as a string. This is the final page content as
-        rendered by the view, or any error message.
-
-    .. attribute:: context
-
-        The template ``Context`` instance that was used to render the template that
-        produced the response content.
-
-        If the rendered page used multiple templates, then ``context`` will be a
-        list of ``Context`` objects, in the order in which they were rendered.
-
-        Regardless of the number of templates used during rendering, you can
-        retrieve context values using the ``[]`` operator. For example, the
-        context variable ``name`` could be retrieved using::
-
-            >>> response = client.get('/foo/')
-            >>> response.context['name']
-            'Arthur'
-
-    .. attribute:: request
-
-        The request data that stimulated the response.
-
-    .. attribute:: status_code
-
-        The HTTP status of the response, as an integer. See
-        :rfc:`2616#section-10` for a full list of HTTP status codes.
-
-    .. attribute:: templates
-
-        A list of ``Template`` instances used to render the final content, in
-        the order they were rendered. For each template in the list, use
-        ``template.name`` to get the template's file name, if the template was
-        loaded from a file. (The name is a string such as
-        ``'admin/index.html'``.)
-
-You can also use dictionary syntax on the response object to query the value
-of any settings in the HTTP headers. For example, you could determine the
-content type of a response using ``response['Content-Type']``.
-
-Exceptions
-~~~~~~~~~~
-
-If you point the test client at a view that raises an exception, that exception
-will be visible in the test case. You can then use a standard ``try ... except``
-block or :meth:`~unittest.TestCase.assertRaises` to test for exceptions.
-
-The only exceptions that are not visible to the test client are ``Http404``,
-``PermissionDenied`` and ``SystemExit``. Django catches these exceptions
-internally and converts them into the appropriate HTTP response codes. In these
-cases, you can check ``response.status_code`` in your test.
-
-Persistent state
-~~~~~~~~~~~~~~~~
-
-The test client is stateful. If a response returns a cookie, then that cookie
-will be stored in the test client and sent with all subsequent ``get()`` and
-``post()`` requests.
-
-Expiration policies for these cookies are not followed. If you want a cookie
-to expire, either delete it manually or create a new ``Client`` instance (which
-will effectively delete all cookies).
-
-A test client has two attributes that store persistent state information. You
-can access these properties as part of a test condition.
-
-.. attribute:: Client.cookies
-
-    A Python :class:`~Cookie.SimpleCookie` object, containing the current values
-    of all the client cookies. See the documentation of the :mod:`Cookie` module
-    for more.
-
-.. attribute:: Client.session
-
-    A dictionary-like object containing session information. See the
-    :doc:`session documentation</topics/http/sessions>` for full details.
-
-    To modify the session and then save it, it must be stored in a variable
-    first (because a new ``SessionStore`` is created every time this property
-    is accessed)::
-
-        def test_something(self):
-            session = self.client.session
-            session['somekey'] = 'test'
-            session.save()
-
-Example
-~~~~~~~
-
-The following is a simple unit test using the test client::
-
-    import unittest
-    from django.test import Client
-
-    class SimpleTest(unittest.TestCase):
-        def setUp(self):
-            # Every test needs a client.
-            self.client = Client()
-
-        def test_details(self):
-            # Issue a GET request.
-            response = self.client.get('/customer/details/')
-
-            # Check that the response is 200 OK.
-            self.assertEqual(response.status_code, 200)
-
-            # Check that the rendered context contains 5 customers.
-            self.assertEqual(len(response.context['customers']), 5)
-
-.. seealso::
-
-    :class:`django.test.RequestFactory`
-
-.. _django-testcase-subclasses:
-
-Provided test case classes
---------------------------
-
-Normal Python unit test classes extend a base class of
-:class:`unittest.TestCase`. Django provides a few extensions of this base class:
-
-.. _testcase_hierarchy_diagram:
-
-.. figure:: _images/django_unittest_classes_hierarchy.*
-   :alt: Hierarchy of Django unit testing classes (TestCase subclasses)
-   :width: 508
-   :height: 328
-
-   Hierarchy of Django unit testing classes
-
-SimpleTestCase
-~~~~~~~~~~~~~~
-
-.. class:: SimpleTestCase()
-
-A thin subclass of :class:`unittest.TestCase`, it extends it with some basic
-functionality like:
-
-* Saving and restoring the Python warning machinery state.
-* Some useful assertions like:
-
-  * Checking that a callable :meth:`raises a certain exception
-    <SimpleTestCase.assertRaisesMessage>`.
-  * Testing form field :meth:`rendering and error treatment
-    <SimpleTestCase.assertFieldOutput>`.
-  * Testing :meth:`HTML responses for the presence/lack of a given fragment
-    <SimpleTestCase.assertContains>`.
-  * Verifying that a template :meth:`has/hasn't been used to generate a given
-    response content <SimpleTestCase.assertTemplateUsed>`.
-  * Verifying a HTTP :meth:`redirect <SimpleTestCase.assertRedirects>` is
-    performed by the app.
-  * Robustly testing two :meth:`HTML fragments <SimpleTestCase.assertHTMLEqual>`
-    for equality/inequality or :meth:`containment <SimpleTestCase.assertInHTML>`.
-  * Robustly testing two :meth:`XML fragments <SimpleTestCase.assertXMLEqual>`
-    for equality/inequality.
-  * Robustly testing two :meth:`JSON fragments <SimpleTestCase.assertJSONEqual>`
-    for equality.
-
-* The ability to run tests with :ref:`modified settings <overriding-settings>`.
-* Using the :attr:`~SimpleTestCase.client` :class:`~django.test.Client`.
-* Custom test-time :attr:`URL maps <SimpleTestCase.urls>`.
-
-.. versionchanged:: 1.6
-
-    The latter two features were moved from ``TransactionTestCase`` to
-    ``SimpleTestCase`` in Django 1.6.
-
-If you need any of the other more complex and heavyweight Django-specific
-features like:
-
-* Testing or using the ORM.
-* Database :attr:`~TransactionTestCase.fixtures`.
-* Test :ref:`skipping based on database backend features <skipping-tests>`.
-* The remaining specialized :meth:`assert*
-  <TransactionTestCase.assertQuerysetEqual>` methods.
-
-then you should use :class:`~django.test.TransactionTestCase` or
-:class:`~django.test.TestCase` instead.
-
-``SimpleTestCase`` inherits from ``unittest.TestCase``.
-
-TransactionTestCase
-~~~~~~~~~~~~~~~~~~~
-
-.. class:: TransactionTestCase()
-
-Django's ``TestCase`` class (described below) makes use of database transaction
-facilities to speed up the process of resetting the database to a known state
-at the beginning of each test. A consequence of this, however, is that the
-effects of transaction commit and rollback cannot be tested by a Django
-``TestCase`` class. If your test requires testing of such transactional
-behavior, you should use a Django ``TransactionTestCase``.
-
-``TransactionTestCase`` and ``TestCase`` are identical except for the manner
-in which the database is reset to a known state and the ability for test code
-to test the effects of commit and rollback:
-
-* A ``TransactionTestCase`` resets the database after the test runs by
-  truncating all tables. A ``TransactionTestCase`` may call commit and rollback
-  and observe the effects of these calls on the database.
-
-* A ``TestCase``, on the other hand, does not truncate tables after a test.
-  Instead, it encloses the test code in a database transaction that is rolled
-  back at the end of the test. Both explicit commits like
-  ``transaction.commit()`` and implicit ones that may be caused by
-  ``transaction.atomic()`` are replaced with a ``nop`` operation. This
-  guarantees that the rollback at the end of the test restores the database to
-  its initial state.
-
-  When running on a database that does not support rollback (e.g. MySQL with the
-  MyISAM storage engine), ``TestCase`` falls back to initializing the database
-  by truncating tables and reloading initial data.
-
-.. warning::
-
-    While ``commit`` and ``rollback`` operations still *appear* to work when
-    used in ``TestCase``, no actual commit or rollback will be performed by the
-    database. This can cause your tests to pass or fail unexpectedly. Always
-    use ``TransactionTestCase`` when testing transactional behavior.
-
-``TransactionTestCase`` inherits from :class:`~django.test.SimpleTestCase`.
-
-TestCase
-~~~~~~~~
-
-.. class:: TestCase()
-
-This class provides some additional capabilities that can be useful for testing
-Web sites.
-
-Converting a normal :class:`unittest.TestCase` to a Django :class:`TestCase` is
-easy: Just change the base class of your test from ``'unittest.TestCase'`` to
-``'django.test.TestCase'``. All of the standard Python unit test functionality
-will continue to be available, but it will be augmented with some useful
-additions, including:
-
-* Automatic loading of fixtures.
-
-* Wraps each test in a transaction.
-
-* Creates a TestClient instance.
-
-* Django-specific assertions for testing for things like redirection and form
-  errors.
-
-``TestCase`` inherits from :class:`~django.test.TransactionTestCase`.
-
-.. _live-test-server:
-
-LiveServerTestCase
-~~~~~~~~~~~~~~~~~~
-
-.. class:: LiveServerTestCase()
-
-``LiveServerTestCase`` does basically the same as
-:class:`~django.test.TransactionTestCase` with one extra feature: it launches a
-live Django server in the background on setup, and shuts it down on teardown.
-This allows the use of automated test clients other than the
-:ref:`Django dummy client <test-client>` such as, for example, the Selenium_
-client, to execute a series of functional tests inside a browser and simulate a
-real user's actions.
-
-By default the live server's address is ``'localhost:8081'`` and the full URL
-can be accessed during the tests with ``self.live_server_url``. If you'd like
-to change the default address (in the case, for example, where the 8081 port is
-already taken) then you may pass a different one to the :djadmin:`test` command
-via the :djadminopt:`--liveserver` option, for example:
-
-.. code-block:: bash
-
-    ./manage.py test --liveserver=localhost:8082
-
-Another way of changing the default server address is by setting the
-`DJANGO_LIVE_TEST_SERVER_ADDRESS` environment variable somewhere in your
-code (for example, in a :ref:`custom test runner<topics-testing-test_runner>`):
-
-.. code-block:: python
-
-    import os
-    os.environ['DJANGO_LIVE_TEST_SERVER_ADDRESS'] = 'localhost:8082'
-
-In the case where the tests are run by multiple processes in parallel (for
-example, in the context of several simultaneous `continuous integration`_
-builds), the processes will compete for the same address, and therefore your
-tests might randomly fail with an "Address already in use" error. To avoid this
-problem, you can pass a comma-separated list of ports or ranges of ports (at
-least as many as the number of potential parallel processes). For example:
-
-.. code-block:: bash
-
-    ./manage.py test --liveserver=localhost:8082,8090-8100,9000-9200,7041
-
-Then, during test execution, each new live test server will try every specified
-port until it finds one that is free and takes it.
-
-.. _continuous integration: http://en.wikipedia.org/wiki/Continuous_integration
-
-To demonstrate how to use ``LiveServerTestCase``, let's write a simple Selenium
-test. First of all, you need to install the `selenium package`_ into your
-Python path:
-
-.. code-block:: bash
-
-   pip install selenium
-
-Then, add a ``LiveServerTestCase``-based test to your app's tests module
-(for example: ``myapp/tests.py``). The code for this test may look as follows:
-
-.. code-block:: python
-
-    from django.test import LiveServerTestCase
-    from selenium.webdriver.firefox.webdriver import WebDriver
-
-    class MySeleniumTests(LiveServerTestCase):
-        fixtures = ['user-data.json']
-
-        @classmethod
-        def setUpClass(cls):
-            cls.selenium = WebDriver()
-            super(MySeleniumTests, cls).setUpClass()
-
-        @classmethod
-        def tearDownClass(cls):
-            cls.selenium.quit()
-            super(MySeleniumTests, cls).tearDownClass()
-
-        def test_login(self):
-            self.selenium.get('%s%s' % (self.live_server_url, '/login/'))
-            username_input = self.selenium.find_element_by_name("username")
-            username_input.send_keys('myuser')
-            password_input = self.selenium.find_element_by_name("password")
-            password_input.send_keys('secret')
-            self.selenium.find_element_by_xpath('//input[@value="Log in"]').click()
-
-Finally, you may run the test as follows:
-
-.. code-block:: bash
-
-    ./manage.py test myapp.MySeleniumTests.test_login
-
-This example will automatically open Firefox then go to the login page, enter
-the credentials and press the "Log in" button. Selenium offers other drivers in
-case you do not have Firefox installed or wish to use another browser. The
-example above is just a tiny fraction of what the Selenium client can do; check
-out the `full reference`_ for more details.
-
-.. _Selenium: http://seleniumhq.org/
-.. _selenium package: https://pypi.python.org/pypi/selenium
-.. _full reference: http://selenium-python.readthedocs.org/en/latest/api.html
-.. _Firefox: http://www.mozilla.com/firefox/
-
-.. versionchanged:: 1.7
-
-    Before Django 1.7 ``LiveServerTestCase`` used to rely on the
-    :doc:`staticfiles contrib app </howto/static-files/index>` to get the
-    static assets of the application(s) under test transparently served at their
-    expected locations during the execution of these tests.
-
-    In Django 1.7 this dependency of core functionality on a ``contrib``
-    appplication has been removed, because of which ``LiveServerTestCase``
-    ability in this respect has been retrofitted to simply publish the contents
-    of the file system under :setting:`STATIC_ROOT` at the :setting:`STATIC_URL`
-    URL.
-
-    If you use the ``staticfiles`` app in your project and need to perform live
-    testing then you might want to consider using the
-    :class:`~django.contrib.staticfiles.testing.StaticLiveServerCase` subclass
-    shipped with it instead because it's the one that implements the original
-    behavior now. See :ref:`the relevant documentation
-    <staticfiles-testing-support>` for more details.
-
-.. note::
-
-    When using an in-memory SQLite database to run the tests, the same database
-    connection will be shared by two threads in parallel: the thread in which
-    the live server is run and the thread in which the test case is run. It's
-    important to prevent simultaneous database queries via this shared
-    connection by the two threads, as that may sometimes randomly cause the
-    tests to fail. So you need to ensure that the two threads don't access the
-    database at the same time. In particular, this means that in some cases
-    (for example, just after clicking a link or submitting a form), you might
-    need to check that a response is received by Selenium and that the next
-    page is loaded before proceeding with further test execution.
-    Do this, for example, by making Selenium wait until the ``<body>`` HTML tag
-    is found in the response (requires Selenium > 2.13):
-
-    .. code-block:: python
-
-        def test_login(self):
-            from selenium.webdriver.support.wait import WebDriverWait
-            timeout = 2
-            ...
-            self.selenium.find_element_by_xpath('//input[@value="Log in"]').click()
-            # Wait until the response is received
-            WebDriverWait(self.selenium, timeout).until(
-                lambda driver: driver.find_element_by_tag_name('body'))
-
-    The tricky thing here is that there's really no such thing as a "page load,"
-    especially in modern Web apps that generate HTML dynamically after the
-    server generates the initial document. So, simply checking for the presence
-    of ``<body>`` in the response might not necessarily be appropriate for all
-    use cases. Please refer to the `Selenium FAQ`_ and
-    `Selenium documentation`_ for more information.
-
-    .. _Selenium FAQ: http://code.google.com/p/selenium/wiki/FrequentlyAskedQuestions#Q:_WebDriver_fails_to_find_elements_/_Does_not_block_on_page_loa
-    .. _Selenium documentation: http://seleniumhq.org/docs/04_webdriver_advanced.html#explicit-waits
-
-Test cases features
--------------------
-
-Default test client
-~~~~~~~~~~~~~~~~~~~
-
-.. attribute:: SimpleTestCase.client
-
-Every test case in a ``django.test.*TestCase`` instance has access to an
-instance of a Django test client. This client can be accessed as
-``self.client``. This client is recreated for each test, so you don't have to
-worry about state (such as cookies) carrying over from one test to another.
-
-This means, instead of instantiating a ``Client`` in each test::
-
-    import unittest
-    from django.test import Client
-
-    class SimpleTest(unittest.TestCase):
-        def test_details(self):
-            client = Client()
-            response = client.get('/customer/details/')
-            self.assertEqual(response.status_code, 200)
-
-        def test_index(self):
-            client = Client()
-            response = client.get('/customer/index/')
-            self.assertEqual(response.status_code, 200)
-
-...you can just refer to ``self.client``, like so::
-
-    from django.test import TestCase
-
-    class SimpleTest(TestCase):
-        def test_details(self):
-            response = self.client.get('/customer/details/')
-            self.assertEqual(response.status_code, 200)
-
-        def test_index(self):
-            response = self.client.get('/customer/index/')
-            self.assertEqual(response.status_code, 200)
-
-Customizing the test client
-~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-.. attribute:: SimpleTestCase.client_class
-
-If you want to use a different ``Client`` class (for example, a subclass
-with customized behavior), use the :attr:`~SimpleTestCase.client_class` class
-attribute::
-
-    from django.test import TestCase, Client
-
-    class MyTestClient(Client):
-        # Specialized methods for your environment...
-
-    class MyTest(TestCase):
-        client_class = MyTestClient
-
-        def test_my_stuff(self):
-            # Here self.client is an instance of MyTestClient...
-            call_some_test_code()
-
-.. _topics-testing-fixtures:
-
-Fixture loading
-~~~~~~~~~~~~~~~
-
-.. attribute:: TransactionTestCase.fixtures
-
-A test case for a database-backed Web site isn't much use if there isn't any
-data in the database. To make it easy to put test data into the database,
-Django's custom ``TransactionTestCase`` class provides a way of loading
-**fixtures**.
-
-A fixture is a collection of data that Django knows how to import into a
-database. For example, if your site has user accounts, you might set up a
-fixture of fake user accounts in order to populate your database during tests.
-
-The most straightforward way of creating a fixture is to use the
-:djadmin:`manage.py dumpdata <dumpdata>` command. This assumes you
-already have some data in your database. See the :djadmin:`dumpdata
-documentation<dumpdata>` for more details.
-
-.. note::
-
-    If you've ever run :djadmin:`manage.py migrate<migrate>`, you've
-    already used a fixture without even knowing it! When you call
-    :djadmin:`migrate` in the database for the first time, Django
-    installs a fixture called ``initial_data``. This gives you a way
-    of populating a new database with any initial data, such as a
-    default set of categories.
-
-    Fixtures with other names can always be installed manually using
-    the :djadmin:`manage.py loaddata<loaddata>` command.
-
-.. admonition:: Initial SQL data and testing
-
-    Django provides a second way to insert initial data into models --
-    the :ref:`custom SQL hook <initial-sql>`. However, this technique
-    *cannot* be used to provide initial data for testing purposes.
-    Django's test framework flushes the contents of the test database
-    after each test; as a result, any data added using the custom SQL
-    hook will be lost.
-
-Once you've created a fixture and placed it in a ``fixtures`` directory in one
-of your :setting:`INSTALLED_APPS`, you can use it in your unit tests by
-specifying a ``fixtures`` class attribute on your :class:`django.test.TestCase`
-subclass::
-
-    from django.test import TestCase
-    from myapp.models import Animal
-
-    class AnimalTestCase(TestCase):
-        fixtures = ['mammals.json', 'birds']
-
-        def setUp(self):
-            # Test definitions as before.
-            call_setup_methods()
-
-        def testFluffyAnimals(self):
-            # A test that uses the fixtures.
-            call_some_test_code()
-
-Here's specifically what will happen:
-
-* At the start of each test case, before ``setUp()`` is run, Django will
-  flush the database, returning the database to the state it was in
-  directly after :djadmin:`migrate` was called.
-
-* Then, all the named fixtures are installed. In this example, Django will
-  install any JSON fixture named ``mammals``, followed by any fixture named
-  ``birds``. See the :djadmin:`loaddata` documentation for more
-  details on defining and installing fixtures.
-
-This flush/load procedure is repeated for each test in the test case, so you
-can be certain that the outcome of a test will not be affected by another test,
-or by the order of test execution.
-
-By default, fixtures are only loaded into the ``default`` database. If you are
-using multiple databases and set :attr:`multi_db=True
-<TransactionTestCase.multi_db>`, fixtures will be loaded into all databases.
-
-URLconf configuration
-~~~~~~~~~~~~~~~~~~~~~
-
-.. attribute:: SimpleTestCase.urls
-
-If your application provides views, you may want to include tests that use the
-test client to exercise those views. However, an end user is free to deploy the
-views in your application at any URL of their choosing. This means that your
-tests can't rely upon the fact that your views will be available at a
-particular URL.
-
-In order to provide a reliable URL space for your test,
-``django.test.*TestCase`` classes provide the ability to customize the URLconf
-configuration for the duration of the execution of a test suite. If your
-``*TestCase`` instance defines an ``urls`` attribute, the ``*TestCase`` will use
-the value of that attribute as the :setting:`ROOT_URLCONF` for the duration
-of that test.
-
-For example::
-
-    from django.test import TestCase
-
-    class TestMyViews(TestCase):
-        urls = 'myapp.test_urls'
-
-        def testIndexPageView(self):
-            # Here you'd test your view using ``Client``.
-            call_some_test_code()
-
-This test case will use the contents of ``myapp.test_urls`` as the
-URLconf for the duration of the test case.
-
-.. _emptying-test-outbox:
-
-Multi-database support
-~~~~~~~~~~~~~~~~~~~~~~
-
-.. attribute:: TransactionTestCase.multi_db
-
-Django sets up a test database corresponding to every database that is
-defined in the :setting:`DATABASES` definition in your settings
-file. However, a big part of the time taken to run a Django TestCase
-is consumed by the call to ``flush`` that ensures that you have a
-clean database at the start of each test run. If you have multiple
-databases, multiple flushes are required (one for each database),
-which can be a time consuming activity -- especially if your tests
-don't need to test multi-database activity.
-
-As an optimization, Django only flushes the ``default`` database at
-the start of each test run. If your setup contains multiple databases,
-and you have a test that requires every database to be clean, you can
-use the ``multi_db`` attribute on the test suite to request a full
-flush.
-
-For example::
-
-    class TestMyViews(TestCase):
-        multi_db = True
-
-        def testIndexPageView(self):
-            call_some_test_code()
-
-This test case will flush *all* the test databases before running
-``testIndexPageView``.
-
-The ``multi_db`` flag also affects into which databases the
-attr:`TransactionTestCase.fixtures` are loaded. By default (when
-``multi_db=False``), fixtures are only loaded into the ``default`` database.
-If ``multi_db=True``, fixtures are loaded into all databases.
-
-.. _overriding-settings:
-
-Overriding settings
-~~~~~~~~~~~~~~~~~~~
-
-.. method:: SimpleTestCase.settings
-
-For testing purposes it's often useful to change a setting temporarily and
-revert to the original value after running the testing code. For this use case
-Django provides a standard Python context manager (see :pep:`343`)
-:meth:`~django.test.SimpleTestCase.settings`, which can be used like this::
-
-    from django.test import TestCase
-
-    class LoginTestCase(TestCase):
-
-        def test_login(self):
-
-            # First check for the default behavior
-            response = self.client.get('/sekrit/')
-            self.assertRedirects(response, '/accounts/login/?next=/sekrit/')
-
-            # Then override the LOGIN_URL setting
-            with self.settings(LOGIN_URL='/other/login/'):
-                response = self.client.get('/sekrit/')
-                self.assertRedirects(response, '/other/login/?next=/sekrit/')
-
-This example will override the :setting:`LOGIN_URL` setting for the code
-in the ``with`` block and reset its value to the previous state afterwards.
-
-.. function:: override_settings
-
-In case you want to override a setting for just one test method or even the
-whole :class:`~django.test.TestCase` class, Django provides the
-:func:`~django.test.override_settings` decorator (see :pep:`318`). It's
-used like this::
-
-    from django.test import TestCase, override_settings
-
-    class LoginTestCase(TestCase):
-
-        @override_settings(LOGIN_URL='/other/login/')
-        def test_login(self):
-            response = self.client.get('/sekrit/')
-            self.assertRedirects(response, '/other/login/?next=/sekrit/')
-
-The decorator can also be applied to test case classes::
-
-    from django.test import TestCase, override_settings
-
-    @override_settings(LOGIN_URL='/other/login/')
-    class LoginTestCase(TestCase):
-
-        def test_login(self):
-            response = self.client.get('/sekrit/')
-            self.assertRedirects(response, '/other/login/?next=/sekrit/')
-
-.. versionchanged:: 1.7
-
-    Previously, ``override_settings`` was imported from
-    ``django.test.utils``.
-
-.. note::
-
-    When given a class, the decorator modifies the class directly and
-    returns it; it doesn't create and return a modified copy of it.  So if
-    you try to tweak the above example to assign the return value to a
-    different name than ``LoginTestCase``, you may be surprised to find that
-    the original ``LoginTestCase`` is still equally affected by the
-    decorator.
-
-.. warning::
-
-    The settings file contains some settings that are only consulted during
-    initialization of Django internals. If you change them with
-    ``override_settings``, the setting is changed if you access it via the
-    ``django.conf.settings`` module, however, Django's internals access it
-    differently. Effectively, using ``override_settings`` with these settings
-    is probably not going to do what you expect it to do.
-
-    We do not recommend using ``override_settings`` with :setting:`DATABASES`.
-    Using ``override_settings`` with :setting:`CACHES` is possible, but a bit
-    tricky if you are using internals that make using of caching, like
-    :mod:`django.contrib.sessions`. For example, you will have to reinitialize
-    the session backend in a test that uses cached sessions and overrides
-    :setting:`CACHES`.
-
-
-You can also simulate the absence of a setting by deleting it after settings
-have been overridden, like this::
-
-    @override_settings()
-    def test_something(self):
-        del settings.LOGIN_URL
-        ...
-
-When overriding settings, make sure to handle the cases in which your app's
-code uses a cache or similar feature that retains state even if the
-setting is changed. Django provides the
-:data:`django.test.signals.setting_changed` signal that lets you register
-callbacks to clean up and otherwise reset state when settings are changed.
-
-Django itself uses this signal to reset various data:
-
-================================ ========================
-Overridden settings              Data reset
-================================ ========================
-USE_TZ, TIME_ZONE                Databases timezone
-TEMPLATE_CONTEXT_PROCESSORS      Context processors cache
-TEMPLATE_LOADERS                 Template loaders cache
-SERIALIZATION_MODULES            Serializers cache
-LOCALE_PATHS, LANGUAGE_CODE      Default translation and loaded translations
-MEDIA_ROOT, DEFAULT_FILE_STORAGE Default file storage
-================================ ========================
-
-Emptying the test outbox
-~~~~~~~~~~~~~~~~~~~~~~~~
-
-If you use any of Django's custom ``TestCase`` classes, the test runner will
-clear the contents of the test email outbox at the start of each test case.
-
-For more detail on email services during tests, see `Email services`_ below.
-
-.. _assertions:
-
-Assertions
-~~~~~~~~~~
-
-As Python's normal :class:`unittest.TestCase` class implements assertion methods
-such as :meth:`~unittest.TestCase.assertTrue` and
-:meth:`~unittest.TestCase.assertEqual`, Django's custom :class:`TestCase` class
-provides a number of custom assertion methods that are useful for testing Web
-applications:
-
-The failure messages given by most of these assertion methods can be customized
-with the ``msg_prefix`` argument. This string will be prefixed to any failure
-message generated by the assertion. This allows you to provide additional
-details that may help you to identify the location and cause of an failure in
-your test suite.
-
-.. method:: SimpleTestCase.assertRaisesMessage(expected_exception, expected_message, callable_obj=None, *args, **kwargs)
-
-    Asserts that execution of callable ``callable_obj`` raised the
-    ``expected_exception`` exception and that such exception has an
-    ``expected_message`` representation. Any other outcome is reported as a
-    failure. Similar to unittest's :meth:`~unittest.TestCase.assertRaisesRegexp`
-    with the difference that ``expected_message`` isn't a regular expression.
-
-.. method:: SimpleTestCase.assertFieldOutput(self, fieldclass, valid, invalid, field_args=None, field_kwargs=None, empty_value=u'')
-
-    Asserts that a form field behaves correctly with various inputs.
-
-    :param fieldclass: the class of the field to be tested.
-    :param valid: a dictionary mapping valid inputs to their expected cleaned
-        values.
-    :param invalid: a dictionary mapping invalid inputs to one or more raised
-        error messages.
-    :param field_args: the args passed to instantiate the field.
-    :param field_kwargs: the kwargs passed to instantiate the field.
-    :param empty_value: the expected clean output for inputs in ``empty_values``.
-
-    For example, the following code tests that an ``EmailField`` accepts
-    "a@a.com" as a valid email address, but rejects "aaa" with a reasonable
-    error message::
-
-        self.assertFieldOutput(EmailField, {'a@a.com': 'a@a.com'}, {'aaa': [u'Enter a valid email address.']})
-
-.. method:: SimpleTestCase.assertFormError(response, form, field, errors, msg_prefix='')
-
-    Asserts that a field on a form raises the provided list of errors when
-    rendered on the form.
-
-    ``form`` is the name the ``Form`` instance was given in the template
-    context.
-
-    ``field`` is the name of the field on the form to check. If ``field``
-    has a value of ``None``, non-field errors (errors you can access via
-    ``form.non_field_errors()``) will be checked.
-
-    ``errors`` is an error string, or a list of error strings, that are
-    expected as a result of form validation.
-
-.. method:: SimpleTestCase.assertFormsetError(response, formset, form_index, field, errors, msg_prefix='')
-
-    .. versionadded:: 1.6
-
-    Asserts that the ``formset`` raises the provided list of errors when
-    rendered.
-
-    ``formset`` is the name the ``Formset`` instance was given in the template
-    context.
-
-    ``form_index`` is the number of the form within the ``Formset``.  If
-    ``form_index`` has a value of ``None``, non-form errors (errors you can
-    access via ``formset.non_form_errors()``) will be checked.
-
-    ``field`` is the name of the field on the form to check. If ``field``
-    has a value of ``None``, non-field errors (errors you can access via
-    ``form.non_field_errors()``) will be checked.
-
-    ``errors`` is an error string, or a list of error strings, that are
-    expected as a result of form validation.
-
-.. method:: SimpleTestCase.assertContains(response, text, count=None, status_code=200, msg_prefix='', html=False)
-
-    Asserts that a ``Response`` instance produced the given ``status_code`` and
-    that ``text`` appears in the content of the response. If ``count`` is
-    provided, ``text`` must occur exactly ``count`` times in the response.
-
-    Set ``html`` to ``True`` to handle ``text`` as HTML. The comparison with
-    the response content will be based on HTML semantics instead of
-    character-by-character equality. Whitespace is ignored in most cases,
-    attribute ordering is not significant. See
-    :meth:`~SimpleTestCase.assertHTMLEqual` for more details.
-
-.. method:: SimpleTestCase.assertNotContains(response, text, status_code=200, msg_prefix='', html=False)
-
-    Asserts that a ``Response`` instance produced the given ``status_code`` and
-    that ``text`` does not appears in the content of the response.
-
-    Set ``html`` to ``True`` to handle ``text`` as HTML. The comparison with
-    the response content will be based on HTML semantics instead of
-    character-by-character equality. Whitespace is ignored in most cases,
-    attribute ordering is not significant. See
-    :meth:`~SimpleTestCase.assertHTMLEqual` for more details.
-
-.. method:: SimpleTestCase.assertTemplateUsed(response, template_name, msg_prefix='')
-
-    Asserts that the template with the given name was used in rendering the
-    response.
-
-    The name is a string such as ``'admin/index.html'``.
-
-    You can use this as a context manager, like this::
-
-        with self.assertTemplateUsed('index.html'):
-            render_to_string('index.html')
-        with self.assertTemplateUsed(template_name='index.html'):
-            render_to_string('index.html')
-
-.. method:: SimpleTestCase.assertTemplateNotUsed(response, template_name, msg_prefix='')
-
-    Asserts that the template with the given name was *not* used in rendering
-    the response.
-
-    You can use this as a context manager in the same way as
-    :meth:`~SimpleTestCase.assertTemplateUsed`.
-
-.. method:: SimpleTestCase.assertRedirects(response, expected_url, status_code=302, target_status_code=200, msg_prefix='', fetch_redirect_response=True)
-
-    Asserts that the response return a ``status_code`` redirect status, it
-    redirected to ``expected_url`` (including any GET data), and the final
-    page was received with ``target_status_code``.
-
-    If your request used the ``follow`` argument, the ``expected_url`` and
-    ``target_status_code`` will be the url and status code for the final
-    point of the redirect chain.
-
-    .. versionadded:: 1.7
-
-    If ``fetch_redirect_response`` is ``False``, the final page won't be
-    loaded. Since the test client can't fetch externals URLs, this is
-    particularly useful if ``expected_url`` isn't part of your Django app.
-
-    .. versionadded:: 1.7
-
-    Scheme is handled correctly when making comparisons between two URLs. If
-    there isn't any scheme specified in the location where we are redirected to,
-    the original request's scheme is used. If present, the scheme in
-    ``expected_url`` is the one used to make the comparisons to.
-
-.. method:: SimpleTestCase.assertHTMLEqual(html1, html2, msg=None)
-
-    Asserts that the strings ``html1`` and ``html2`` are equal. The comparison
-    is based on HTML semantics. The comparison takes following things into
-    account:
-
-    * Whitespace before and after HTML tags is ignored.
-    * All types of whitespace are considered equivalent.
-    * All open tags are closed implicitly, e.g. when a surrounding tag is
-      closed or the HTML document ends.
-    * Empty tags are equivalent to their self-closing version.
-    * The ordering of attributes of an HTML element is not significant.
-    * Attributes without an argument are equal to attributes that equal in
-      name and value (see the examples).
-
-    The following examples are valid tests and don't raise any
-    ``AssertionError``::
-
-        self.assertHTMLEqual('<p>Hello <b>world!</p>',
-            '''<p>
-                Hello   <b>world! <b/>
-            </p>''')
-        self.assertHTMLEqual(
-            '<input type="checkbox" checked="checked" id="id_accept_terms" />',
-            '<input id="id_accept_terms" type='checkbox' checked>')
-
-    ``html1`` and ``html2`` must be valid HTML. An ``AssertionError`` will be
-    raised if one of them cannot be parsed.
-
-    Output in case of error can be customized with the ``msg`` argument.
-
-.. method:: SimpleTestCase.assertHTMLNotEqual(html1, html2, msg=None)
-
-    Asserts that the strings ``html1`` and ``html2`` are *not* equal. The
-    comparison is based on HTML semantics. See
-    :meth:`~SimpleTestCase.assertHTMLEqual` for details.
-
-    ``html1`` and ``html2`` must be valid HTML. An ``AssertionError`` will be
-    raised if one of them cannot be parsed.
-
-    Output in case of error can be customized with the ``msg`` argument.
-
-.. method:: SimpleTestCase.assertXMLEqual(xml1, xml2, msg=None)
-
-    Asserts that the strings ``xml1`` and ``xml2`` are equal. The
-    comparison is based on XML semantics. Similarly to
-    :meth:`~SimpleTestCase.assertHTMLEqual`, the comparison is
-    made on parsed content, hence only semantic differences are considered, not
-    syntax differences. When unvalid XML is passed in any parameter, an
-    ``AssertionError`` is always raised, even if both string are identical.
-
-    Output in case of error can be customized with the ``msg`` argument.
-
-.. method:: SimpleTestCase.assertXMLNotEqual(xml1, xml2, msg=None)
-
-    Asserts that the strings ``xml1`` and ``xml2`` are *not* equal. The
-    comparison is based on XML semantics. See
-    :meth:`~SimpleTestCase.assertXMLEqual` for details.
-
-    Output in case of error can be customized with the ``msg`` argument.
-
-.. method:: SimpleTestCase.assertInHTML(needle, haystack, count=None, msg_prefix='')
-
-    Asserts that the HTML fragment ``needle`` is contained in the ``haystack`` one.
-
-    If the ``count`` integer argument is specified, then additionally the number
-    of ``needle`` occurrences will be strictly verified.
-
-    Whitespace in most cases is ignored, and attribute ordering is not
-    significant. The passed-in arguments must be valid HTML.
-
-.. method:: SimpleTestCase.assertJSONEqual(raw, expected_data, msg=None)
-
-    Asserts that the JSON fragments ``raw`` and ``expected_data`` are equal.
-    Usual JSON non-significant whitespace rules apply as the heavyweight is
-    delegated to the :mod:`json` library.
-
-    Output in case of error can be customized with the ``msg`` argument.
-
-.. method:: TransactionTestCase.assertQuerysetEqual(qs, values, transform=repr, ordered=True)
-
-    Asserts that a queryset ``qs`` returns a particular list of values ``values``.
-
-    The comparison of the contents of ``qs`` and ``values`` is performed using
-    the function ``transform``; by default, this means that the ``repr()`` of
-    each value is compared. Any other callable can be used if ``repr()`` doesn't
-    provide a unique or helpful comparison.
-
-    By default, the comparison is also ordering dependent. If ``qs`` doesn't
-    provide an implicit ordering, you can set the ``ordered`` parameter to
-    ``False``, which turns the comparison into a Python set comparison.
-
-    .. versionchanged:: 1.6
-
-        The method now checks for undefined order and raises ``ValueError``
-        if undefined order is spotted. The ordering is seen as undefined if
-        the given ``qs`` isn't ordered and the comparison is against more
-        than one ordered values.
-
-.. method:: TransactionTestCase.assertNumQueries(num, func, *args, **kwargs)
-
-    Asserts that when ``func`` is called with ``*args`` and ``**kwargs`` that
-    ``num`` database queries are executed.
-
-    If a ``"using"`` key is present in ``kwargs`` it is used as the database
-    alias for which to check the number of queries.  If you wish to call a
-    function with a ``using`` parameter you can do it by wrapping the call with
-    a ``lambda`` to add an extra parameter::
-
-        self.assertNumQueries(7, lambda: my_function(using=7))
-
-    You can also use this as a context manager::
-
-        with self.assertNumQueries(2):
-            Person.objects.create(name="Aaron")
-            Person.objects.create(name="Daniel")
-
-.. _topics-testing-email:
-
-Email services
---------------
-
-If any of your Django views send email using :doc:`Django's email
-functionality </topics/email>`, you probably don't want to send email each time
-you run a test using that view. For this reason, Django's test runner
-automatically redirects all Django-sent email to a dummy outbox. This lets you
-test every aspect of sending email -- from the number of messages sent to the
-contents of each message -- without actually sending the messages.
-
-The test runner accomplishes this by transparently replacing the normal
-email backend with a testing backend.
-(Don't worry -- this has no effect on any other email senders outside of
-Django, such as your machine's mail server, if you're running one.)
-
-.. currentmodule:: django.core.mail
-
-.. data:: django.core.mail.outbox
-
-During test running, each outgoing email is saved in
-``django.core.mail.outbox``. This is a simple list of all
-:class:`~django.core.mail.EmailMessage` instances that have been sent.
-The ``outbox`` attribute is a special attribute that is created *only* when
-the ``locmem`` email backend is used. It doesn't normally exist as part of the
-:mod:`django.core.mail` module and you can't import it directly. The code
-below shows how to access this attribute correctly.
-
-Here's an example test that examines ``django.core.mail.outbox`` for length
-and contents::
-
-    from django.core import mail
-    from django.test import TestCase
-
-    class EmailTest(TestCase):
-        def test_send_email(self):
-            # Send message.
-            mail.send_mail('Subject here', 'Here is the message.',
-                'from@example.com', ['to@example.com'],
-                fail_silently=False)
-
-            # Test that one message has been sent.
-            self.assertEqual(len(mail.outbox), 1)
-
-            # Verify that the subject of the first message is correct.
-            self.assertEqual(mail.outbox[0].subject, 'Subject here')
-
-As noted :ref:`previously <emptying-test-outbox>`, the test outbox is emptied
-at the start of every test in a Django ``*TestCase``. To empty the outbox
-manually, assign the empty list to ``mail.outbox``::
-
-    from django.core import mail
-
-    # Empty the test outbox
-    mail.outbox = []
-
-.. _skipping-tests:
-
-Skipping tests
---------------
-
-.. currentmodule:: django.test
-
-The unittest library provides the :func:`@skipIf <unittest.skipIf>` and
-:func:`@skipUnless <unittest.skipUnless>` decorators to allow you to skip tests
-if you know ahead of time that those tests are going to fail under certain
-conditions.
-
-For example, if your test requires a particular optional library in order to
-succeed, you could decorate the test case with :func:`@skipIf
-<unittest.skipIf>`. Then, the test runner will report that the test wasn't
-executed and why, instead of failing the test or omitting the test altogether.
-
-To supplement these test skipping behaviors, Django provides two
-additional skip decorators. Instead of testing a generic boolean,
-these decorators check the capabilities of the database, and skip the
-test if the database doesn't support a specific named feature.
-
-The decorators use a string identifier to describe database features.
-This string corresponds to attributes of the database connection
-features class. See ``django.db.backends.BaseDatabaseFeatures``
-class for a full list of database features that can be used as a basis
-for skipping tests.
-
-.. function:: skipIfDBFeature(feature_name_string)
-
-Skip the decorated test or ``TestCase`` if the named database feature is
-supported.
-
-For example, the following test will not be executed if the database
-supports transactions (e.g., it would *not* run under PostgreSQL, but
-it would under MySQL with MyISAM tables)::
-
-    class MyTests(TestCase):
-        @skipIfDBFeature('supports_transactions')
-        def test_transaction_behavior(self):
-            # ... conditional test code
-
-.. versionchanged:: 1.7
-
-    ``skipIfDBFeature`` can now be used to decorate a ``TestCase`` class.
-
-.. function:: skipUnlessDBFeature(feature_name_string)
-
-Skip the decorated test or ``TestCase`` if the named database feature is *not*
-supported.
-
-For example, the following test will only be executed if the database
-supports transactions (e.g., it would run under PostgreSQL, but *not*
-under MySQL with MyISAM tables)::
-
-    class MyTests(TestCase):
-        @skipUnlessDBFeature('supports_transactions')
-        def test_transaction_behavior(self):
-            # ... conditional test code
-
-.. versionchanged:: 1.7
-
-    ``skipUnlessDBFeature`` can now be used to decorate a ``TestCase`` class.
diff --git a/docs/topics/testing/tools.txt b/docs/topics/testing/tools.txt
new file mode 100644
index 0000000000..680c1dd17c
--- /dev/null
+++ b/docs/topics/testing/tools.txt
@@ -0,0 +1,1603 @@
+=============
+Testing tools
+=============
+
+.. currentmodule:: django.test
+
+Django provides a small set of tools that come in handy when writing tests.
+
+.. _test-client:
+
+The test client
+---------------
+
+The test client is a Python class that acts as a dummy Web browser, allowing
+you to test your views and interact with your Django-powered application
+programmatically.
+
+Some of the things you can do with the test client are:
+
+* Simulate GET and POST requests on a URL and observe the response --
+  everything from low-level HTTP (result headers and status codes) to
+  page content.
+
+* See the chain of redirects (if any) and check the URL and status code at
+  each step.
+
+* Test that a given request is rendered by a given Django template, with
+  a template context that contains certain values.
+
+Note that the test client is not intended to be a replacement for Selenium_ or
+other "in-browser" frameworks. Django's test client has a different focus. In
+short:
+
+* Use Django's test client to establish that the correct template is being
+  rendered and that the template is passed the correct context data.
+
+* Use in-browser frameworks like Selenium_ to test *rendered* HTML and the
+  *behavior* of Web pages, namely JavaScript functionality. Django also
+  provides special support for those frameworks; see the section on
+  :class:`~django.test.LiveServerTestCase` for more details.
+
+A comprehensive test suite should use a combination of both test types.
+
+Overview and a quick example
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+To use the test client, instantiate ``django.test.Client`` and retrieve
+Web pages::
+
+    >>> from django.test import Client
+    >>> c = Client()
+    >>> response = c.post('/login/', {'username': 'john', 'password': 'smith'})
+    >>> response.status_code
+    200
+    >>> response = c.get('/customer/details/')
+    >>> response.content
+    '<!DOCTYPE html...'
+
+As this example suggests, you can instantiate ``Client`` from within a session
+of the Python interactive interpreter.
+
+Note a few important things about how the test client works:
+
+* The test client does *not* require the Web server to be running. In fact,
+  it will run just fine with no Web server running at all! That's because
+  it avoids the overhead of HTTP and deals directly with the Django
+  framework. This helps make the unit tests run quickly.
+
+* When retrieving pages, remember to specify the *path* of the URL, not the
+  whole domain. For example, this is correct::
+
+      >>> c.get('/login/')
+
+  This is incorrect::
+
+      >>> c.get('http://www.example.com/login/')
+
+  The test client is not capable of retrieving Web pages that are not
+  powered by your Django project. If you need to retrieve other Web pages,
+  use a Python standard library module such as :mod:`urllib` or
+  :mod:`urllib2`.
+
+* To resolve URLs, the test client uses whatever URLconf is pointed-to by
+  your :setting:`ROOT_URLCONF` setting.
+
+* Although the above example would work in the Python interactive
+  interpreter, some of the test client's functionality, notably the
+  template-related functionality, is only available *while tests are
+  running*.
+
+  The reason for this is that Django's test runner performs a bit of black
+  magic in order to determine which template was loaded by a given view.
+  This black magic (essentially a patching of Django's template system in
+  memory) only happens during test running.
+
+* By default, the test client will disable any CSRF checks
+  performed by your site.
+
+  If, for some reason, you *want* the test client to perform CSRF
+  checks, you can create an instance of the test client that
+  enforces CSRF checks. To do this, pass in the
+  ``enforce_csrf_checks`` argument when you construct your
+  client::
+
+      >>> from django.test import Client
+      >>> csrf_client = Client(enforce_csrf_checks=True)
+
+Making requests
+~~~~~~~~~~~~~~~
+
+Use the ``django.test.Client`` class to make requests.
+
+.. class:: Client(enforce_csrf_checks=False, **defaults)
+
+    It requires no arguments at time of construction. However, you can use
+    keywords arguments to specify some default headers. For example, this will
+    send a ``User-Agent`` HTTP header in each request::
+
+        >>> c = Client(HTTP_USER_AGENT='Mozilla/5.0')
+
+    The values from the ``extra`` keywords arguments passed to
+    :meth:`~django.test.Client.get()`,
+    :meth:`~django.test.Client.post()`, etc. have precedence over
+    the defaults passed to the class constructor.
+
+    The ``enforce_csrf_checks`` argument can be used to test CSRF
+    protection (see above).
+
+    Once you have a ``Client`` instance, you can call any of the following
+    methods:
+
+    .. method:: Client.get(path, data={}, follow=False, secure=False, **extra)
+
+        .. versionadded:: 1.7
+
+            The ``secure`` argument was added.
+
+        Makes a GET request on the provided ``path`` and returns a ``Response``
+        object, which is documented below.
+
+        The key-value pairs in the ``data`` dictionary are used to create a GET
+        data payload. For example::
+
+            >>> c = Client()
+            >>> c.get('/customers/details/', {'name': 'fred', 'age': 7})
+
+        ...will result in the evaluation of a GET request equivalent to::
+
+            /customers/details/?name=fred&age=7
+
+        The ``extra`` keyword arguments parameter can be used to specify
+        headers to be sent in the request. For example::
+
+            >>> c = Client()
+            >>> c.get('/customers/details/', {'name': 'fred', 'age': 7},
+            ...       HTTP_X_REQUESTED_WITH='XMLHttpRequest')
+
+        ...will send the HTTP header ``HTTP_X_REQUESTED_WITH`` to the
+        details view, which is a good way to test code paths that use the
+        :meth:`django.http.HttpRequest.is_ajax()` method.
+
+        .. admonition:: CGI specification
+
+            The headers sent via ``**extra`` should follow CGI_ specification.
+            For example, emulating a different "Host" header as sent in the
+            HTTP request from the browser to the server should be passed
+            as ``HTTP_HOST``.
+
+            .. _CGI: http://www.w3.org/CGI/
+
+        If you already have the GET arguments in URL-encoded form, you can
+        use that encoding instead of using the data argument. For example,
+        the previous GET request could also be posed as::
+
+        >>> c = Client()
+        >>> c.get('/customers/details/?name=fred&age=7')
+
+        If you provide a URL with both an encoded GET data and a data argument,
+        the data argument will take precedence.
+
+        If you set ``follow`` to ``True`` the client will follow any redirects
+        and a ``redirect_chain`` attribute will be set in the response object
+        containing tuples of the intermediate urls and status codes.
+
+        If you had a URL ``/redirect_me/`` that redirected to ``/next/``, that
+        redirected to ``/final/``, this is what you'd see::
+
+            >>> response = c.get('/redirect_me/', follow=True)
+            >>> response.redirect_chain
+            [(u'http://testserver/next/', 302), (u'http://testserver/final/', 302)]
+
+        If you set ``secure`` to ``True`` the client will emulate an HTTPS
+        request.
+
+    .. method:: Client.post(path, data={}, content_type=MULTIPART_CONTENT, follow=False, secure=False, **extra)
+
+        Makes a POST request on the provided ``path`` and returns a
+        ``Response`` object, which is documented below.
+
+        The key-value pairs in the ``data`` dictionary are used to submit POST
+        data. For example::
+
+            >>> c = Client()
+            >>> c.post('/login/', {'name': 'fred', 'passwd': 'secret'})
+
+        ...will result in the evaluation of a POST request to this URL::
+
+            /login/
+
+        ...with this POST data::
+
+            name=fred&passwd=secret
+
+        If you provide ``content_type`` (e.g. :mimetype:`text/xml` for an XML
+        payload), the contents of ``data`` will be sent as-is in the POST
+        request, using ``content_type`` in the HTTP ``Content-Type`` header.
+
+        If you don't provide a value for ``content_type``, the values in
+        ``data`` will be transmitted with a content type of
+        :mimetype:`multipart/form-data`. In this case, the key-value pairs in
+        ``data`` will be encoded as a multipart message and used to create the
+        POST data payload.
+
+        To submit multiple values for a given key -- for example, to specify
+        the selections for a ``<select multiple>`` -- provide the values as a
+        list or tuple for the required key. For example, this value of ``data``
+        would submit three selected values for the field named ``choices``::
+
+            {'choices': ('a', 'b', 'd')}
+
+        Submitting files is a special case. To POST a file, you need only
+        provide the file field name as a key, and a file handle to the file you
+        wish to upload as a value. For example::
+
+            >>> c = Client()
+            >>> with open('wishlist.doc') as fp:
+            ...     c.post('/customers/wishes/', {'name': 'fred', 'attachment': fp})
+
+        (The name ``attachment`` here is not relevant; use whatever name your
+        file-processing code expects.)
+
+        Note that if you wish to use the same file handle for multiple
+        ``post()`` calls then you will need to manually reset the file
+        pointer between posts. The easiest way to do this is to
+        manually close the file after it has been provided to
+        ``post()``, as demonstrated above.
+
+        You should also ensure that the file is opened in a way that
+        allows the data to be read. If your file contains binary data
+        such as an image, this means you will need to open the file in
+        ``rb`` (read binary) mode.
+
+        The ``extra`` argument acts the same as for :meth:`Client.get`.
+
+        If the URL you request with a POST contains encoded parameters, these
+        parameters will be made available in the request.GET data. For example,
+        if you were to make the request::
+
+        >>> c.post('/login/?visitor=true', {'name': 'fred', 'passwd': 'secret'})
+
+        ... the view handling this request could interrogate request.POST
+        to retrieve the username and password, and could interrogate request.GET
+        to determine if the user was a visitor.
+
+        If you set ``follow`` to ``True`` the client will follow any redirects
+        and a ``redirect_chain`` attribute will be set in the response object
+        containing tuples of the intermediate urls and status codes.
+
+        If you set ``secure`` to ``True`` the client will emulate an HTTPS
+        request.
+
+    .. method:: Client.head(path, data={}, follow=False, secure=False, **extra)
+
+        Makes a HEAD request on the provided ``path`` and returns a
+        ``Response`` object. This method works just like :meth:`Client.get`,
+        including the ``follow``, ``secure`` and ``extra`` arguments, except
+        it does not return a message body.
+
+    .. method:: Client.options(path, data='', content_type='application/octet-stream', follow=False, secure=False, **extra)
+
+        Makes an OPTIONS request on the provided ``path`` and returns a
+        ``Response`` object. Useful for testing RESTful interfaces.
+
+        When ``data`` is provided, it is used as the request body, and
+        a ``Content-Type`` header is set to ``content_type``.
+
+        The ``follow``, ``secure`` and ``extra`` arguments act the same as for
+        :meth:`Client.get`.
+
+    .. method:: Client.put(path, data='', content_type='application/octet-stream', follow=False, secure=False, **extra)
+
+        Makes a PUT request on the provided ``path`` and returns a
+        ``Response`` object. Useful for testing RESTful interfaces.
+
+        When ``data`` is provided, it is used as the request body, and
+        a ``Content-Type`` header is set to ``content_type``.
+
+        The ``follow``, ``secure`` and ``extra`` arguments act the same as for
+        :meth:`Client.get`.
+
+    .. method:: Client.patch(path, data='', content_type='application/octet-stream', follow=False, secure=False, **extra)
+
+        Makes a PATCH request on the provided ``path`` and returns a
+        ``Response`` object. Useful for testing RESTful interfaces.
+
+        The ``follow``, ``secure`` and ``extra`` arguments act the same as for
+        :meth:`Client.get`.
+
+    .. method:: Client.delete(path, data='', content_type='application/octet-stream', follow=False, secure=False, **extra)
+
+        Makes an DELETE request on the provided ``path`` and returns a
+        ``Response`` object. Useful for testing RESTful interfaces.
+
+        When ``data`` is provided, it is used as the request body, and
+        a ``Content-Type`` header is set to ``content_type``.
+
+        The ``follow``, ``secure`` and ``extra`` arguments act the same as for
+        :meth:`Client.get`.
+
+    .. method:: Client.login(**credentials)
+
+        If your site uses Django's :doc:`authentication system</topics/auth/index>`
+        and you deal with logging in users, you can use the test client's
+        ``login()`` method to simulate the effect of a user logging into the
+        site.
+
+        After you call this method, the test client will have all the cookies
+        and session data required to pass any login-based tests that may form
+        part of a view.
+
+        The format of the ``credentials`` argument depends on which
+        :ref:`authentication backend <authentication-backends>` you're using
+        (which is configured by your :setting:`AUTHENTICATION_BACKENDS`
+        setting). If you're using the standard authentication backend provided
+        by Django (``ModelBackend``), ``credentials`` should be the user's
+        username and password, provided as keyword arguments::
+
+            >>> c = Client()
+            >>> c.login(username='fred', password='secret')
+
+            # Now you can access a view that's only available to logged-in users.
+
+        If you're using a different authentication backend, this method may
+        require different credentials. It requires whichever credentials are
+        required by your backend's ``authenticate()`` method.
+
+        ``login()`` returns ``True`` if it the credentials were accepted and
+        login was successful.
+
+        Finally, you'll need to remember to create user accounts before you can
+        use this method. As we explained above, the test runner is executed
+        using a test database, which contains no users by default. As a result,
+        user accounts that are valid on your production site will not work
+        under test conditions. You'll need to create users as part of the test
+        suite -- either manually (using the Django model API) or with a test
+        fixture. Remember that if you want your test user to have a password,
+        you can't set the user's password by setting the password attribute
+        directly -- you must use the
+        :meth:`~django.contrib.auth.models.User.set_password()` function to
+        store a correctly hashed password. Alternatively, you can use the
+        :meth:`~django.contrib.auth.models.UserManager.create_user` helper
+        method to create a new user with a correctly hashed password.
+
+        .. versionadded:: 1.7
+
+            Requests made with :meth:`~django.test.Client.login` go through the
+            request middleware. If you need to control the environment, you can
+            do so at :class:`~django.test.Client` instantiation or with the
+            `Client.defaults` attribute.
+
+    .. method:: Client.logout()
+
+        If your site uses Django's :doc:`authentication system</topics/auth/index>`,
+        the ``logout()`` method can be used to simulate the effect of a user
+        logging out of your site.
+
+        After you call this method, the test client will have all the cookies
+        and session data cleared to defaults. Subsequent requests will appear
+        to come from an :class:`~django.contrib.auth.models.AnonymousUser`.
+
+        .. versionadded:: 1.7
+
+            Requests made with :meth:`~django.test.Client.logout` go through the
+            request middleware. If you need to control the environment, you can
+            do so at :class:`~django.test.Client` instantiation or with the
+            `Client.defaults` attribute.
+
+Testing responses
+~~~~~~~~~~~~~~~~~
+
+The ``get()`` and ``post()`` methods both return a ``Response`` object. This
+``Response`` object is *not* the same as the ``HttpResponse`` object returned
+Django views; the test response object has some additional data useful for
+test code to verify.
+
+Specifically, a ``Response`` object has the following attributes:
+
+.. class:: Response()
+
+    .. attribute:: client
+
+        The test client that was used to make the request that resulted in the
+        response.
+
+    .. attribute:: content
+
+        The body of the response, as a string. This is the final page content as
+        rendered by the view, or any error message.
+
+    .. attribute:: context
+
+        The template ``Context`` instance that was used to render the template that
+        produced the response content.
+
+        If the rendered page used multiple templates, then ``context`` will be a
+        list of ``Context`` objects, in the order in which they were rendered.
+
+        Regardless of the number of templates used during rendering, you can
+        retrieve context values using the ``[]`` operator. For example, the
+        context variable ``name`` could be retrieved using::
+
+            >>> response = client.get('/foo/')
+            >>> response.context['name']
+            'Arthur'
+
+    .. attribute:: request
+
+        The request data that stimulated the response.
+
+    .. attribute:: wsgi_request
+
+        .. versionadded:: 1.7
+
+        The ``WSGIRequest`` instance generated by the test handler that
+        generated the response.
+
+    .. attribute:: status_code
+
+        The HTTP status of the response, as an integer. See
+        :rfc:`2616#section-10` for a full list of HTTP status codes.
+
+    .. attribute:: templates
+
+        A list of ``Template`` instances used to render the final content, in
+        the order they were rendered. For each template in the list, use
+        ``template.name`` to get the template's file name, if the template was
+        loaded from a file. (The name is a string such as
+        ``'admin/index.html'``.)
+
+You can also use dictionary syntax on the response object to query the value
+of any settings in the HTTP headers. For example, you could determine the
+content type of a response using ``response['Content-Type']``.
+
+Exceptions
+~~~~~~~~~~
+
+If you point the test client at a view that raises an exception, that exception
+will be visible in the test case. You can then use a standard ``try ... except``
+block or :meth:`~unittest.TestCase.assertRaises` to test for exceptions.
+
+The only exceptions that are not visible to the test client are ``Http404``,
+``PermissionDenied`` and ``SystemExit``. Django catches these exceptions
+internally and converts them into the appropriate HTTP response codes. In these
+cases, you can check ``response.status_code`` in your test.
+
+Persistent state
+~~~~~~~~~~~~~~~~
+
+The test client is stateful. If a response returns a cookie, then that cookie
+will be stored in the test client and sent with all subsequent ``get()`` and
+``post()`` requests.
+
+Expiration policies for these cookies are not followed. If you want a cookie
+to expire, either delete it manually or create a new ``Client`` instance (which
+will effectively delete all cookies).
+
+A test client has two attributes that store persistent state information. You
+can access these properties as part of a test condition.
+
+.. attribute:: Client.cookies
+
+    A Python :class:`~Cookie.SimpleCookie` object, containing the current values
+    of all the client cookies. See the documentation of the :mod:`Cookie` module
+    for more.
+
+.. attribute:: Client.session
+
+    A dictionary-like object containing session information. See the
+    :doc:`session documentation</topics/http/sessions>` for full details.
+
+    To modify the session and then save it, it must be stored in a variable
+    first (because a new ``SessionStore`` is created every time this property
+    is accessed)::
+
+        def test_something(self):
+            session = self.client.session
+            session['somekey'] = 'test'
+            session.save()
+
+Example
+~~~~~~~
+
+The following is a simple unit test using the test client::
+
+    import unittest
+    from django.test import Client
+
+    class SimpleTest(unittest.TestCase):
+        def setUp(self):
+            # Every test needs a client.
+            self.client = Client()
+
+        def test_details(self):
+            # Issue a GET request.
+            response = self.client.get('/customer/details/')
+
+            # Check that the response is 200 OK.
+            self.assertEqual(response.status_code, 200)
+
+            # Check that the rendered context contains 5 customers.
+            self.assertEqual(len(response.context['customers']), 5)
+
+.. seealso::
+
+    :class:`django.test.RequestFactory`
+
+.. _django-testcase-subclasses:
+
+Provided test case classes
+--------------------------
+
+Normal Python unit test classes extend a base class of
+:class:`unittest.TestCase`. Django provides a few extensions of this base class:
+
+.. _testcase_hierarchy_diagram:
+
+.. figure:: _images/django_unittest_classes_hierarchy.*
+   :alt: Hierarchy of Django unit testing classes (TestCase subclasses)
+   :width: 508
+   :height: 328
+
+   Hierarchy of Django unit testing classes
+
+SimpleTestCase
+~~~~~~~~~~~~~~
+
+.. class:: SimpleTestCase()
+
+A thin subclass of :class:`unittest.TestCase`, it extends it with some basic
+functionality like:
+
+* Saving and restoring the Python warning machinery state.
+* Some useful assertions like:
+
+  * Checking that a callable :meth:`raises a certain exception
+    <SimpleTestCase.assertRaisesMessage>`.
+  * Testing form field :meth:`rendering and error treatment
+    <SimpleTestCase.assertFieldOutput>`.
+  * Testing :meth:`HTML responses for the presence/lack of a given fragment
+    <SimpleTestCase.assertContains>`.
+  * Verifying that a template :meth:`has/hasn't been used to generate a given
+    response content <SimpleTestCase.assertTemplateUsed>`.
+  * Verifying a HTTP :meth:`redirect <SimpleTestCase.assertRedirects>` is
+    performed by the app.
+  * Robustly testing two :meth:`HTML fragments <SimpleTestCase.assertHTMLEqual>`
+    for equality/inequality or :meth:`containment <SimpleTestCase.assertInHTML>`.
+  * Robustly testing two :meth:`XML fragments <SimpleTestCase.assertXMLEqual>`
+    for equality/inequality.
+  * Robustly testing two :meth:`JSON fragments <SimpleTestCase.assertJSONEqual>`
+    for equality.
+
+* The ability to run tests with :ref:`modified settings <overriding-settings>`.
+* Using the :attr:`~SimpleTestCase.client` :class:`~django.test.Client`.
+* Custom test-time :attr:`URL maps <SimpleTestCase.urls>`.
+
+.. versionchanged:: 1.6
+
+    The latter two features were moved from ``TransactionTestCase`` to
+    ``SimpleTestCase`` in Django 1.6.
+
+If you need any of the other more complex and heavyweight Django-specific
+features like:
+
+* Testing or using the ORM.
+* Database :attr:`~TransactionTestCase.fixtures`.
+* Test :ref:`skipping based on database backend features <skipping-tests>`.
+* The remaining specialized :meth:`assert*
+  <TransactionTestCase.assertQuerysetEqual>` methods.
+
+then you should use :class:`~django.test.TransactionTestCase` or
+:class:`~django.test.TestCase` instead.
+
+``SimpleTestCase`` inherits from ``unittest.TestCase``.
+
+TransactionTestCase
+~~~~~~~~~~~~~~~~~~~
+
+.. class:: TransactionTestCase()
+
+Django's ``TestCase`` class (described below) makes use of database transaction
+facilities to speed up the process of resetting the database to a known state
+at the beginning of each test. A consequence of this, however, is that the
+effects of transaction commit and rollback cannot be tested by a Django
+``TestCase`` class. If your test requires testing of such transactional
+behavior, you should use a Django ``TransactionTestCase``.
+
+``TransactionTestCase`` and ``TestCase`` are identical except for the manner
+in which the database is reset to a known state and the ability for test code
+to test the effects of commit and rollback:
+
+* A ``TransactionTestCase`` resets the database after the test runs by
+  truncating all tables. A ``TransactionTestCase`` may call commit and rollback
+  and observe the effects of these calls on the database.
+
+* A ``TestCase``, on the other hand, does not truncate tables after a test.
+  Instead, it encloses the test code in a database transaction that is rolled
+  back at the end of the test. Both explicit commits like
+  ``transaction.commit()`` and implicit ones that may be caused by
+  ``transaction.atomic()`` are replaced with a ``nop`` operation. This
+  guarantees that the rollback at the end of the test restores the database to
+  its initial state.
+
+  When running on a database that does not support rollback (e.g. MySQL with the
+  MyISAM storage engine), ``TestCase`` falls back to initializing the database
+  by truncating tables and reloading initial data.
+
+.. warning::
+
+    While ``commit`` and ``rollback`` operations still *appear* to work when
+    used in ``TestCase``, no actual commit or rollback will be performed by the
+    database. This can cause your tests to pass or fail unexpectedly. Always
+    use ``TransactionTestCase`` when testing transactional behavior.
+
+``TransactionTestCase`` inherits from :class:`~django.test.SimpleTestCase`.
+
+TestCase
+~~~~~~~~
+
+.. class:: TestCase()
+
+This class provides some additional capabilities that can be useful for testing
+Web sites.
+
+Converting a normal :class:`unittest.TestCase` to a Django :class:`TestCase` is
+easy: Just change the base class of your test from ``'unittest.TestCase'`` to
+``'django.test.TestCase'``. All of the standard Python unit test functionality
+will continue to be available, but it will be augmented with some useful
+additions, including:
+
+* Automatic loading of fixtures.
+
+* Wraps each test in a transaction.
+
+* Creates a TestClient instance.
+
+* Django-specific assertions for testing for things like redirection and form
+  errors.
+
+``TestCase`` inherits from :class:`~django.test.TransactionTestCase`.
+
+.. _live-test-server:
+
+LiveServerTestCase
+~~~~~~~~~~~~~~~~~~
+
+.. class:: LiveServerTestCase()
+
+``LiveServerTestCase`` does basically the same as
+:class:`~django.test.TransactionTestCase` with one extra feature: it launches a
+live Django server in the background on setup, and shuts it down on teardown.
+This allows the use of automated test clients other than the
+:ref:`Django dummy client <test-client>` such as, for example, the Selenium_
+client, to execute a series of functional tests inside a browser and simulate a
+real user's actions.
+
+By default the live server's address is ``'localhost:8081'`` and the full URL
+can be accessed during the tests with ``self.live_server_url``. If you'd like
+to change the default address (in the case, for example, where the 8081 port is
+already taken) then you may pass a different one to the :djadmin:`test` command
+via the :djadminopt:`--liveserver` option, for example:
+
+.. code-block:: bash
+
+    ./manage.py test --liveserver=localhost:8082
+
+Another way of changing the default server address is by setting the
+`DJANGO_LIVE_TEST_SERVER_ADDRESS` environment variable somewhere in your
+code (for example, in a :ref:`custom test runner<topics-testing-test_runner>`):
+
+.. code-block:: python
+
+    import os
+    os.environ['DJANGO_LIVE_TEST_SERVER_ADDRESS'] = 'localhost:8082'
+
+In the case where the tests are run by multiple processes in parallel (for
+example, in the context of several simultaneous `continuous integration`_
+builds), the processes will compete for the same address, and therefore your
+tests might randomly fail with an "Address already in use" error. To avoid this
+problem, you can pass a comma-separated list of ports or ranges of ports (at
+least as many as the number of potential parallel processes). For example:
+
+.. code-block:: bash
+
+    ./manage.py test --liveserver=localhost:8082,8090-8100,9000-9200,7041
+
+Then, during test execution, each new live test server will try every specified
+port until it finds one that is free and takes it.
+
+.. _continuous integration: http://en.wikipedia.org/wiki/Continuous_integration
+
+To demonstrate how to use ``LiveServerTestCase``, let's write a simple Selenium
+test. First of all, you need to install the `selenium package`_ into your
+Python path:
+
+.. code-block:: bash
+
+   pip install selenium
+
+Then, add a ``LiveServerTestCase``-based test to your app's tests module
+(for example: ``myapp/tests.py``). The code for this test may look as follows:
+
+.. code-block:: python
+
+    from django.test import LiveServerTestCase
+    from selenium.webdriver.firefox.webdriver import WebDriver
+
+    class MySeleniumTests(LiveServerTestCase):
+        fixtures = ['user-data.json']
+
+        @classmethod
+        def setUpClass(cls):
+            cls.selenium = WebDriver()
+            super(MySeleniumTests, cls).setUpClass()
+
+        @classmethod
+        def tearDownClass(cls):
+            cls.selenium.quit()
+            super(MySeleniumTests, cls).tearDownClass()
+
+        def test_login(self):
+            self.selenium.get('%s%s' % (self.live_server_url, '/login/'))
+            username_input = self.selenium.find_element_by_name("username")
+            username_input.send_keys('myuser')
+            password_input = self.selenium.find_element_by_name("password")
+            password_input.send_keys('secret')
+            self.selenium.find_element_by_xpath('//input[@value="Log in"]').click()
+
+Finally, you may run the test as follows:
+
+.. code-block:: bash
+
+    ./manage.py test myapp.MySeleniumTests.test_login
+
+This example will automatically open Firefox then go to the login page, enter
+the credentials and press the "Log in" button. Selenium offers other drivers in
+case you do not have Firefox installed or wish to use another browser. The
+example above is just a tiny fraction of what the Selenium client can do; check
+out the `full reference`_ for more details.
+
+.. _Selenium: http://seleniumhq.org/
+.. _selenium package: https://pypi.python.org/pypi/selenium
+.. _full reference: http://selenium-python.readthedocs.org/en/latest/api.html
+.. _Firefox: http://www.mozilla.com/firefox/
+
+.. versionchanged:: 1.7
+
+    Before Django 1.7 ``LiveServerTestCase`` used to rely on the
+    :doc:`staticfiles contrib app </howto/static-files/index>` to get the
+    static assets of the application(s) under test transparently served at their
+    expected locations during the execution of these tests.
+
+    In Django 1.7 this dependency of core functionality on a ``contrib``
+    appplication has been removed, because of which ``LiveServerTestCase``
+    ability in this respect has been retrofitted to simply publish the contents
+    of the file system under :setting:`STATIC_ROOT` at the :setting:`STATIC_URL`
+    URL.
+
+    If you use the ``staticfiles`` app in your project and need to perform live
+    testing then you might want to consider using the
+    :class:`~django.contrib.staticfiles.testing.StaticLiveServerCase` subclass
+    shipped with it instead because it's the one that implements the original
+    behavior now. See :ref:`the relevant documentation
+    <staticfiles-testing-support>` for more details.
+
+.. note::
+
+    When using an in-memory SQLite database to run the tests, the same database
+    connection will be shared by two threads in parallel: the thread in which
+    the live server is run and the thread in which the test case is run. It's
+    important to prevent simultaneous database queries via this shared
+    connection by the two threads, as that may sometimes randomly cause the
+    tests to fail. So you need to ensure that the two threads don't access the
+    database at the same time. In particular, this means that in some cases
+    (for example, just after clicking a link or submitting a form), you might
+    need to check that a response is received by Selenium and that the next
+    page is loaded before proceeding with further test execution.
+    Do this, for example, by making Selenium wait until the ``<body>`` HTML tag
+    is found in the response (requires Selenium > 2.13):
+
+    .. code-block:: python
+
+        def test_login(self):
+            from selenium.webdriver.support.wait import WebDriverWait
+            timeout = 2
+            ...
+            self.selenium.find_element_by_xpath('//input[@value="Log in"]').click()
+            # Wait until the response is received
+            WebDriverWait(self.selenium, timeout).until(
+                lambda driver: driver.find_element_by_tag_name('body'))
+
+    The tricky thing here is that there's really no such thing as a "page load,"
+    especially in modern Web apps that generate HTML dynamically after the
+    server generates the initial document. So, simply checking for the presence
+    of ``<body>`` in the response might not necessarily be appropriate for all
+    use cases. Please refer to the `Selenium FAQ`_ and
+    `Selenium documentation`_ for more information.
+
+    .. _Selenium FAQ: http://code.google.com/p/selenium/wiki/FrequentlyAskedQuestions#Q:_WebDriver_fails_to_find_elements_/_Does_not_block_on_page_loa
+    .. _Selenium documentation: http://seleniumhq.org/docs/04_webdriver_advanced.html#explicit-waits
+
+Test cases features
+-------------------
+
+Default test client
+~~~~~~~~~~~~~~~~~~~
+
+.. attribute:: SimpleTestCase.client
+
+Every test case in a ``django.test.*TestCase`` instance has access to an
+instance of a Django test client. This client can be accessed as
+``self.client``. This client is recreated for each test, so you don't have to
+worry about state (such as cookies) carrying over from one test to another.
+
+This means, instead of instantiating a ``Client`` in each test::
+
+    import unittest
+    from django.test import Client
+
+    class SimpleTest(unittest.TestCase):
+        def test_details(self):
+            client = Client()
+            response = client.get('/customer/details/')
+            self.assertEqual(response.status_code, 200)
+
+        def test_index(self):
+            client = Client()
+            response = client.get('/customer/index/')
+            self.assertEqual(response.status_code, 200)
+
+...you can just refer to ``self.client``, like so::
+
+    from django.test import TestCase
+
+    class SimpleTest(TestCase):
+        def test_details(self):
+            response = self.client.get('/customer/details/')
+            self.assertEqual(response.status_code, 200)
+
+        def test_index(self):
+            response = self.client.get('/customer/index/')
+            self.assertEqual(response.status_code, 200)
+
+Customizing the test client
+~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. attribute:: SimpleTestCase.client_class
+
+If you want to use a different ``Client`` class (for example, a subclass
+with customized behavior), use the :attr:`~SimpleTestCase.client_class` class
+attribute::
+
+    from django.test import TestCase, Client
+
+    class MyTestClient(Client):
+        # Specialized methods for your environment...
+
+    class MyTest(TestCase):
+        client_class = MyTestClient
+
+        def test_my_stuff(self):
+            # Here self.client is an instance of MyTestClient...
+            call_some_test_code()
+
+.. _topics-testing-fixtures:
+
+Fixture loading
+~~~~~~~~~~~~~~~
+
+.. attribute:: TransactionTestCase.fixtures
+
+A test case for a database-backed Web site isn't much use if there isn't any
+data in the database. To make it easy to put test data into the database,
+Django's custom ``TransactionTestCase`` class provides a way of loading
+**fixtures**.
+
+A fixture is a collection of data that Django knows how to import into a
+database. For example, if your site has user accounts, you might set up a
+fixture of fake user accounts in order to populate your database during tests.
+
+The most straightforward way of creating a fixture is to use the
+:djadmin:`manage.py dumpdata <dumpdata>` command. This assumes you
+already have some data in your database. See the :djadmin:`dumpdata
+documentation<dumpdata>` for more details.
+
+.. note::
+
+    If you've ever run :djadmin:`manage.py migrate<migrate>`, you've
+    already used a fixture without even knowing it! When you call
+    :djadmin:`migrate` in the database for the first time, Django
+    installs a fixture called ``initial_data``. This gives you a way
+    of populating a new database with any initial data, such as a
+    default set of categories.
+
+    Fixtures with other names can always be installed manually using
+    the :djadmin:`manage.py loaddata<loaddata>` command.
+
+.. admonition:: Initial SQL data and testing
+
+    Django provides a second way to insert initial data into models --
+    the :ref:`custom SQL hook <initial-sql>`. However, this technique
+    *cannot* be used to provide initial data for testing purposes.
+    Django's test framework flushes the contents of the test database
+    after each test; as a result, any data added using the custom SQL
+    hook will be lost.
+
+Once you've created a fixture and placed it in a ``fixtures`` directory in one
+of your :setting:`INSTALLED_APPS`, you can use it in your unit tests by
+specifying a ``fixtures`` class attribute on your :class:`django.test.TestCase`
+subclass::
+
+    from django.test import TestCase
+    from myapp.models import Animal
+
+    class AnimalTestCase(TestCase):
+        fixtures = ['mammals.json', 'birds']
+
+        def setUp(self):
+            # Test definitions as before.
+            call_setup_methods()
+
+        def testFluffyAnimals(self):
+            # A test that uses the fixtures.
+            call_some_test_code()
+
+Here's specifically what will happen:
+
+* At the start of each test case, before ``setUp()`` is run, Django will
+  flush the database, returning the database to the state it was in
+  directly after :djadmin:`migrate` was called.
+
+* Then, all the named fixtures are installed. In this example, Django will
+  install any JSON fixture named ``mammals``, followed by any fixture named
+  ``birds``. See the :djadmin:`loaddata` documentation for more
+  details on defining and installing fixtures.
+
+This flush/load procedure is repeated for each test in the test case, so you
+can be certain that the outcome of a test will not be affected by another test,
+or by the order of test execution.
+
+By default, fixtures are only loaded into the ``default`` database. If you are
+using multiple databases and set :attr:`multi_db=True
+<TransactionTestCase.multi_db>`, fixtures will be loaded into all databases.
+
+URLconf configuration
+~~~~~~~~~~~~~~~~~~~~~
+
+.. attribute:: SimpleTestCase.urls
+
+If your application provides views, you may want to include tests that use the
+test client to exercise those views. However, an end user is free to deploy the
+views in your application at any URL of their choosing. This means that your
+tests can't rely upon the fact that your views will be available at a
+particular URL.
+
+In order to provide a reliable URL space for your test,
+``django.test.*TestCase`` classes provide the ability to customize the URLconf
+configuration for the duration of the execution of a test suite. If your
+``*TestCase`` instance defines an ``urls`` attribute, the ``*TestCase`` will use
+the value of that attribute as the :setting:`ROOT_URLCONF` for the duration
+of that test.
+
+For example::
+
+    from django.test import TestCase
+
+    class TestMyViews(TestCase):
+        urls = 'myapp.test_urls'
+
+        def testIndexPageView(self):
+            # Here you'd test your view using ``Client``.
+            call_some_test_code()
+
+This test case will use the contents of ``myapp.test_urls`` as the
+URLconf for the duration of the test case.
+
+.. _emptying-test-outbox:
+
+Multi-database support
+~~~~~~~~~~~~~~~~~~~~~~
+
+.. attribute:: TransactionTestCase.multi_db
+
+Django sets up a test database corresponding to every database that is
+defined in the :setting:`DATABASES` definition in your settings
+file. However, a big part of the time taken to run a Django TestCase
+is consumed by the call to ``flush`` that ensures that you have a
+clean database at the start of each test run. If you have multiple
+databases, multiple flushes are required (one for each database),
+which can be a time consuming activity -- especially if your tests
+don't need to test multi-database activity.
+
+As an optimization, Django only flushes the ``default`` database at
+the start of each test run. If your setup contains multiple databases,
+and you have a test that requires every database to be clean, you can
+use the ``multi_db`` attribute on the test suite to request a full
+flush.
+
+For example::
+
+    class TestMyViews(TestCase):
+        multi_db = True
+
+        def testIndexPageView(self):
+            call_some_test_code()
+
+This test case will flush *all* the test databases before running
+``testIndexPageView``.
+
+The ``multi_db`` flag also affects into which databases the
+attr:`TransactionTestCase.fixtures` are loaded. By default (when
+``multi_db=False``), fixtures are only loaded into the ``default`` database.
+If ``multi_db=True``, fixtures are loaded into all databases.
+
+.. _overriding-settings:
+
+Overriding settings
+~~~~~~~~~~~~~~~~~~~
+
+.. method:: SimpleTestCase.settings
+
+For testing purposes it's often useful to change a setting temporarily and
+revert to the original value after running the testing code. For this use case
+Django provides a standard Python context manager (see :pep:`343`) called
+:meth:`~django.test.SimpleTestCase.settings`, which can be used like this::
+
+    from django.test import TestCase
+
+    class LoginTestCase(TestCase):
+
+        def test_login(self):
+
+            # First check for the default behavior
+            response = self.client.get('/sekrit/')
+            self.assertRedirects(response, '/accounts/login/?next=/sekrit/')
+
+            # Then override the LOGIN_URL setting
+            with self.settings(LOGIN_URL='/other/login/'):
+                response = self.client.get('/sekrit/')
+                self.assertRedirects(response, '/other/login/?next=/sekrit/')
+
+This example will override the :setting:`LOGIN_URL` setting for the code
+in the ``with`` block and reset its value to the previous state afterwards.
+
+.. method:: SimpleTestCase.modify_settings
+
+.. versionadded:: 1.7
+
+It can prove unwieldy to redefine settings that contain a list of values. In
+practice, adding or removing values is often sufficient. The
+:meth:`~django.test.SimpleTestCase.modify_settings` context manager makes it
+easy::
+
+    from django.test import TestCase
+
+    class MiddlewareTestCase(TestCase):
+
+        def test_cache_middleware(self):
+            with self.modify_settings(MIDDLEWARE_CLASSES={
+                'append': 'django.middleware.cache.FetchFromCacheMiddleware',
+                'prepend': 'django.middleware.cache.UpdateCacheMiddleware',
+                'remove': [
+                    'django.contrib.sessions.middleware.SessionMiddleware',
+                    'django.contrib.auth.middleware.AuthenticationMiddleware',
+                    'django.contrib.messages.middleware.MessageMiddleware',
+                ],
+            }):
+                response = self.client.get('/')
+                # ...
+
+For each action, you can supply either a list of values or a string. When the
+value already exists in the list, ``append`` and ``prepend`` have no effect;
+neither does ``remove`` when the value doesn't exist.
+
+.. function:: override_settings
+
+In case you want to override a setting for a test method, Django provides the
+:func:`~django.test.override_settings` decorator (see :pep:`318`). It's used
+like this::
+
+    from django.test import TestCase, override_settings
+
+    class LoginTestCase(TestCase):
+
+        @override_settings(LOGIN_URL='/other/login/')
+        def test_login(self):
+            response = self.client.get('/sekrit/')
+            self.assertRedirects(response, '/other/login/?next=/sekrit/')
+
+The decorator can also be applied to :class:`~django.test.TestCase` classes::
+
+    from django.test import TestCase, override_settings
+
+    @override_settings(LOGIN_URL='/other/login/')
+    class LoginTestCase(TestCase):
+
+        def test_login(self):
+            response = self.client.get('/sekrit/')
+            self.assertRedirects(response, '/other/login/?next=/sekrit/')
+
+.. versionchanged:: 1.7
+
+    Previously, ``override_settings`` was imported from ``django.test.utils``.
+
+.. function:: modify_settings
+
+.. versionadded:: 1.7
+
+Likewise, Django provides the :func:`~django.test.modify_settings`
+decorator::
+
+    from django.test import TestCase, modify_settings
+
+    class MiddlewareTestCase(TestCase):
+
+        @modify_settings(MIDDLEWARE_CLASSES={
+            'append': 'django.middleware.cache.FetchFromCacheMiddleware',
+            'prepend': 'django.middleware.cache.UpdateCacheMiddleware',
+        })
+        def test_cache_middleware(self):
+            response = self.client.get('/')
+            # ...
+
+The decorator can also be applied to test case classes::
+
+    from django.test import TestCase, modify_settings
+
+    @modify_settings(MIDDLEWARE_CLASSES={
+        'append': 'django.middleware.cache.FetchFromCacheMiddleware',
+        'prepend': 'django.middleware.cache.UpdateCacheMiddleware',
+    })
+    class MiddlewareTestCase(TestCase):
+
+        def test_cache_middleware(self):
+            response = self.client.get('/')
+            # ...
+
+.. note::
+
+    When given a class, these decorators modify the class directly and return
+    it; they don't create and return a modified copy of it. So if you try to
+    tweak the above examples to assign the return value to a different name
+    than ``LoginTestCase`` or ``MiddlewareTestCase``, you may be surprised to
+    find that the original test case classes are still equally affected by the
+    decorator. For a given class, :func:`~django.test.modify_settings` is
+    always applied after :func:`~django.test.override_settings`.
+
+.. warning::
+
+    The settings file contains some settings that are only consulted during
+    initialization of Django internals. If you change them with
+    ``override_settings``, the setting is changed if you access it via the
+    ``django.conf.settings`` module, however, Django's internals access it
+    differently. Effectively, using :func:`~django.test.override_settings` or
+    :func:`~django.test.modify_settings` with these settings is probably not
+    going to do what you expect it to do.
+
+    We do not recommend altering the :setting:`DATABASES` setting. Altering
+    the :setting:`CACHES` setting is possible, but a bit tricky if you are
+    using internals that make using of caching, like
+    :mod:`django.contrib.sessions`. For example, you will have to reinitialize
+    the session backend in a test that uses cached sessions and overrides
+    :setting:`CACHES`.
+
+You can also simulate the absence of a setting by deleting it after settings
+have been overridden, like this::
+
+    @override_settings()
+    def test_something(self):
+        del settings.LOGIN_URL
+        ...
+
+When overriding settings, make sure to handle the cases in which your app's
+code uses a cache or similar feature that retains state even if the setting is
+changed. Django provides the :data:`django.test.signals.setting_changed`
+signal that lets you register callbacks to clean up and otherwise reset state
+when settings are changed.
+
+Django itself uses this signal to reset various data:
+
+================================ ========================
+Overridden settings              Data reset
+================================ ========================
+USE_TZ, TIME_ZONE                Databases timezone
+TEMPLATE_CONTEXT_PROCESSORS      Context processors cache
+TEMPLATE_LOADERS                 Template loaders cache
+SERIALIZATION_MODULES            Serializers cache
+LOCALE_PATHS, LANGUAGE_CODE      Default translation and loaded translations
+MEDIA_ROOT, DEFAULT_FILE_STORAGE Default file storage
+================================ ========================
+
+Emptying the test outbox
+~~~~~~~~~~~~~~~~~~~~~~~~
+
+If you use any of Django's custom ``TestCase`` classes, the test runner will
+clear the contents of the test email outbox at the start of each test case.
+
+For more detail on email services during tests, see `Email services`_ below.
+
+.. _assertions:
+
+Assertions
+~~~~~~~~~~
+
+As Python's normal :class:`unittest.TestCase` class implements assertion methods
+such as :meth:`~unittest.TestCase.assertTrue` and
+:meth:`~unittest.TestCase.assertEqual`, Django's custom :class:`TestCase` class
+provides a number of custom assertion methods that are useful for testing Web
+applications:
+
+The failure messages given by most of these assertion methods can be customized
+with the ``msg_prefix`` argument. This string will be prefixed to any failure
+message generated by the assertion. This allows you to provide additional
+details that may help you to identify the location and cause of an failure in
+your test suite.
+
+.. method:: SimpleTestCase.assertRaisesMessage(expected_exception, expected_message, callable_obj=None, *args, **kwargs)
+
+    Asserts that execution of callable ``callable_obj`` raised the
+    ``expected_exception`` exception and that such exception has an
+    ``expected_message`` representation. Any other outcome is reported as a
+    failure. Similar to unittest's :meth:`~unittest.TestCase.assertRaisesRegexp`
+    with the difference that ``expected_message`` isn't a regular expression.
+
+.. method:: SimpleTestCase.assertFieldOutput(self, fieldclass, valid, invalid, field_args=None, field_kwargs=None, empty_value=u'')
+
+    Asserts that a form field behaves correctly with various inputs.
+
+    :param fieldclass: the class of the field to be tested.
+    :param valid: a dictionary mapping valid inputs to their expected cleaned
+        values.
+    :param invalid: a dictionary mapping invalid inputs to one or more raised
+        error messages.
+    :param field_args: the args passed to instantiate the field.
+    :param field_kwargs: the kwargs passed to instantiate the field.
+    :param empty_value: the expected clean output for inputs in ``empty_values``.
+
+    For example, the following code tests that an ``EmailField`` accepts
+    "a@a.com" as a valid email address, but rejects "aaa" with a reasonable
+    error message::
+
+        self.assertFieldOutput(EmailField, {'a@a.com': 'a@a.com'}, {'aaa': [u'Enter a valid email address.']})
+
+.. method:: SimpleTestCase.assertFormError(response, form, field, errors, msg_prefix='')
+
+    Asserts that a field on a form raises the provided list of errors when
+    rendered on the form.
+
+    ``form`` is the name the ``Form`` instance was given in the template
+    context.
+
+    ``field`` is the name of the field on the form to check. If ``field``
+    has a value of ``None``, non-field errors (errors you can access via
+    ``form.non_field_errors()``) will be checked.
+
+    ``errors`` is an error string, or a list of error strings, that are
+    expected as a result of form validation.
+
+.. method:: SimpleTestCase.assertFormsetError(response, formset, form_index, field, errors, msg_prefix='')
+
+    .. versionadded:: 1.6
+
+    Asserts that the ``formset`` raises the provided list of errors when
+    rendered.
+
+    ``formset`` is the name the ``Formset`` instance was given in the template
+    context.
+
+    ``form_index`` is the number of the form within the ``Formset``.  If
+    ``form_index`` has a value of ``None``, non-form errors (errors you can
+    access via ``formset.non_form_errors()``) will be checked.
+
+    ``field`` is the name of the field on the form to check. If ``field``
+    has a value of ``None``, non-field errors (errors you can access via
+    ``form.non_field_errors()``) will be checked.
+
+    ``errors`` is an error string, or a list of error strings, that are
+    expected as a result of form validation.
+
+.. method:: SimpleTestCase.assertContains(response, text, count=None, status_code=200, msg_prefix='', html=False)
+
+    Asserts that a ``Response`` instance produced the given ``status_code`` and
+    that ``text`` appears in the content of the response. If ``count`` is
+    provided, ``text`` must occur exactly ``count`` times in the response.
+
+    Set ``html`` to ``True`` to handle ``text`` as HTML. The comparison with
+    the response content will be based on HTML semantics instead of
+    character-by-character equality. Whitespace is ignored in most cases,
+    attribute ordering is not significant. See
+    :meth:`~SimpleTestCase.assertHTMLEqual` for more details.
+
+.. method:: SimpleTestCase.assertNotContains(response, text, status_code=200, msg_prefix='', html=False)
+
+    Asserts that a ``Response`` instance produced the given ``status_code`` and
+    that ``text`` does not appears in the content of the response.
+
+    Set ``html`` to ``True`` to handle ``text`` as HTML. The comparison with
+    the response content will be based on HTML semantics instead of
+    character-by-character equality. Whitespace is ignored in most cases,
+    attribute ordering is not significant. See
+    :meth:`~SimpleTestCase.assertHTMLEqual` for more details.
+
+.. method:: SimpleTestCase.assertTemplateUsed(response, template_name, msg_prefix='')
+
+    Asserts that the template with the given name was used in rendering the
+    response.
+
+    The name is a string such as ``'admin/index.html'``.
+
+    You can use this as a context manager, like this::
+
+        with self.assertTemplateUsed('index.html'):
+            render_to_string('index.html')
+        with self.assertTemplateUsed(template_name='index.html'):
+            render_to_string('index.html')
+
+.. method:: SimpleTestCase.assertTemplateNotUsed(response, template_name, msg_prefix='')
+
+    Asserts that the template with the given name was *not* used in rendering
+    the response.
+
+    You can use this as a context manager in the same way as
+    :meth:`~SimpleTestCase.assertTemplateUsed`.
+
+.. method:: SimpleTestCase.assertRedirects(response, expected_url, status_code=302, target_status_code=200, msg_prefix='', fetch_redirect_response=True)
+
+    Asserts that the response return a ``status_code`` redirect status, it
+    redirected to ``expected_url`` (including any GET data), and the final
+    page was received with ``target_status_code``.
+
+    If your request used the ``follow`` argument, the ``expected_url`` and
+    ``target_status_code`` will be the url and status code for the final
+    point of the redirect chain.
+
+    .. versionadded:: 1.7
+
+    If ``fetch_redirect_response`` is ``False``, the final page won't be
+    loaded. Since the test client can't fetch externals URLs, this is
+    particularly useful if ``expected_url`` isn't part of your Django app.
+
+    .. versionadded:: 1.7
+
+    Scheme is handled correctly when making comparisons between two URLs. If
+    there isn't any scheme specified in the location where we are redirected to,
+    the original request's scheme is used. If present, the scheme in
+    ``expected_url`` is the one used to make the comparisons to.
+
+.. method:: SimpleTestCase.assertHTMLEqual(html1, html2, msg=None)
+
+    Asserts that the strings ``html1`` and ``html2`` are equal. The comparison
+    is based on HTML semantics. The comparison takes following things into
+    account:
+
+    * Whitespace before and after HTML tags is ignored.
+    * All types of whitespace are considered equivalent.
+    * All open tags are closed implicitly, e.g. when a surrounding tag is
+      closed or the HTML document ends.
+    * Empty tags are equivalent to their self-closing version.
+    * The ordering of attributes of an HTML element is not significant.
+    * Attributes without an argument are equal to attributes that equal in
+      name and value (see the examples).
+
+    The following examples are valid tests and don't raise any
+    ``AssertionError``::
+
+        self.assertHTMLEqual('<p>Hello <b>world!</p>',
+            '''<p>
+                Hello   <b>world! <b/>
+            </p>''')
+        self.assertHTMLEqual(
+            '<input type="checkbox" checked="checked" id="id_accept_terms" />',
+            '<input id="id_accept_terms" type='checkbox' checked>')
+
+    ``html1`` and ``html2`` must be valid HTML. An ``AssertionError`` will be
+    raised if one of them cannot be parsed.
+
+    Output in case of error can be customized with the ``msg`` argument.
+
+.. method:: SimpleTestCase.assertHTMLNotEqual(html1, html2, msg=None)
+
+    Asserts that the strings ``html1`` and ``html2`` are *not* equal. The
+    comparison is based on HTML semantics. See
+    :meth:`~SimpleTestCase.assertHTMLEqual` for details.
+
+    ``html1`` and ``html2`` must be valid HTML. An ``AssertionError`` will be
+    raised if one of them cannot be parsed.
+
+    Output in case of error can be customized with the ``msg`` argument.
+
+.. method:: SimpleTestCase.assertXMLEqual(xml1, xml2, msg=None)
+
+    Asserts that the strings ``xml1`` and ``xml2`` are equal. The
+    comparison is based on XML semantics. Similarly to
+    :meth:`~SimpleTestCase.assertHTMLEqual`, the comparison is
+    made on parsed content, hence only semantic differences are considered, not
+    syntax differences. When unvalid XML is passed in any parameter, an
+    ``AssertionError`` is always raised, even if both string are identical.
+
+    Output in case of error can be customized with the ``msg`` argument.
+
+.. method:: SimpleTestCase.assertXMLNotEqual(xml1, xml2, msg=None)
+
+    Asserts that the strings ``xml1`` and ``xml2`` are *not* equal. The
+    comparison is based on XML semantics. See
+    :meth:`~SimpleTestCase.assertXMLEqual` for details.
+
+    Output in case of error can be customized with the ``msg`` argument.
+
+.. method:: SimpleTestCase.assertInHTML(needle, haystack, count=None, msg_prefix='')
+
+    Asserts that the HTML fragment ``needle`` is contained in the ``haystack`` one.
+
+    If the ``count`` integer argument is specified, then additionally the number
+    of ``needle`` occurrences will be strictly verified.
+
+    Whitespace in most cases is ignored, and attribute ordering is not
+    significant. The passed-in arguments must be valid HTML.
+
+.. method:: SimpleTestCase.assertJSONEqual(raw, expected_data, msg=None)
+
+    Asserts that the JSON fragments ``raw`` and ``expected_data`` are equal.
+    Usual JSON non-significant whitespace rules apply as the heavyweight is
+    delegated to the :mod:`json` library.
+
+    Output in case of error can be customized with the ``msg`` argument.
+
+.. method:: TransactionTestCase.assertQuerysetEqual(qs, values, transform=repr, ordered=True)
+
+    Asserts that a queryset ``qs`` returns a particular list of values ``values``.
+
+    The comparison of the contents of ``qs`` and ``values`` is performed using
+    the function ``transform``; by default, this means that the ``repr()`` of
+    each value is compared. Any other callable can be used if ``repr()`` doesn't
+    provide a unique or helpful comparison.
+
+    By default, the comparison is also ordering dependent. If ``qs`` doesn't
+    provide an implicit ordering, you can set the ``ordered`` parameter to
+    ``False``, which turns the comparison into a Python set comparison.
+
+    .. versionchanged:: 1.6
+
+        The method now checks for undefined order and raises ``ValueError``
+        if undefined order is spotted. The ordering is seen as undefined if
+        the given ``qs`` isn't ordered and the comparison is against more
+        than one ordered values.
+
+.. method:: TransactionTestCase.assertNumQueries(num, func, *args, **kwargs)
+
+    Asserts that when ``func`` is called with ``*args`` and ``**kwargs`` that
+    ``num`` database queries are executed.
+
+    If a ``"using"`` key is present in ``kwargs`` it is used as the database
+    alias for which to check the number of queries.  If you wish to call a
+    function with a ``using`` parameter you can do it by wrapping the call with
+    a ``lambda`` to add an extra parameter::
+
+        self.assertNumQueries(7, lambda: my_function(using=7))
+
+    You can also use this as a context manager::
+
+        with self.assertNumQueries(2):
+            Person.objects.create(name="Aaron")
+            Person.objects.create(name="Daniel")
+
+.. _topics-testing-email:
+
+Email services
+--------------
+
+If any of your Django views send email using :doc:`Django's email
+functionality </topics/email>`, you probably don't want to send email each time
+you run a test using that view. For this reason, Django's test runner
+automatically redirects all Django-sent email to a dummy outbox. This lets you
+test every aspect of sending email -- from the number of messages sent to the
+contents of each message -- without actually sending the messages.
+
+The test runner accomplishes this by transparently replacing the normal
+email backend with a testing backend.
+(Don't worry -- this has no effect on any other email senders outside of
+Django, such as your machine's mail server, if you're running one.)
+
+.. currentmodule:: django.core.mail
+
+.. data:: django.core.mail.outbox
+
+During test running, each outgoing email is saved in
+``django.core.mail.outbox``. This is a simple list of all
+:class:`~django.core.mail.EmailMessage` instances that have been sent.
+The ``outbox`` attribute is a special attribute that is created *only* when
+the ``locmem`` email backend is used. It doesn't normally exist as part of the
+:mod:`django.core.mail` module and you can't import it directly. The code
+below shows how to access this attribute correctly.
+
+Here's an example test that examines ``django.core.mail.outbox`` for length
+and contents::
+
+    from django.core import mail
+    from django.test import TestCase
+
+    class EmailTest(TestCase):
+        def test_send_email(self):
+            # Send message.
+            mail.send_mail('Subject here', 'Here is the message.',
+                'from@example.com', ['to@example.com'],
+                fail_silently=False)
+
+            # Test that one message has been sent.
+            self.assertEqual(len(mail.outbox), 1)
+
+            # Verify that the subject of the first message is correct.
+            self.assertEqual(mail.outbox[0].subject, 'Subject here')
+
+As noted :ref:`previously <emptying-test-outbox>`, the test outbox is emptied
+at the start of every test in a Django ``*TestCase``. To empty the outbox
+manually, assign the empty list to ``mail.outbox``::
+
+    from django.core import mail
+
+    # Empty the test outbox
+    mail.outbox = []
+
+.. _skipping-tests:
+
+Skipping tests
+--------------
+
+.. currentmodule:: django.test
+
+The unittest library provides the :func:`@skipIf <unittest.skipIf>` and
+:func:`@skipUnless <unittest.skipUnless>` decorators to allow you to skip tests
+if you know ahead of time that those tests are going to fail under certain
+conditions.
+
+For example, if your test requires a particular optional library in order to
+succeed, you could decorate the test case with :func:`@skipIf
+<unittest.skipIf>`. Then, the test runner will report that the test wasn't
+executed and why, instead of failing the test or omitting the test altogether.
+
+To supplement these test skipping behaviors, Django provides two
+additional skip decorators. Instead of testing a generic boolean,
+these decorators check the capabilities of the database, and skip the
+test if the database doesn't support a specific named feature.
+
+The decorators use a string identifier to describe database features.
+This string corresponds to attributes of the database connection
+features class. See ``django.db.backends.BaseDatabaseFeatures``
+class for a full list of database features that can be used as a basis
+for skipping tests.
+
+.. function:: skipIfDBFeature(feature_name_string)
+
+Skip the decorated test or ``TestCase`` if the named database feature is
+supported.
+
+For example, the following test will not be executed if the database
+supports transactions (e.g., it would *not* run under PostgreSQL, but
+it would under MySQL with MyISAM tables)::
+
+    class MyTests(TestCase):
+        @skipIfDBFeature('supports_transactions')
+        def test_transaction_behavior(self):
+            # ... conditional test code
+
+.. versionchanged:: 1.7
+
+    ``skipIfDBFeature`` can now be used to decorate a ``TestCase`` class.
+
+.. function:: skipUnlessDBFeature(feature_name_string)
+
+Skip the decorated test or ``TestCase`` if the named database feature is *not*
+supported.
+
+For example, the following test will only be executed if the database
+supports transactions (e.g., it would run under PostgreSQL, but *not*
+under MySQL with MyISAM tables)::
+
+    class MyTests(TestCase):
+        @skipUnlessDBFeature('supports_transactions')
+        def test_transaction_behavior(self):
+            # ... conditional test code
+
+.. versionchanged:: 1.7
+
+    ``skipUnlessDBFeature`` can now be used to decorate a ``TestCase`` class.
diff --git a/scripts/manage_translations.py b/scripts/manage_translations.py
index 83d5b87c87..078cc7f9bb 100644
--- a/scripts/manage_translations.py
+++ b/scripts/manage_translations.py
@@ -88,7 +88,7 @@ def update_catalogs(resources=None, languages=None):
 
     os.chdir(os.path.join(os.getcwd(), 'django'))
     print("Updating main en catalog")
-    call_command('makemessages', locale='en')
+    call_command('makemessages', locale=['en'])
     _check_diff('core', os.path.join(os.getcwd(), 'conf', 'locale'))
 
     # Contrib catalogs
@@ -96,9 +96,9 @@ def update_catalogs(resources=None, languages=None):
         os.chdir(os.path.join(dir_, '..'))
         print("Updating en catalog in %s" % dir_)
         if name.endswith('-js'):
-            call_command('makemessages', locale='en', domain='djangojs')
+            call_command('makemessages', locale=['en'], domain='djangojs')
         else:
-            call_command('makemessages', locale='en')
+            call_command('makemessages', locale=['en'])
         _check_diff(name, dir_)
 
 
diff --git a/setup.cfg b/setup.cfg
index ac1e029e90..ef3fc9c873 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -3,7 +3,7 @@ doc_files = docs extras AUTHORS INSTALL LICENSE README.rst
 install-script = scripts/rpm-install.sh
 
 [flake8]
-exclude=.git,./django/utils/dictconfig.py,./django/contrib/comments/*,./django/utils/unittest.py,./django/utils/lru_cache.py,./tests/comment_tests/*,./django/test/_doctest.py,./django/utils/six.py,./django/conf/app_template/*
+exclude=build,.git,./django/utils/dictconfig.py,./django/contrib/comments/*,./django/utils/unittest.py,./django/utils/lru_cache.py,./tests/comment_tests/*,./django/test/_doctest.py,./django/utils/six.py,./django/conf/app_template/*
 ignore=E128,E501,W601
 
 [metadata]
diff --git a/tests/admin_custom_urls/tests.py b/tests/admin_custom_urls/tests.py
index f7a469efe9..d629c78e04 100644
--- a/tests/admin_custom_urls/tests.py
+++ b/tests/admin_custom_urls/tests.py
@@ -3,8 +3,7 @@ from __future__ import unicode_literals
 from django.contrib.admin.utils import quote
 from django.core.urlresolvers import reverse
 from django.template.response import TemplateResponse
-from django.test import TestCase
-from django.test.utils import override_settings
+from django.test import TestCase, override_settings
 
 from .models import Action, Person, Car
 
diff --git a/tests/admin_docs/tests.py b/tests/admin_docs/tests.py
index 047bf920a2..d2f8386bdb 100644
--- a/tests/admin_docs/tests.py
+++ b/tests/admin_docs/tests.py
@@ -5,32 +5,23 @@ from django.contrib.sites.models import Site
 from django.contrib.admindocs import utils
 from django.contrib.auth.models import User
 from django.core.urlresolvers import reverse
-from django.test import TestCase
-from django.test.utils import override_settings
+from django.test import TestCase, modify_settings, override_settings
 
 
 class MiscTests(TestCase):
     urls = 'admin_docs.urls'
 
     def setUp(self):
-        self._old_installed = Site._meta.app_config.installed
         User.objects.create_superuser('super', None, 'secret')
         self.client.login(username='super', password='secret')
 
-    def tearDown(self):
-        Site._meta.app_config.installed = self._old_installed
-
-    @override_settings(
-        SITE_ID=None,
-        INSTALLED_APPS=[app for app in settings.INSTALLED_APPS
-                        if app != 'django.contrib.sites'],
-    )
+    @modify_settings(INSTALLED_APPS={'remove': 'django.contrib.sites'})
+    @override_settings(SITE_ID=None)    # will restore SITE_ID after the test
     def test_no_sites_framework(self):
         """
         Without the sites framework, should not access SITE_ID or Site
         objects. Deleting settings is fine here as UserSettingsHolder is used.
         """
-        Site._meta.app_config.installed = False
         Site.objects.all().delete()
         del settings.SITE_ID
         self.client.get('/admindocs/views/')  # should not raise
diff --git a/tests/admin_filters/tests.py b/tests/admin_filters/tests.py
index 7381447051..17c67929dc 100644
--- a/tests/admin_filters/tests.py
+++ b/tests/admin_filters/tests.py
@@ -8,9 +8,9 @@ from django.contrib.admin.views.main import ChangeList
 from django.contrib.auth.admin import UserAdmin
 from django.contrib.auth.models import User
 from django.core.exceptions import ImproperlyConfigured
-from django.test import TestCase, RequestFactory
-from django.test.utils import override_settings, six
+from django.test import TestCase, RequestFactory, override_settings
 from django.utils.encoding import force_text
+from django.utils import six
 
 from .models import Book, Department, Employee
 
diff --git a/tests/admin_inlines/tests.py b/tests/admin_inlines/tests.py
index 8d6fc97426..e840e21b81 100644
--- a/tests/admin_inlines/tests.py
+++ b/tests/admin_inlines/tests.py
@@ -4,8 +4,7 @@ from django.contrib.admin.tests import AdminSeleniumWebDriverTestCase
 from django.contrib.admin.helpers import InlineAdminForm
 from django.contrib.auth.models import User, Permission
 from django.contrib.contenttypes.models import ContentType
-from django.test import TestCase
-from django.test.utils import override_settings
+from django.test import TestCase, override_settings
 
 # local test models
 from .admin import InnerInline
diff --git a/tests/app_cache/__init__.py b/tests/admin_scripts/complex_app/management/__init__.py
similarity index 100%
rename from tests/app_cache/__init__.py
rename to tests/admin_scripts/complex_app/management/__init__.py
diff --git a/tests/invalid_models/__init__.py b/tests/admin_scripts/complex_app/management/commands/__init__.py
similarity index 100%
rename from tests/invalid_models/__init__.py
rename to tests/admin_scripts/complex_app/management/commands/__init__.py
diff --git a/tests/admin_scripts/complex_app/management/commands/duplicate.py b/tests/admin_scripts/complex_app/management/commands/duplicate.py
new file mode 100644
index 0000000000..11b183843f
--- /dev/null
+++ b/tests/admin_scripts/complex_app/management/commands/duplicate.py
@@ -0,0 +1,7 @@
+from django.core.management.base import NoArgsCommand
+
+
+class Command(NoArgsCommand):
+
+    def handle_noargs(self, **options):
+        self.stdout.write('complex_app')
diff --git a/tests/admin_scripts/management/commands/app_command.py b/tests/admin_scripts/management/commands/app_command.py
index 5cbddb6e96..4706645484 100644
--- a/tests/admin_scripts/management/commands/app_command.py
+++ b/tests/admin_scripts/management/commands/app_command.py
@@ -4,7 +4,7 @@ from django.core.management.base import AppCommand
 class Command(AppCommand):
     help = 'Test Application-based commands'
     requires_model_validation = False
-    args = '[appname ...]'
+    args = '[app_label ...]'
 
-    def handle_app(self, app, **options):
-        print('EXECUTE:AppCommand app=%s, options=%s' % (app, sorted(options.items())))
+    def handle_app_config(self, app_config, **options):
+        print('EXECUTE:AppCommand name=%s, options=%s' % (app_config.name, sorted(options.items())))
diff --git a/tests/invalid_models/invalid_models/__init__.py b/tests/admin_scripts/simple_app/management/__init__.py
similarity index 100%
rename from tests/invalid_models/invalid_models/__init__.py
rename to tests/admin_scripts/simple_app/management/__init__.py
diff --git a/tests/syndication/__init__.py b/tests/admin_scripts/simple_app/management/commands/__init__.py
similarity index 100%
rename from tests/syndication/__init__.py
rename to tests/admin_scripts/simple_app/management/commands/__init__.py
diff --git a/tests/admin_scripts/simple_app/management/commands/duplicate.py b/tests/admin_scripts/simple_app/management/commands/duplicate.py
new file mode 100644
index 0000000000..a451f3991c
--- /dev/null
+++ b/tests/admin_scripts/simple_app/management/commands/duplicate.py
@@ -0,0 +1,7 @@
+from django.core.management.base import NoArgsCommand
+
+
+class Command(NoArgsCommand):
+
+    def handle_noargs(self, **options):
+        self.stdout.write('simple_app')
diff --git a/tests/admin_scripts/tests.py b/tests/admin_scripts/tests.py
index 8f693bfd34..e052a1a6d7 100644
--- a/tests/admin_scripts/tests.py
+++ b/tests/admin_scripts/tests.py
@@ -25,7 +25,7 @@ from django.test.utils import str_prefix
 from django.utils.encoding import force_text
 from django.utils._os import upath
 from django.utils.six import StringIO
-from django.test import LiveServerTestCase
+from django.test import LiveServerTestCase, TestCase
 
 
 test_dir = os.path.realpath(os.path.join(os.environ['DJANGO_TEST_TEMP_DIR'], 'test_project'))
@@ -379,14 +379,14 @@ class DjangoAdminMinimalSettings(AdminScriptTestCase):
         args = ['sqlall', '--settings=test_project.settings', 'admin_scripts']
         out, err = self.run_django_admin(args)
         self.assertNoOutput(out)
-        self.assertOutput(err, "No app with label 'admin_scripts'.")
+        self.assertOutput(err, "No installed app with label 'admin_scripts'.")
 
     def test_builtin_with_environment(self):
         "minimal: django-admin builtin commands fail if settings are provided in the environment"
         args = ['sqlall', 'admin_scripts']
         out, err = self.run_django_admin(args, 'test_project.settings')
         self.assertNoOutput(out)
-        self.assertOutput(err, "No app with label 'admin_scripts'.")
+        self.assertOutput(err, "No installed app with label 'admin_scripts'.")
 
     def test_builtin_with_bad_settings(self):
         "minimal: django-admin builtin commands fail if settings file (from argument) doesn't exist"
@@ -815,21 +815,21 @@ class ManageMinimalSettings(AdminScriptTestCase):
         args = ['sqlall', 'admin_scripts']
         out, err = self.run_manage(args)
         self.assertNoOutput(out)
-        self.assertOutput(err, "No app with label 'admin_scripts'.")
+        self.assertOutput(err, "No installed app with label 'admin_scripts'.")
 
     def test_builtin_with_settings(self):
         "minimal: manage.py builtin commands fail if settings are provided as argument"
         args = ['sqlall', '--settings=test_project.settings', 'admin_scripts']
         out, err = self.run_manage(args)
         self.assertNoOutput(out)
-        self.assertOutput(err, "No app with label 'admin_scripts'.")
+        self.assertOutput(err, "No installed app with label 'admin_scripts'.")
 
     def test_builtin_with_environment(self):
         "minimal: manage.py builtin commands fail if settings are provided in the environment"
         args = ['sqlall', 'admin_scripts']
         out, err = self.run_manage(args, 'test_project.settings')
         self.assertNoOutput(out)
-        self.assertOutput(err, "No app with label 'admin_scripts'.")
+        self.assertOutput(err, "No installed app with label 'admin_scripts'.")
 
     def test_builtin_with_bad_settings(self):
         "minimal: manage.py builtin commands fail if settings file (from argument) doesn't exist"
@@ -964,7 +964,7 @@ class ManageMultipleSettings(AdminScriptTestCase):
         args = ['sqlall', 'admin_scripts']
         out, err = self.run_manage(args)
         self.assertNoOutput(out)
-        self.assertOutput(err, "No app with label 'admin_scripts'.")
+        self.assertOutput(err, "No installed app with label 'admin_scripts'.")
 
     def test_builtin_with_settings(self):
         "multiple: manage.py builtin commands succeed if settings are provided as argument"
@@ -1094,7 +1094,7 @@ class ManageValidate(AdminScriptTestCase):
         self.assertOutput(err, 'ImportError')
 
     def test_complex_app(self):
-        "manage.py validate does not raise an ImportError validating a complex app with nested calls to load_app"
+        "manage.py validate does not raise an ImportError validating a complex app"
         self.write_settings('settings.py',
             apps=['admin_scripts.complex_app', 'admin_scripts.simple_app'],
             sdict={'DEBUG': True})
@@ -1416,39 +1416,36 @@ class CommandTypes(AdminScriptTestCase):
         args = ['app_command', 'auth']
         out, err = self.run_manage(args)
         self.assertNoOutput(err)
-        self.assertOutput(out, "EXECUTE:AppCommand app=<module 'django.contrib.auth.models'")
-        self.assertOutput(out, "module 'django.contrib.auth.models' from")
-        self.assertOutput(out, str_prefix("'>, options=[('no_color', False), ('pythonpath', None), ('settings', None), ('traceback', None), ('verbosity', %(_)s'1')]"))
+        self.assertOutput(out, "EXECUTE:AppCommand name=django.contrib.auth, options=")
+        self.assertOutput(out, str_prefix(", options=[('no_color', False), ('pythonpath', None), ('settings', None), ('traceback', None), ('verbosity', %(_)s'1')]"))
 
     def test_app_command_no_apps(self):
         "User AppCommands raise an error when no app name is provided"
         args = ['app_command']
         out, err = self.run_manage(args)
-        self.assertOutput(err, 'Error: Enter at least one appname.')
+        self.assertOutput(err, 'Error: Enter at least one application label.')
 
     def test_app_command_multiple_apps(self):
         "User AppCommands raise an error when multiple app names are provided"
         args = ['app_command', 'auth', 'contenttypes']
         out, err = self.run_manage(args)
         self.assertNoOutput(err)
-        self.assertOutput(out, "EXECUTE:AppCommand app=<module 'django.contrib.auth.models'")
-        self.assertOutput(out, "module 'django.contrib.auth.models' from")
-        self.assertOutput(out, str_prefix("'>, options=[('no_color', False), ('pythonpath', None), ('settings', None), ('traceback', None), ('verbosity', %(_)s'1')]"))
-        self.assertOutput(out, "EXECUTE:AppCommand app=<module 'django.contrib.contenttypes.models'")
-        self.assertOutput(out, "module 'django.contrib.contenttypes.models' from")
-        self.assertOutput(out, str_prefix("'>, options=[('no_color', False), ('pythonpath', None), ('settings', None), ('traceback', None), ('verbosity', %(_)s'1')]"))
+        self.assertOutput(out, "EXECUTE:AppCommand name=django.contrib.auth, options=")
+        self.assertOutput(out, str_prefix(", options=[('no_color', False), ('pythonpath', None), ('settings', None), ('traceback', None), ('verbosity', %(_)s'1')]"))
+        self.assertOutput(out, "EXECUTE:AppCommand name=django.contrib.contenttypes, options=")
+        self.assertOutput(out, str_prefix(", options=[('no_color', False), ('pythonpath', None), ('settings', None), ('traceback', None), ('verbosity', %(_)s'1')]"))
 
-    def test_app_command_invalid_appname(self):
+    def test_app_command_invalid_app_label(self):
         "User AppCommands can execute when a single app name is provided"
         args = ['app_command', 'NOT_AN_APP']
         out, err = self.run_manage(args)
-        self.assertOutput(err, "No app with label 'NOT_AN_APP'.")
+        self.assertOutput(err, "No installed app with label 'NOT_AN_APP'.")
 
-    def test_app_command_some_invalid_appnames(self):
+    def test_app_command_some_invalid_app_labels(self):
         "User AppCommands can execute when some of the provided app names are invalid"
         args = ['app_command', 'auth', 'NOT_AN_APP']
         out, err = self.run_manage(args)
-        self.assertOutput(err, "No app with label 'NOT_AN_APP'.")
+        self.assertOutput(err, "No installed app with label 'NOT_AN_APP'.")
 
     def test_label_command(self):
         "User LabelCommands can execute when a label is provided"
@@ -1472,6 +1469,24 @@ class CommandTypes(AdminScriptTestCase):
         self.assertOutput(out, str_prefix("EXECUTE:LabelCommand label=anotherlabel, options=[('no_color', False), ('pythonpath', None), ('settings', None), ('traceback', None), ('verbosity', %(_)s'1')]"))
 
 
+class Discovery(TestCase):
+
+    def test_precedence(self):
+        """
+        Apps listed first in INSTALLED_APPS have precendence.
+        """
+        with self.settings(INSTALLED_APPS=['admin_scripts.complex_app',
+                                           'admin_scripts.simple_app']):
+            out = StringIO()
+            call_command('duplicate', stdout=out)
+            self.assertEqual(out.getvalue().strip(), 'complex_app')
+        with self.settings(INSTALLED_APPS=['admin_scripts.simple_app',
+                                           'admin_scripts.complex_app']):
+            out = StringIO()
+            call_command('duplicate', stdout=out)
+            self.assertEqual(out.getvalue().strip(), 'simple_app')
+
+
 class ArgumentOrder(AdminScriptTestCase):
     """Tests for 2-stage argument parsing scheme.
 
diff --git a/tests/admin_views/admin.py b/tests/admin_views/admin.py
index 5a895958b0..ae12764897 100644
--- a/tests/admin_views/admin.py
+++ b/tests/admin_views/admin.py
@@ -12,28 +12,29 @@ from django.core.files.storage import FileSystemStorage
 from django.core.mail import EmailMessage
 from django.core.servers.basehttp import FileWrapper
 from django.conf.urls import patterns, url
-from django.db import models
 from django.forms.models import BaseModelFormSet
 from django.http import HttpResponse, StreamingHttpResponse
 from django.contrib.admin import BooleanFieldListFilter
 from django.utils.six import StringIO
 
-from .models import (Article, Chapter, Account, Media, Child, Parent, Picture,
-    Widget, DooHickey, Grommet, Whatsit, FancyDoodad, Category, Link,
+from .models import (Article, Chapter, Child, Parent, Picture, Widget,
+    DooHickey, Grommet, Whatsit, FancyDoodad, Category, Link,
     PrePopulatedPost, PrePopulatedSubPost, CustomArticle, Section,
-    ModelWithStringPrimaryKey, Color, Thing, Actor, Inquisition, Sketch, Person,
-    Persona, Subscriber, ExternalSubscriber, OldSubscriber, Vodcast, EmptyModel,
-    Fabric, Gallery, Language, Recommendation, Recommender, Collector, Post,
-    Gadget, Villain, SuperVillain, Plot, PlotDetails, CyclicOne, CyclicTwo,
-    WorkHour, Reservation, FoodDelivery, RowLevelChangePermissionModel, Paper,
+    ModelWithStringPrimaryKey, Color, Thing, Actor, Inquisition, Sketch,
+    Person, Persona, FooAccount, BarAccount, Subscriber, ExternalSubscriber,
+    OldSubscriber, Podcast, Vodcast, EmptyModel, Fabric, Gallery, Language,
+    Recommendation, Recommender, Collector, Post, Gadget, Villain,
+    SuperVillain, Plot, PlotDetails, CyclicOne, CyclicTwo, WorkHour,
+    Reservation, FoodDelivery, RowLevelChangePermissionModel, Paper,
     CoverLetter, Story, OtherStory, Book, Promo, ChapterXtra1, Pizza, Topping,
-    Album, Question, Answer, ComplexSortedPerson, PluggableSearchPerson, PrePopulatedPostLargeSlug,
-    AdminOrderedField, AdminOrderedModelMethod, AdminOrderedAdminMethod,
-    AdminOrderedCallable, Report, Color2, UnorderedObject, MainPrepopulated,
-    RelatedPrepopulated, UndeletableObject, UnchangeableObject, UserMessenger, Simple, Choice,
-    ShortMessage, Telegram, FilteredManager, EmptyModelHidden,
-    EmptyModelVisible, EmptyModelMixin, State, City, Restaurant, Worker,
-    ParentWithDependentChildren, DependentChild)
+    Album, Question, Answer, ComplexSortedPerson, PluggableSearchPerson,
+    PrePopulatedPostLargeSlug, AdminOrderedField, AdminOrderedModelMethod,
+    AdminOrderedAdminMethod, AdminOrderedCallable, Report, Color2,
+    UnorderedObject, MainPrepopulated, RelatedPrepopulated, UndeletableObject,
+    UnchangeableObject, UserMessenger, Simple, Choice, ShortMessage, Telegram,
+    FilteredManager, EmptyModelHidden, EmptyModelVisible, EmptyModelMixin,
+    State, City, Restaurant, Worker, ParentWithDependentChildren,
+    DependentChild)
 
 
 def callable_year(dt_value):
@@ -190,16 +191,6 @@ class PersonAdmin(admin.ModelAdmin):
         return super(PersonAdmin, self).get_queryset(request).order_by('age')
 
 
-class FooAccount(Account):
-    """A service-specific account of type Foo."""
-    servicename = 'foo'
-
-
-class BarAccount(Account):
-    """A service-specific account of type Bar."""
-    servicename = 'bar'
-
-
 class FooAccountAdmin(admin.StackedInline):
     model = FooAccount
     extra = 1
@@ -261,13 +252,6 @@ class ExternalSubscriberAdmin(admin.ModelAdmin):
     actions = [redirect_to, external_mail, download, no_perm]
 
 
-class Podcast(Media):
-    release_date = models.DateField()
-
-    class Meta:
-        ordering = ('release_date',)  # overridden in PodcastAdmin
-
-
 class PodcastAdmin(admin.ModelAdmin):
     list_display = ('name', 'release_date')
     list_editable = ('release_date',)
diff --git a/tests/admin_views/tests.py b/tests/admin_views/tests.py
index c813ee8437..d01a37725a 100644
--- a/tests/admin_views/tests.py
+++ b/tests/admin_views/tests.py
@@ -29,7 +29,7 @@ from django.forms.utils import ErrorList
 from django.template.response import TemplateResponse
 from django.test import TestCase
 from django.test.utils import patch_logger
-from django.test.utils import override_settings
+from django.test import override_settings
 from django.utils import formats
 from django.utils import translation
 from django.utils.cache import get_max_age
diff --git a/tests/admin_widgets/tests.py b/tests/admin_widgets/tests.py
index 04fe083eea..29dd5750ae 100644
--- a/tests/admin_widgets/tests.py
+++ b/tests/admin_widgets/tests.py
@@ -18,7 +18,7 @@ from django.core.files.storage import default_storage
 from django.core.files.uploadedfile import SimpleUploadedFile
 from django.db.models import CharField, DateField
 from django.test import TestCase as DjangoTestCase
-from django.test.utils import override_settings
+from django.test import override_settings
 from django.utils import six
 from django.utils import translation
 
@@ -993,9 +993,7 @@ class AdminRawIdWidgetSeleniumFirefoxTests(AdminSeleniumWebDriverTestCase):
 
         # The field now contains the selected band's id
         self.selenium.switch_to_window(main_window)
-        self.assertEqual(
-            self.selenium.find_element_by_id('id_main_band').get_attribute('value'),
-            '42')
+        self.wait_for_value('#id_main_band', '42')
 
         # Reopen the popup window and click on another band
         self.selenium.find_element_by_id('lookup_id_main_band').click()
@@ -1007,9 +1005,7 @@ class AdminRawIdWidgetSeleniumFirefoxTests(AdminSeleniumWebDriverTestCase):
 
         # The field now contains the other selected band's id
         self.selenium.switch_to_window(main_window)
-        self.assertEqual(
-            self.selenium.find_element_by_id('id_main_band').get_attribute('value'),
-            '98')
+        self.wait_for_value('#id_main_band', '98')
 
     def test_many_to_many(self):
         self.admin_login(username='super', password='secret', login_url='/')
@@ -1032,9 +1028,7 @@ class AdminRawIdWidgetSeleniumFirefoxTests(AdminSeleniumWebDriverTestCase):
 
         # The field now contains the selected band's id
         self.selenium.switch_to_window(main_window)
-        self.assertEqual(
-            self.selenium.find_element_by_id('id_supporting_bands').get_attribute('value'),
-            '42')
+        self.wait_for_value('#id_supporting_bands', '42')
 
         # Reopen the popup window and click on another band
         self.selenium.find_element_by_id('lookup_id_supporting_bands').click()
@@ -1046,9 +1040,7 @@ class AdminRawIdWidgetSeleniumFirefoxTests(AdminSeleniumWebDriverTestCase):
 
         # The field now contains the two selected bands' ids
         self.selenium.switch_to_window(main_window)
-        self.assertEqual(
-            self.selenium.find_element_by_id('id_supporting_bands').get_attribute('value'),
-            '42,98')
+        self.wait_for_value('#id_supporting_bands', '42,98')
 
 
 class AdminRawIdWidgetSeleniumChromeTests(AdminRawIdWidgetSeleniumFirefoxTests):
@@ -1087,14 +1079,12 @@ class RelatedFieldWidgetSeleniumFirefoxTests(AdminSeleniumWebDriverTestCase):
         save_button_css_selector = '.submit-row > input[type=submit]'
         self.selenium.find_element_by_css_selector(save_button_css_selector).click()
         self.selenium.switch_to_window(main_window)
-        # Wait up to 2 seconds for the new option to show up after clicking save in the popup.
-        self.selenium.implicitly_wait(2)
-        self.selenium.find_element_by_css_selector('#id_user option[value=newuser]')
-        self.selenium.implicitly_wait(0)
+        # The field now contains the new user
+        self.wait_for('#id_user option[value="newuser"]')
 
         # Go ahead and submit the form to make sure it works
         self.selenium.find_element_by_css_selector(save_button_css_selector).click()
-        self.wait_page_loaded()
+        self.wait_for_text('li.success', 'The profile "newuser" was added successfully.')
         profiles = models.Profile.objects.all()
         self.assertEqual(len(profiles), 1)
         self.assertEqual(profiles[0].user.username, username_value)
diff --git a/tests/app_cache/tests.py b/tests/app_cache/tests.py
deleted file mode 100644
index a531a22e8b..0000000000
--- a/tests/app_cache/tests.py
+++ /dev/null
@@ -1,51 +0,0 @@
-from __future__ import absolute_import
-
-from django.core.apps import app_cache
-from django.core.apps.cache import AppCache
-from django.db import models
-from django.test import TestCase
-
-from .models import TotallyNormal, SoAlternative, new_app_cache
-
-
-class AppCacheTests(TestCase):
-
-    def test_models_py(self):
-        """
-        Tests that the models in the models.py file were loaded correctly.
-        """
-        self.assertEqual(app_cache.get_model("app_cache", "TotallyNormal"), TotallyNormal)
-        self.assertEqual(app_cache.get_model("app_cache", "SoAlternative"), None)
-
-        self.assertEqual(new_app_cache.get_model("app_cache", "TotallyNormal"), None)
-        self.assertEqual(new_app_cache.get_model("app_cache", "SoAlternative"), SoAlternative)
-
-    def test_dynamic_load(self):
-        """
-        Makes a new model at runtime and ensures it goes into the right place.
-        """
-        old_models = app_cache.get_models(app_cache.get_app_config("app_cache").models_module)
-        # Construct a new model in a new app cache
-        body = {}
-        new_app_cache = AppCache()
-        meta_contents = {
-            'app_label': "app_cache",
-            'app_cache': new_app_cache,
-        }
-        meta = type("Meta", tuple(), meta_contents)
-        body['Meta'] = meta
-        body['__module__'] = TotallyNormal.__module__
-        temp_model = type("SouthPonies", (models.Model,), body)
-        # Make sure it appeared in the right place!
-        self.assertEqual(
-            old_models,
-            app_cache.get_models(app_cache.get_app_config("app_cache").models_module),
-        )
-        self.assertEqual(new_app_cache.get_model("app_cache", "SouthPonies"), temp_model)
-
-    def test_singleton_master(self):
-        """
-        Ensures that only one master app cache can exist.
-        """
-        with self.assertRaises(RuntimeError):
-            AppCache(master=True)
diff --git a/tests/app_loading/not_installed/models.py b/tests/app_loading/not_installed/models.py
index 1e4b59894c..09cf2ac6ed 100644
--- a/tests/app_loading/not_installed/models.py
+++ b/tests/app_loading/not_installed/models.py
@@ -2,12 +2,22 @@ from django.db import models
 
 
 class NotInstalledModel(models.Model):
-    pass
+
+    class Meta:
+        app_label = 'not_installed'
 
 
 class RelatedModel(models.Model):
+
+    class Meta:
+        app_label = 'not_installed'
+
     not_installed = models.ForeignKey(NotInstalledModel)
 
 
 class M2MRelatedModel(models.Model):
+
+    class Meta:
+        app_label = 'not_installed'
+
     not_installed = models.ManyToManyField(NotInstalledModel)
diff --git a/tests/app_loading/tests.py b/tests/app_loading/tests.py
index b32f510a24..63f47fa5fa 100644
--- a/tests/app_loading/tests.py
+++ b/tests/app_loading/tests.py
@@ -2,12 +2,11 @@ from __future__ import unicode_literals
 
 import os
 import sys
-from unittest import TestCase
 
-from django.core.apps import app_cache
-from django.core.apps.cache import AppCache
-from django.test.utils import override_settings
+from django.apps import apps
+from django.test import TestCase
 from django.utils._os import upath
+from django.utils import six
 
 
 class EggLoadingTest(TestCase):
@@ -16,73 +15,53 @@ class EggLoadingTest(TestCase):
         self.old_path = sys.path[:]
         self.egg_dir = '%s/eggs' % os.path.dirname(upath(__file__))
 
-        # The models need to be removed after the test in order to prevent bad
-        # interactions with the flush operation in other tests.
-        self._old_models = app_cache.app_configs['app_loading'].models.copy()
-
     def tearDown(self):
-        app_cache.app_configs['app_loading'].models = self._old_models
-        app_cache._get_models_cache = {}
-
+        apps.clear_cache()
         sys.path = self.old_path
 
     def test_egg1(self):
         """Models module can be loaded from an app in an egg"""
         egg_name = '%s/modelapp.egg' % self.egg_dir
         sys.path.append(egg_name)
-        models = app_cache.load_app('app_with_models')
-        self.assertFalse(models is None)
+        with self.settings(INSTALLED_APPS=['app_with_models']):
+            models_module = apps.get_app_config('app_with_models').models_module
+            self.assertIsNotNone(models_module)
+        del apps.all_models['app_with_models']
 
     def test_egg2(self):
         """Loading an app from an egg that has no models returns no models (and no error)"""
         egg_name = '%s/nomodelapp.egg' % self.egg_dir
         sys.path.append(egg_name)
-        models = app_cache.load_app('app_no_models')
-        self.assertTrue(models is None)
+        with self.settings(INSTALLED_APPS=['app_no_models']):
+            models_module = apps.get_app_config('app_no_models').models_module
+            self.assertIsNone(models_module)
+        del apps.all_models['app_no_models']
 
     def test_egg3(self):
         """Models module can be loaded from an app located under an egg's top-level package"""
         egg_name = '%s/omelet.egg' % self.egg_dir
         sys.path.append(egg_name)
-        models = app_cache.load_app('omelet.app_with_models')
-        self.assertFalse(models is None)
+        with self.settings(INSTALLED_APPS=['omelet.app_with_models']):
+            models_module = apps.get_app_config('app_with_models').models_module
+            self.assertIsNotNone(models_module)
+        del apps.all_models['app_with_models']
 
     def test_egg4(self):
         """Loading an app with no models from under the top-level egg package generates no error"""
         egg_name = '%s/omelet.egg' % self.egg_dir
         sys.path.append(egg_name)
-        models = app_cache.load_app('omelet.app_no_models')
-        self.assertTrue(models is None)
+        with self.settings(INSTALLED_APPS=['omelet.app_no_models']):
+            models_module = apps.get_app_config('app_no_models').models_module
+            self.assertIsNone(models_module)
+        del apps.all_models['app_no_models']
 
     def test_egg5(self):
         """Loading an app from an egg that has an import error in its models module raises that error"""
         egg_name = '%s/brokenapp.egg' % self.egg_dir
         sys.path.append(egg_name)
-        self.assertRaises(ImportError, app_cache.load_app, 'broken_app')
-        raised = None
-        try:
-            app_cache.load_app('broken_app')
-        except ImportError as e:
-            raised = e
-
-        # Make sure the message is indicating the actual
-        # problem in the broken app.
-        self.assertTrue(raised is not None)
-        self.assertTrue("modelz" in raised.args[0])
-
-    def test_missing_app(self):
-        """
-        Test that repeated app loading doesn't succeed in case there is an
-        error. Refs #17667.
-        """
-        app_cache = AppCache()
-        # Pretend we're the master app cache to test populate().
-        app_cache.master = True
-        with override_settings(INSTALLED_APPS=('notexists',)):
-            with self.assertRaises(ImportError):
-                app_cache.get_model('notexists', 'nomodel', seed_cache=True)
-            with self.assertRaises(ImportError):
-                app_cache.get_model('notexists', 'nomodel', seed_cache=True)
+        with six.assertRaisesRegex(self, ImportError, 'modelz'):
+            with self.settings(INSTALLED_APPS=['broken_app']):
+                pass
 
 
 class GetModelsTest(TestCase):
@@ -91,32 +70,10 @@ class GetModelsTest(TestCase):
         self.not_installed_module = models
 
     def test_get_model_only_returns_installed_models(self):
-        self.assertEqual(
-            app_cache.get_model("not_installed", "NotInstalledModel"), None)
-
-    def test_get_model_with_not_installed(self):
-        self.assertEqual(
-            app_cache.get_model(
-                "not_installed", "NotInstalledModel", only_installed=False),
-            self.not_installed_module.NotInstalledModel)
+        with self.assertRaises(LookupError):
+            apps.get_model("not_installed", "NotInstalledModel")
 
     def test_get_models_only_returns_installed_models(self):
-        self.assertFalse(
-            "NotInstalledModel" in
-            [m.__name__ for m in app_cache.get_models()])
-
-    def test_get_models_with_app_label_only_returns_installed_models(self):
-        self.assertEqual(app_cache.get_models(self.not_installed_module), [])
-
-    def test_get_models_with_not_installed(self):
-        self.assertTrue(
-            "NotInstalledModel" in [
-                m.__name__ for m in app_cache.get_models(only_installed=False)])
-
-
-class NotInstalledModelsTest(TestCase):
-    def test_related_not_installed_model(self):
-        from .not_installed.models import NotInstalledModel
-        self.assertEqual(
-            set(NotInstalledModel._meta.get_all_field_names()),
-            set(["id", "relatedmodel", "m2mrelatedmodel"]))
+        self.assertNotIn(
+            "NotInstalledModel",
+            [m.__name__ for m in apps.get_models()])
diff --git a/tests/apps/__init__.py b/tests/apps/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/tests/apps/apps.py b/tests/apps/apps.py
new file mode 100644
index 0000000000..a2c49fcbff
--- /dev/null
+++ b/tests/apps/apps.py
@@ -0,0 +1,34 @@
+from __future__ import unicode_literals
+
+from django.apps import AppConfig
+
+
+class MyAdmin(AppConfig):
+    name = 'django.contrib.admin'
+    verbose_name = "Admin sweet admin."
+
+
+class MyAuth(AppConfig):
+    name = 'django.contrib.auth'
+    verbose_name = "All your password are belong to us."
+
+
+class BadConfig(AppConfig):
+    """This class doesn't supply the mandatory 'name' attribute."""
+
+
+class NotAConfig(object):
+    name = 'apps'
+
+
+class NoSuchApp(AppConfig):
+    name = 'there is no such app'
+
+
+class PlainAppsConfig(AppConfig):
+    name = 'apps'
+
+
+class RelabeledAppsConfig(AppConfig):
+    name = 'apps'
+    label = 'relabeled'
diff --git a/tests/app_cache/models.py b/tests/apps/models.py
similarity index 51%
rename from tests/app_cache/models.py
rename to tests/apps/models.py
index 10e9e6f1de..d6907eced1 100644
--- a/tests/app_cache/models.py
+++ b/tests/apps/models.py
@@ -1,9 +1,12 @@
-from django.core.apps.cache import AppCache
+from __future__ import unicode_literals
+
+from django.apps.registry import Apps
 from django.db import models
 
-# We're testing app cache presence on load, so this is handy.
 
-new_app_cache = AppCache()
+# We're testing app registry presence on load, so this is handy.
+
+new_apps = Apps(['apps'])
 
 
 class TotallyNormal(models.Model):
@@ -14,4 +17,4 @@ class SoAlternative(models.Model):
     name = models.CharField(max_length=255)
 
     class Meta:
-        app_cache = new_app_cache
+        apps = new_apps
diff --git a/tests/apps/tests.py b/tests/apps/tests.py
new file mode 100644
index 0000000000..ad5fd0d609
--- /dev/null
+++ b/tests/apps/tests.py
@@ -0,0 +1,161 @@
+from __future__ import absolute_import, unicode_literals
+
+from django.apps import apps
+from django.apps.registry import Apps
+from django.core.exceptions import ImproperlyConfigured
+from django.db import models
+from django.test import TestCase, override_settings
+from django.utils import six
+
+from .models import TotallyNormal, SoAlternative, new_apps
+
+
+# Small list with a variety of cases for tests that iterate on installed apps.
+# Intentionally not in alphabetical order to check if the order is preserved.
+
+SOME_INSTALLED_APPS = [
+    'apps.apps.MyAdmin',
+    'apps.apps.MyAuth',
+    'django.contrib.contenttypes',
+    'django.contrib.sessions',
+    'django.contrib.messages',
+    'django.contrib.staticfiles',
+]
+
+SOME_INSTALLED_APPS_NAMES = [
+    'django.contrib.admin',
+    'django.contrib.auth',
+] + SOME_INSTALLED_APPS[2:]
+
+
+class AppsTests(TestCase):
+
+    def test_singleton_master(self):
+        """
+        Ensures that only one master registry can exist.
+        """
+        with self.assertRaises(RuntimeError):
+            Apps(installed_apps=None)
+
+    def test_ready(self):
+        """
+        Tests the ready property of the master registry.
+        """
+        # The master app registry is always ready when the tests run.
+        self.assertTrue(apps.ready)
+        # Non-master app registries are populated in __init__.
+        self.assertTrue(Apps().ready)
+
+    def test_bad_app_config(self):
+        """
+        Tests when INSTALLED_APPS contains an incorrect app config.
+        """
+        with self.assertRaises(ImproperlyConfigured):
+            with self.settings(INSTALLED_APPS=['apps.apps.BadConfig']):
+                pass
+
+    def test_not_an_app_config(self):
+        """
+        Tests when INSTALLED_APPS contains a class that isn't an app config.
+        """
+        with self.assertRaises(ImproperlyConfigured):
+            with self.settings(INSTALLED_APPS=['apps.apps.NotAConfig']):
+                pass
+
+    def test_no_such_app(self):
+        """
+        Tests when INSTALLED_APPS contains an app that doesn't exist, either
+        directly or via an app config.
+        """
+        with self.assertRaises(ImportError):
+            with self.settings(INSTALLED_APPS=['there is no such app']):
+                pass
+        with self.assertRaises(ImportError):
+            with self.settings(INSTALLED_APPS=['apps.apps.NoSuchApp']):
+                pass
+
+    def test_no_such_app_config(self):
+        """
+        Tests when INSTALLED_APPS contains an entry that doesn't exist.
+        """
+        with self.assertRaises(ImportError):
+            with self.settings(INSTALLED_APPS=['apps.apps.NoSuchConfig']):
+                pass
+
+    @override_settings(INSTALLED_APPS=SOME_INSTALLED_APPS)
+    def test_get_app_configs(self):
+        """
+        Tests get_app_configs().
+        """
+        app_configs = apps.get_app_configs()
+        self.assertListEqual(
+            [app_config.name for app_config in app_configs],
+            SOME_INSTALLED_APPS_NAMES)
+
+    @override_settings(INSTALLED_APPS=SOME_INSTALLED_APPS)
+    def test_get_app_config(self):
+        """
+        Tests get_app_config().
+        """
+        app_config = apps.get_app_config('admin')
+        self.assertEqual(app_config.name, 'django.contrib.admin')
+
+        app_config = apps.get_app_config('staticfiles')
+        self.assertEqual(app_config.name, 'django.contrib.staticfiles')
+
+        with self.assertRaises(LookupError):
+            apps.get_app_config('webdesign')
+
+    @override_settings(INSTALLED_APPS=SOME_INSTALLED_APPS)
+    def test_is_installed(self):
+        self.assertTrue(apps.is_installed('django.contrib.admin'))
+        self.assertTrue(apps.is_installed('django.contrib.staticfiles'))
+        self.assertFalse(apps.is_installed('django.contrib.webdesign'))
+
+    @override_settings(INSTALLED_APPS=['apps.apps.RelabeledAppsConfig'])
+    def test_relabeling(self):
+        self.assertEqual(apps.get_app_config('relabeled').name, 'apps')
+
+    def test_duplicate_labels(self):
+        with six.assertRaisesRegex(self, ImproperlyConfigured, "Application labels aren't unique"):
+            with self.settings(INSTALLED_APPS=['apps.apps.PlainAppsConfig', 'apps']):
+                pass
+
+    def test_duplicate_names(self):
+        with six.assertRaisesRegex(self, ImproperlyConfigured, "Application names aren't unique"):
+            with self.settings(INSTALLED_APPS=['apps.apps.RelabeledAppsConfig', 'apps']):
+                pass
+
+    def test_models_py(self):
+        """
+        Tests that the models in the models.py file were loaded correctly.
+        """
+        self.assertEqual(apps.get_model("apps", "TotallyNormal"), TotallyNormal)
+        with self.assertRaises(LookupError):
+            apps.get_model("apps", "SoAlternative")
+
+        with self.assertRaises(LookupError):
+            new_apps.get_model("apps", "TotallyNormal")
+        self.assertEqual(new_apps.get_model("apps", "SoAlternative"), SoAlternative)
+
+    def test_dynamic_load(self):
+        """
+        Makes a new model at runtime and ensures it goes into the right place.
+        """
+        old_models = list(apps.get_app_config("apps").get_models())
+        # Construct a new model in a new app registry
+        body = {}
+        new_apps = Apps(["apps"])
+        meta_contents = {
+            'app_label': "apps",
+            'apps': new_apps,
+        }
+        meta = type(str("Meta"), tuple(), meta_contents)
+        body['Meta'] = meta
+        body['__module__'] = TotallyNormal.__module__
+        temp_model = type(str("SouthPonies"), (models.Model,), body)
+        # Make sure it appeared in the right place!
+        self.assertListEqual(list(apps.get_app_config("apps").get_models()), old_models)
+        with self.assertRaises(LookupError):
+            apps.get_model("apps", "SouthPonies")
+        self.assertEqual(new_apps.get_model("apps", "SouthPonies"), temp_model)
diff --git a/tests/backends/tests.py b/tests/backends/tests.py
index 3a79b79411..a4743aeb41 100644
--- a/tests/backends/tests.py
+++ b/tests/backends/tests.py
@@ -20,9 +20,9 @@ from django.db.models import Sum, Avg, Variance, StdDev
 from django.db.models.fields import (AutoField, DateField, DateTimeField,
     DecimalField, IntegerField, TimeField)
 from django.db.utils import ConnectionHandler
-from django.test import (TestCase, skipUnlessDBFeature, skipIfDBFeature,
-    TransactionTestCase)
-from django.test.utils import override_settings, str_prefix
+from django.test import (TestCase, TransactionTestCase, override_settings,
+    skipUnlessDBFeature, skipIfDBFeature)
+from django.test.utils import str_prefix
 from django.utils import six
 from django.utils.six.moves import xrange
 
diff --git a/tests/base/models.py b/tests/base/models.py
index 23efdf9d5b..f84d64df53 100644
--- a/tests/base/models.py
+++ b/tests/base/models.py
@@ -5,7 +5,7 @@ from django.utils import six
 
 
 # The models definitions below used to crash. Generating models dynamically
-# at runtime is a bad idea because it pollutes the app cache. This doesn't
+# at runtime is a bad idea because it pollutes the app registry. This doesn't
 # integrate well with the test suite but at least it prevents regressions.
 
 
diff --git a/tests/bash_completion/tests.py b/tests/bash_completion/tests.py
index 6ff709809d..8653af3c85 100644
--- a/tests/bash_completion/tests.py
+++ b/tests/bash_completion/tests.py
@@ -5,7 +5,7 @@ import os
 import sys
 import unittest
 
-from django.conf import settings
+from django.apps import apps
 from django.core.management import ManagementUtility
 from django.utils.six import StringIO
 
@@ -84,5 +84,7 @@ class BashCompletionTests(unittest.TestCase):
         "Application names will be autocompleted for an AppCommand"
         self._user_input('django-admin.py sqlall a')
         output = self._run_autocomplete()
-        app_labels = [name.split('.')[-1] for name in settings.INSTALLED_APPS]
-        self.assertEqual(output, sorted(label for label in app_labels if label.startswith('a')))
+        a_labels = sorted(app_config.label
+            for app_config in apps.get_app_configs()
+            if app_config.label.startswith('a'))
+        self.assertEqual(output, a_labels)
diff --git a/tests/bulk_create/tests.py b/tests/bulk_create/tests.py
index 9bb95acb72..367cbde04d 100644
--- a/tests/bulk_create/tests.py
+++ b/tests/bulk_create/tests.py
@@ -4,7 +4,7 @@ from operator import attrgetter
 
 from django.db import connection
 from django.test import TestCase, skipIfDBFeature, skipUnlessDBFeature
-from django.test.utils import override_settings
+from django.test import override_settings
 
 from .models import Country, Restaurant, Pizzeria, State, TwoFields
 
diff --git a/tests/cache/tests.py b/tests/cache/tests.py
index 12e75e24b7..94790ed740 100644
--- a/tests/cache/tests.py
+++ b/tests/cache/tests.py
@@ -23,8 +23,8 @@ from django.middleware.cache import (FetchFromCacheMiddleware,
     UpdateCacheMiddleware, CacheMiddleware)
 from django.template import Template
 from django.template.response import TemplateResponse
-from django.test import TestCase, TransactionTestCase, RequestFactory
-from django.test.utils import (override_settings, IgnoreDeprecationWarningsMixin,
+from django.test import TestCase, TransactionTestCase, RequestFactory, override_settings
+from django.test.utils import (IgnoreDeprecationWarningsMixin,
     IgnorePendingDeprecationWarningsMixin)
 from django.utils import six
 from django.utils import timezone
@@ -1198,8 +1198,20 @@ class CacheUtils(TestCase):
     """TestCase for django.utils.cache functions."""
 
     def setUp(self):
+        self.host = 'www.example.com'
         self.path = '/cache/test/'
-        self.factory = RequestFactory()
+        self.factory = RequestFactory(HTTP_HOST=self.host)
+
+    def _get_request_cache(self, method='GET', query_string=None, update_cache=None):
+        request = self._get_request(self.host, self.path,
+                                    method, query_string=query_string)
+        request._cache_update_cache = True if not update_cache else update_cache
+        return request
+
+    def _set_cache(self, request, msg):
+        response = HttpResponse()
+        response.content = msg
+        return UpdateCacheMiddleware().process_response(request, response)
 
     def test_patch_vary_headers(self):
         headers = (
@@ -1229,10 +1241,19 @@ class CacheUtils(TestCase):
         self.assertEqual(get_cache_key(request), None)
         # Set headers to an empty list.
         learn_cache_key(request, response)
-        self.assertEqual(get_cache_key(request), 'views.decorators.cache.cache_page.settingsprefix.GET.9fa0fd092afb73bdce204bb4f94d5804.d41d8cd98f00b204e9800998ecf8427e')
+
+        self.assertEqual(
+            get_cache_key(request),
+            'views.decorators.cache.cache_page.settingsprefix.GET.'
+            '18a03f9c9649f7d684af5db3524f5c99.d41d8cd98f00b204e9800998ecf8427e'
+        )
         # Verify that a specified key_prefix is taken into account.
         learn_cache_key(request, response, key_prefix=key_prefix)
-        self.assertEqual(get_cache_key(request, key_prefix=key_prefix), 'views.decorators.cache.cache_page.localprefix.GET.9fa0fd092afb73bdce204bb4f94d5804.d41d8cd98f00b204e9800998ecf8427e')
+        self.assertEqual(
+            get_cache_key(request, key_prefix=key_prefix),
+            'views.decorators.cache.cache_page.localprefix.GET.'
+            '18a03f9c9649f7d684af5db3524f5c99.d41d8cd98f00b204e9800998ecf8427e'
+        )
 
     def test_get_cache_key_with_query(self):
         request = self.factory.get(self.path, {'test': 1})
@@ -1242,7 +1263,22 @@ class CacheUtils(TestCase):
         # Set headers to an empty list.
         learn_cache_key(request, response)
         # Verify that the querystring is taken into account.
-        self.assertEqual(get_cache_key(request), 'views.decorators.cache.cache_page.settingsprefix.GET.d11198ba31883732b0de5786a80cc12b.d41d8cd98f00b204e9800998ecf8427e')
+
+        self.assertEqual(
+            get_cache_key(request),
+            'views.decorators.cache.cache_page.settingsprefix.GET.'
+            'beaf87a9a99ee81c673ea2d67ccbec2a.d41d8cd98f00b204e9800998ecf8427e'
+        )
+
+    def test_cache_key_varies_by_url(self):
+        """
+        get_cache_key keys differ by fully-qualfied URL instead of path
+        """
+        request1 = self.factory.get(self.path, HTTP_HOST='sub-1.example.com')
+        learn_cache_key(request1, HttpResponse())
+        request2 = self.factory.get(self.path, HTTP_HOST='sub-2.example.com')
+        learn_cache_key(request2, HttpResponse())
+        self.assertTrue(get_cache_key(request1) != get_cache_key(request2))
 
     def test_learn_cache_key(self):
         request = self.factory.head(self.path)
@@ -1250,7 +1286,12 @@ class CacheUtils(TestCase):
         response['Vary'] = 'Pony'
         # Make sure that the Vary header is added to the key hash
         learn_cache_key(request, response)
-        self.assertEqual(get_cache_key(request), 'views.decorators.cache.cache_page.settingsprefix.GET.9fa0fd092afb73bdce204bb4f94d5804.d41d8cd98f00b204e9800998ecf8427e')
+
+        self.assertEqual(
+            get_cache_key(request),
+            'views.decorators.cache.cache_page.settingsprefix.GET.'
+            '18a03f9c9649f7d684af5db3524f5c99.d41d8cd98f00b204e9800998ecf8427e'
+        )
 
     def test_patch_cache_control(self):
         tests = (
@@ -1874,10 +1915,19 @@ class TestWithTemplateResponse(TestCase):
         self.assertEqual(get_cache_key(request), None)
         # Set headers to an empty list.
         learn_cache_key(request, response)
-        self.assertEqual(get_cache_key(request), 'views.decorators.cache.cache_page.settingsprefix.GET.9fa0fd092afb73bdce204bb4f94d5804.d41d8cd98f00b204e9800998ecf8427e')
+
+        self.assertEqual(
+            get_cache_key(request),
+            'views.decorators.cache.cache_page.settingsprefix.GET.'
+            '58a0a05c8a5620f813686ff969c26853.d41d8cd98f00b204e9800998ecf8427e'
+        )
         # Verify that a specified key_prefix is taken into account.
         learn_cache_key(request, response, key_prefix=key_prefix)
-        self.assertEqual(get_cache_key(request, key_prefix=key_prefix), 'views.decorators.cache.cache_page.localprefix.GET.9fa0fd092afb73bdce204bb4f94d5804.d41d8cd98f00b204e9800998ecf8427e')
+        self.assertEqual(
+            get_cache_key(request, key_prefix=key_prefix),
+            'views.decorators.cache.cache_page.localprefix.GET.'
+            '58a0a05c8a5620f813686ff969c26853.d41d8cd98f00b204e9800998ecf8427e'
+        )
 
     def test_get_cache_key_with_query(self):
         request = self.factory.get(self.path, {'test': 1})
@@ -1887,7 +1937,11 @@ class TestWithTemplateResponse(TestCase):
         # Set headers to an empty list.
         learn_cache_key(request, response)
         # Verify that the querystring is taken into account.
-        self.assertEqual(get_cache_key(request), 'views.decorators.cache.cache_page.settingsprefix.GET.d11198ba31883732b0de5786a80cc12b.d41d8cd98f00b204e9800998ecf8427e')
+        self.assertEqual(
+            get_cache_key(request),
+            'views.decorators.cache.cache_page.settingsprefix.GET.'
+            '0f1c2d56633c943073c4569d9a9502fe.d41d8cd98f00b204e9800998ecf8427e'
+        )
 
     @override_settings(USE_ETAGS=False)
     def test_without_etag(self):
diff --git a/tests/commands_sql/tests.py b/tests/commands_sql/tests.py
index 3088ea4d48..7ef28f83db 100644
--- a/tests/commands_sql/tests.py
+++ b/tests/commands_sql/tests.py
@@ -1,6 +1,6 @@
 from __future__ import unicode_literals
 
-from django.core.apps import app_cache
+from django.apps import apps
 from django.core.management.color import no_style
 from django.core.management.sql import (sql_create, sql_delete, sql_indexes,
     sql_destroy_indexes, sql_all)
@@ -17,8 +17,8 @@ class SQLCommandsTestCase(TestCase):
         return len([o for o in output if o.startswith(cmd)])
 
     def test_sql_create(self):
-        app = app_cache.get_app_config('commands_sql').models_module
-        output = sql_create(app, no_style(), connections[DEFAULT_DB_ALIAS])
+        app_config = apps.get_app_config('commands_sql')
+        output = sql_create(app_config, no_style(), connections[DEFAULT_DB_ALIAS])
         create_tables = [o for o in output if o.startswith('CREATE TABLE')]
         self.assertEqual(len(create_tables), 3)
         # Lower so that Oracle's upper case tbl names wont break
@@ -26,8 +26,8 @@ class SQLCommandsTestCase(TestCase):
         six.assertRegex(self, sql, r'^create table .commands_sql_book.*')
 
     def test_sql_delete(self):
-        app = app_cache.get_app_config('commands_sql').models_module
-        output = sql_delete(app, no_style(), connections[DEFAULT_DB_ALIAS])
+        app_config = apps.get_app_config('commands_sql')
+        output = sql_delete(app_config, no_style(), connections[DEFAULT_DB_ALIAS])
         drop_tables = [o for o in output if o.startswith('DROP TABLE')]
         self.assertEqual(len(drop_tables), 3)
         # Lower so that Oracle's upper case tbl names wont break
@@ -35,20 +35,20 @@ class SQLCommandsTestCase(TestCase):
         six.assertRegex(self, sql, r'^drop table .commands_sql_comment.*')
 
     def test_sql_indexes(self):
-        app = app_cache.get_app_config('commands_sql').models_module
-        output = sql_indexes(app, no_style(), connections[DEFAULT_DB_ALIAS])
+        app_config = apps.get_app_config('commands_sql')
+        output = sql_indexes(app_config, no_style(), connections[DEFAULT_DB_ALIAS])
         # PostgreSQL creates one additional index for CharField
         self.assertIn(self.count_ddl(output, 'CREATE INDEX'), [3, 4])
 
     def test_sql_destroy_indexes(self):
-        app = app_cache.get_app_config('commands_sql').models_module
-        output = sql_destroy_indexes(app, no_style(), connections[DEFAULT_DB_ALIAS])
+        app_config = apps.get_app_config('commands_sql')
+        output = sql_destroy_indexes(app_config, no_style(), connections[DEFAULT_DB_ALIAS])
         # PostgreSQL creates one additional index for CharField
         self.assertIn(self.count_ddl(output, 'DROP INDEX'), [3, 4])
 
     def test_sql_all(self):
-        app = app_cache.get_app_config('commands_sql').models_module
-        output = sql_all(app, no_style(), connections[DEFAULT_DB_ALIAS])
+        app_config = apps.get_app_config('commands_sql')
+        output = sql_all(app_config, no_style(), connections[DEFAULT_DB_ALIAS])
 
         self.assertEqual(self.count_ddl(output, 'CREATE TABLE'), 3)
         # PostgreSQL creates one additional index for CharField
@@ -69,8 +69,8 @@ class SQLCommandsRouterTestCase(TestCase):
         router.routers = self._old_routers
 
     def test_router_honored(self):
-        app = app_cache.get_app_config('commands_sql').models_module
+        app_config = apps.get_app_config('commands_sql')
         for sql_command in (sql_all, sql_create, sql_delete, sql_indexes, sql_destroy_indexes):
-            output = sql_command(app, no_style(), connections[DEFAULT_DB_ALIAS])
+            output = sql_command(app_config, no_style(), connections[DEFAULT_DB_ALIAS])
             self.assertEqual(len(output), 0,
                 "%s command is not honoring routers" % sql_command.__name__)
diff --git a/tests/comment_tests/tests/__init__.py b/tests/comment_tests/tests/__init__.py
index 2e247079f8..5f73a995ca 100644
--- a/tests/comment_tests/tests/__init__.py
+++ b/tests/comment_tests/tests/__init__.py
@@ -3,8 +3,7 @@ from django.contrib.comments.forms import CommentForm
 from django.contrib.comments.models import Comment
 from django.contrib.contenttypes.models import ContentType
 from django.contrib.sites.models import Site
-from django.test import TestCase
-from django.test.utils import override_settings
+from django.test import TestCase, override_settings
 
 from ..models import Article, Author
 
diff --git a/tests/comment_tests/tests/test_app_api.py b/tests/comment_tests/tests/test_app_api.py
index 384802d1b2..ffb78c851e 100644
--- a/tests/comment_tests/tests/test_app_api.py
+++ b/tests/comment_tests/tests/test_app_api.py
@@ -3,7 +3,7 @@ from django.contrib import comments
 from django.contrib.comments.models import Comment
 from django.contrib.comments.forms import CommentForm
 from django.core.exceptions import ImproperlyConfigured
-from django.test.utils import override_settings
+from django.test import modify_settings, override_settings
 from django.utils import six
 
 from . import CommentTestCase
@@ -15,14 +15,6 @@ class CommentAppAPITests(CommentTestCase):
     def testGetCommentApp(self):
         self.assertEqual(comments.get_comment_app(), comments)
 
-    @override_settings(
-        COMMENTS_APP='missing_app',
-        INSTALLED_APPS=list(settings.INSTALLED_APPS) + ['missing_app'],
-    )
-    def testGetMissingCommentApp(self):
-        with six.assertRaisesRegex(self, ImproperlyConfigured, 'missing_app'):
-            comments.get_comment_app()
-
     def testGetForm(self):
         self.assertEqual(comments.get_form(), CommentForm)
 
@@ -42,11 +34,8 @@ class CommentAppAPITests(CommentTestCase):
         self.assertEqual(comments.get_approve_url(c), "/approve/12345/")
 
 
-@override_settings(
-    COMMENTS_APP='comment_tests.custom_comments',
-    INSTALLED_APPS=list(settings.INSTALLED_APPS) + [
-        'comment_tests.custom_comments'],
-)
+@modify_settings(INSTALLED_APPS={'append': 'comment_tests.custom_comments'})
+@override_settings(COMMENTS_APP='comment_tests.custom_comments')
 class CustomCommentTest(CommentTestCase):
     urls = 'comment_tests.urls'
 
@@ -69,10 +58,10 @@ class CustomCommentTest(CommentTestCase):
         c = Comment(id=12345)
         self.assertEqual(comments.get_flag_url(c), "/flag/12345/")
 
-    def getGetDeleteURL(self):
+    def testGetDeleteURL(self):
         c = Comment(id=12345)
         self.assertEqual(comments.get_delete_url(c), "/delete/12345/")
 
-    def getGetApproveURL(self):
+    def testGetApproveURL(self):
         c = Comment(id=12345)
         self.assertEqual(comments.get_approve_url(c), "/approve/12345/")
diff --git a/tests/comment_tests/tests/test_comment_form.py b/tests/comment_tests/tests/test_comment_form.py
index 205b4150e8..d4399fbd2a 100644
--- a/tests/comment_tests/tests/test_comment_form.py
+++ b/tests/comment_tests/tests/test_comment_form.py
@@ -3,7 +3,7 @@ import time
 from django.conf import settings
 from django.contrib.comments.forms import CommentForm
 from django.contrib.comments.models import Comment
-from django.test.utils import override_settings
+from django.test import override_settings
 
 from . import CommentTestCase
 from ..models import Article
diff --git a/tests/comment_tests/tests/test_comment_utils_moderators.py b/tests/comment_tests/tests/test_comment_utils_moderators.py
index e61be48d8b..9de37e47e2 100644
--- a/tests/comment_tests/tests/test_comment_utils_moderators.py
+++ b/tests/comment_tests/tests/test_comment_utils_moderators.py
@@ -2,7 +2,7 @@ from django.contrib.comments.models import Comment
 from django.contrib.comments.moderation import (moderator, CommentModerator,
     AlreadyModerated)
 from django.core import mail
-from django.test.utils import override_settings
+from django.test import override_settings
 
 from . import CommentTestCase
 from ..models import Entry
diff --git a/tests/contenttypes_tests/tests.py b/tests/contenttypes_tests/tests.py
index 9cc254e665..1f0af709cb 100644
--- a/tests/contenttypes_tests/tests.py
+++ b/tests/contenttypes_tests/tests.py
@@ -1,7 +1,7 @@
 from __future__ import unicode_literals
 
+from django.apps.registry import Apps
 from django.contrib.contenttypes.models import ContentType
-from django.core.apps.cache import AppCache
 from django.db import models
 from django.test import TestCase
 
@@ -61,7 +61,7 @@ class ContentTypesViewsTests(TestCase):
             class Meta:
                 verbose_name = 'a model created on the fly'
                 app_label = 'my_great_app'
-                app_cache = AppCache()
+                apps = Apps()
 
         ct = ContentType.objects.get_for_model(ModelCreatedOnTheFly)
         self.assertEqual(ct.app_label, 'my_great_app')
diff --git a/tests/csrf_tests/tests.py b/tests/csrf_tests/tests.py
index ac48c17af6..4c9153f3a5 100644
--- a/tests/csrf_tests/tests.py
+++ b/tests/csrf_tests/tests.py
@@ -7,8 +7,7 @@ from django.core.context_processors import csrf
 from django.http import HttpRequest, HttpResponse
 from django.middleware.csrf import CsrfViewMiddleware, CSRF_KEY_LENGTH
 from django.template import RequestContext, Template
-from django.test import TestCase
-from django.test.utils import override_settings
+from django.test import TestCase, override_settings
 from django.views.decorators.csrf import csrf_exempt, requires_csrf_token, ensure_csrf_cookie
 
 
diff --git a/tests/defer_regress/models.py b/tests/defer_regress/models.py
index d858558e97..f58a10215e 100644
--- a/tests/defer_regress/models.py
+++ b/tests/defer_regress/models.py
@@ -82,10 +82,6 @@ class Location(models.Model):
     location1 = models.CharField(max_length=1000, default='location1')
 
 
-class Item(models.Model):
-    pass
-
-
 class Request(models.Model):
     profile = models.ForeignKey(Profile, null=True, blank=True)
     location = models.ForeignKey(Location)
diff --git a/tests/defer_regress/tests.py b/tests/defer_regress/tests.py
index 3e9651b2d2..97d7e7e302 100644
--- a/tests/defer_regress/tests.py
+++ b/tests/defer_regress/tests.py
@@ -2,12 +2,11 @@ from __future__ import unicode_literals
 
 from operator import attrgetter
 
+from django.apps import apps
 from django.contrib.contenttypes.models import ContentType
 from django.contrib.sessions.backends.db import SessionStore
-from django.core.apps import app_cache
 from django.db.models import Count
-from django.test import TestCase
-from django.test.utils import override_settings
+from django.test import TestCase, override_settings
 
 from .models import (
     ResolveThis, Item, RelatedItem, Child, Leaf, Proxy, SimpleItem, Feature,
@@ -93,42 +92,26 @@ class DeferRegressionTest(TestCase):
             list)
 
     def test_ticket_11936(self):
-        # Regression for #11936 - loading.get_models should not return deferred
-        # models by default.
-        # Run a couple of defer queries so that app-cache must contain some
-        # deferred classes. It might contain a lot more classes depending on
-        # the order the tests are ran.
+        app_config = apps.get_app_config("defer_regress")
+        # Regression for #11936 - get_models should not return deferred models
+        # by default. Run a couple of defer queries so that app registry must
+        # contain some deferred classes. It might contain a lot more classes
+        # depending on the order the tests are ran.
         list(Item.objects.defer("name"))
         list(Child.objects.defer("value"))
-        klasses = set(
-            map(
-                attrgetter("__name__"),
-                app_cache.get_models(app_cache.get_app_config("defer_regress").models_module)
-            )
-        )
+        klasses = {model.__name__ for model in app_config.get_models()}
         self.assertIn("Child", klasses)
         self.assertIn("Item", klasses)
         self.assertNotIn("Child_Deferred_value", klasses)
         self.assertNotIn("Item_Deferred_name", klasses)
-        self.assertFalse(any(
-            k._deferred for k in app_cache.get_models(app_cache.get_app_config("defer_regress").models_module)))
+        self.assertFalse(any(k._deferred for k in app_config.get_models()))
 
-        klasses_with_deferred = set(
-            map(
-                attrgetter("__name__"),
-                app_cache.get_models(
-                    app_cache.get_app_config("defer_regress").models_module, include_deferred=True
-                ),
-            )
-        )
+        klasses_with_deferred = {model.__name__ for model in app_config.get_models(include_deferred=True)}
         self.assertIn("Child", klasses_with_deferred)
         self.assertIn("Item", klasses_with_deferred)
         self.assertIn("Child_Deferred_value", klasses_with_deferred)
         self.assertIn("Item_Deferred_name", klasses_with_deferred)
-        self.assertTrue(any(
-            k._deferred for k in app_cache.get_models(
-                app_cache.get_app_config("defer_regress").models_module, include_deferred=True))
-        )
+        self.assertTrue(any(k._deferred for k in app_config.get_models(include_deferred=True)))
 
     @override_settings(SESSION_SERIALIZER='django.contrib.sessions.serializers.PickleSerializer')
     def test_ticket_12163(self):
diff --git a/tests/expressions_regress/tests.py b/tests/expressions_regress/tests.py
index e603c410ac..7533e4ee39 100644
--- a/tests/expressions_regress/tests.py
+++ b/tests/expressions_regress/tests.py
@@ -274,6 +274,13 @@ class FTimeDeltaTests(TestCase):
         self.days_long.append(e4.completed - e4.assigned)
         self.expnames = [e.name for e in Experiment.objects.all()]
 
+    def test_multiple_query_compilation(self):
+        # Ticket #21643
+        queryset = Experiment.objects.filter(end__lt=F('start') + datetime.timedelta(hours=1))
+        q1 = str(queryset.query)
+        q2 = str(queryset.query)
+        self.assertEqual(q1, q2)
+
     def test_delta_add(self):
         for i in range(len(self.deltas)):
             delta = self.deltas[i]
diff --git a/tests/file_storage/tests.py b/tests/file_storage/tests.py
index 20eaf4c89c..2f047f049a 100644
--- a/tests/file_storage/tests.py
+++ b/tests/file_storage/tests.py
@@ -21,7 +21,7 @@ from django.core.files.base import File, ContentFile
 from django.core.files.storage import FileSystemStorage, get_storage_class
 from django.core.files.uploadedfile import SimpleUploadedFile
 from django.test import LiveServerTestCase, SimpleTestCase
-from django.test.utils import override_settings
+from django.test import override_settings
 from django.utils import six
 from django.utils.six.moves.urllib.request import urlopen
 from django.utils._os import upath
diff --git a/tests/file_uploads/tests.py b/tests/file_uploads/tests.py
index 7aa6797630..f4e4ea31b2 100644
--- a/tests/file_uploads/tests.py
+++ b/tests/file_uploads/tests.py
@@ -14,7 +14,7 @@ from django.core.files import temp as tempfile
 from django.core.files.uploadedfile import SimpleUploadedFile
 from django.http.multipartparser import MultiPartParser
 from django.test import TestCase, client
-from django.test.utils import override_settings
+from django.test import override_settings
 from django.utils.encoding import force_bytes
 from django.utils.six import StringIO
 
diff --git a/tests/files/tests.py b/tests/files/tests.py
index 43138d9b57..f562b5748d 100644
--- a/tests/files/tests.py
+++ b/tests/files/tests.py
@@ -161,9 +161,9 @@ class InconsistentGetImageDimensionsBug(unittest.TestCase):
         Multiple calls of get_image_dimensions() should return the same size.
         """
         img_path = os.path.join(os.path.dirname(upath(__file__)), "test.png")
-        with open(img_path, 'rb') as file:
-            image = images.ImageFile(file)
-            image_pil = Image.open(img_path)
+        with open(img_path, 'rb') as fh:
+            image = images.ImageFile(fh)
+            image_pil = Image.open(fh)
             size_1 = images.get_image_dimensions(image)
             size_2 = images.get_image_dimensions(image)
         self.assertEqual(image_pil.size, size_1)
@@ -180,7 +180,8 @@ class InconsistentGetImageDimensionsBug(unittest.TestCase):
             size = images.get_image_dimensions(img_path)
         except zlib.error:
             self.fail("Exception raised from get_image_dimensions().")
-        self.assertEqual(size, Image.open(img_path).size)
+        with open(img_path, 'rb') as fh:
+            self.assertEqual(size, Image.open(fh).size)
 
 
 class FileMoveSafeTests(unittest.TestCase):
diff --git a/tests/fixtures_regress/tests.py b/tests/fixtures_regress/tests.py
index 3757dc5180..6984db30c6 100644
--- a/tests/fixtures_regress/tests.py
+++ b/tests/fixtures_regress/tests.py
@@ -15,7 +15,7 @@ from django.db import transaction, IntegrityError
 from django.db.models import signals
 from django.test import (TestCase, TransactionTestCase, skipIfDBFeature,
     skipUnlessDBFeature)
-from django.test.utils import override_settings
+from django.test import override_settings
 from django.utils.encoding import force_text
 from django.utils._os import upath
 from django.utils import six
diff --git a/tests/forms_tests/tests/test_extra.py b/tests/forms_tests/tests/test_extra.py
index 7988b52da4..100c655117 100644
--- a/tests/forms_tests/tests/test_extra.py
+++ b/tests/forms_tests/tests/test_extra.py
@@ -12,8 +12,7 @@ from django.forms import (
 )
 from django.forms.extras import SelectDateWidget
 from django.forms.utils import ErrorList
-from django.test import TestCase
-from django.test.utils import override_settings
+from django.test import TestCase, override_settings
 from django.utils import six
 from django.utils import translation
 from django.utils.dates import MONTHS_AP
diff --git a/tests/forms_tests/tests/test_input_formats.py b/tests/forms_tests/tests/test_input_formats.py
index b9c29c7609..f939821c75 100644
--- a/tests/forms_tests/tests/test_input_formats.py
+++ b/tests/forms_tests/tests/test_input_formats.py
@@ -1,7 +1,7 @@
 from datetime import time, date, datetime
 
 from django import forms
-from django.test.utils import override_settings
+from django.test import override_settings
 from django.utils.translation import activate, deactivate
 from django.test import SimpleTestCase
 
diff --git a/tests/forms_tests/tests/test_media.py b/tests/forms_tests/tests/test_media.py
index 492655505c..c44e443eac 100644
--- a/tests/forms_tests/tests/test_media.py
+++ b/tests/forms_tests/tests/test_media.py
@@ -1,8 +1,7 @@
 # -*- coding: utf-8 -*-
 from django.forms import Media, TextInput, CharField, Form, MultiWidget
 from django.template import Template, Context
-from django.test import TestCase
-from django.test.utils import override_settings
+from django.test import TestCase, override_settings
 
 
 @override_settings(
diff --git a/tests/forms_tests/tests/test_widgets.py b/tests/forms_tests/tests/test_widgets.py
index 21134d1a24..4bbed3f0a9 100644
--- a/tests/forms_tests/tests/test_widgets.py
+++ b/tests/forms_tests/tests/test_widgets.py
@@ -18,8 +18,7 @@ from django.forms.widgets import RadioFieldRenderer
 from django.utils.safestring import mark_safe
 from django.utils import six
 from django.utils.translation import activate, deactivate, override
-from django.test import TestCase
-from django.test.utils import override_settings
+from django.test import TestCase, override_settings
 from django.utils.encoding import python_2_unicode_compatible, force_text
 
 from ..models import Article
diff --git a/tests/forms_tests/tests/tests.py b/tests/forms_tests/tests/tests.py
index 622b6386e9..0be1f26d81 100644
--- a/tests/forms_tests/tests/tests.py
+++ b/tests/forms_tests/tests/tests.py
@@ -239,14 +239,14 @@ class RelatedModelFormTests(TestCase):
         """
         Test for issue 10405
         """
-        class A(models.Model):
-            ref = models.ForeignKey("B")
+        class C(models.Model):
+            ref = models.ForeignKey("D")
 
-        class B(models.Model):
+        class D(models.Model):
             pass
 
         class Meta:
-            model = A
+            model = C
             fields = '__all__'
 
         self.assertTrue(issubclass(ModelFormMetaclass(str('Form'), (ModelForm,), {'Meta': Meta}), ModelForm))
diff --git a/tests/generic_inline_admin/tests.py b/tests/generic_inline_admin/tests.py
index 09a802a1bc..e35f0d639a 100644
--- a/tests/generic_inline_admin/tests.py
+++ b/tests/generic_inline_admin/tests.py
@@ -8,8 +8,7 @@ from django.contrib.contenttypes.generic import (
     generic_inlineformset_factory, GenericTabularInline)
 from django.forms.formsets import DEFAULT_MAX_NUM
 from django.forms.models import ModelForm
-from django.test import TestCase
-from django.test.utils import override_settings
+from django.test import TestCase, override_settings
 
 # local test models
 from .admin import MediaInline, MediaPermanentInline
diff --git a/tests/generic_views/test_dates.py b/tests/generic_views/test_dates.py
index 944a3dcfe3..07cb13a3ca 100644
--- a/tests/generic_views/test_dates.py
+++ b/tests/generic_views/test_dates.py
@@ -3,8 +3,8 @@ from __future__ import unicode_literals
 import datetime
 
 from django.core.exceptions import ImproperlyConfigured
-from django.test import TestCase, skipUnlessDBFeature
-from django.test.utils import override_settings, requires_tz_support
+from django.test import TestCase, override_settings, skipUnlessDBFeature
+from django.test.utils import requires_tz_support
 from django.utils import timezone
 
 from .models import Book, BookSigning
diff --git a/tests/generic_views/test_list.py b/tests/generic_views/test_list.py
index e572af8e32..a6a5c76ff8 100644
--- a/tests/generic_views/test_list.py
+++ b/tests/generic_views/test_list.py
@@ -1,8 +1,7 @@
 from __future__ import unicode_literals
 
 from django.core.exceptions import ImproperlyConfigured
-from django.test import TestCase
-from django.test.utils import override_settings
+from django.test import TestCase, override_settings
 from django.views.generic.base import View
 from django.utils.encoding import force_str
 
diff --git a/tests/handlers/tests.py b/tests/handlers/tests.py
index f5dc7c8531..ae8b9529f5 100644
--- a/tests/handlers/tests.py
+++ b/tests/handlers/tests.py
@@ -6,7 +6,7 @@ from django.core.handlers.wsgi import WSGIHandler, WSGIRequest
 from django.core.signals import request_started, request_finished
 from django.db import close_old_connections, connection
 from django.test import RequestFactory, TestCase, TransactionTestCase
-from django.test.utils import override_settings
+from django.test import override_settings
 from django.utils.encoding import force_str
 from django.utils import six
 
diff --git a/tests/i18n/contenttypes/tests.py b/tests/i18n/contenttypes/tests.py
index c48f8fc6dd..894ae0a3c7 100644
--- a/tests/i18n/contenttypes/tests.py
+++ b/tests/i18n/contenttypes/tests.py
@@ -4,8 +4,8 @@ from __future__ import unicode_literals
 import os
 
 from django.contrib.contenttypes.models import ContentType
-from django.test import TestCase
-from django.test.utils import override_settings, TransRealMixin
+from django.test import TestCase, override_settings
+from django.test.utils import TransRealMixin
 from django.utils._os import upath
 from django.utils import six
 from django.utils import translation
diff --git a/tests/i18n/patterns/tests.py b/tests/i18n/patterns/tests.py
index 78f5a46aae..a96fe1f54f 100644
--- a/tests/i18n/patterns/tests.py
+++ b/tests/i18n/patterns/tests.py
@@ -6,8 +6,7 @@ from django.core.exceptions import ImproperlyConfigured
 from django.core.urlresolvers import reverse, clear_url_caches
 from django.http import HttpResponsePermanentRedirect
 from django.middleware.locale import LocaleMiddleware
-from django.test import TestCase
-from django.test.utils import override_settings
+from django.test import TestCase, override_settings
 from django.template import Template, Context
 from django.utils._os import upath
 from django.utils import translation
diff --git a/tests/i18n/test_compilation.py b/tests/i18n/test_compilation.py
index 0b8365b3c9..ae92f6f368 100644
--- a/tests/i18n/test_compilation.py
+++ b/tests/i18n/test_compilation.py
@@ -4,7 +4,7 @@ import unittest
 from django.core.management import call_command, CommandError
 from django.core.management.utils import find_command
 from django.test import SimpleTestCase
-from django.test.utils import override_settings
+from django.test import override_settings
 from django.utils import translation
 from django.utils._os import upath
 from django.utils.six import StringIO
diff --git a/tests/i18n/test_extraction.py b/tests/i18n/test_extraction.py
index da3670ff10..bd18700076 100644
--- a/tests/i18n/test_extraction.py
+++ b/tests/i18n/test_extraction.py
@@ -12,7 +12,7 @@ from django.conf import settings
 from django.core import management
 from django.core.management.utils import find_command
 from django.test import SimpleTestCase
-from django.test.utils import override_settings
+from django.test import override_settings
 from django.utils.encoding import force_text
 from django.utils._os import upath
 from django.utils import six
diff --git a/tests/i18n/tests.py b/tests/i18n/tests.py
index 77b7d18455..116364790f 100644
--- a/tests/i18n/tests.py
+++ b/tests/i18n/tests.py
@@ -11,8 +11,8 @@ from threading import local
 from django.conf import settings
 from django.template import Template, Context
 from django.template.base import TemplateSyntaxError
-from django.test import TestCase, RequestFactory
-from django.test.utils import override_settings, TransRealMixin
+from django.test import TestCase, RequestFactory, override_settings
+from django.test.utils import TransRealMixin
 from django.utils import translation
 from django.utils.formats import (get_format, date_format, time_format,
     localize, localize_input, iter_format_modules, get_format_modules,
@@ -1035,11 +1035,26 @@ class ResolutionOrderI18NTests(TransRealMixin, TestCase):
             "translation of '%s'; the actual result is '%s'." % (msgstr, msgid, result)))
 
 
-@override_settings(INSTALLED_APPS=['i18n.resolution'] + list(settings.INSTALLED_APPS))
 class AppResolutionOrderI18NTests(ResolutionOrderI18NTests):
 
     def test_app_translation(self):
-        self.assertUgettext('Date/time', 'APP')
+        # Original translation.
+        self.assertUgettext('Date/time', 'Datum/Zeit')
+
+        # Different translation.
+        with self.modify_settings(INSTALLED_APPS={'append': 'i18n.resolution'}):
+            self.flush_caches()
+            activate('de')
+
+            # Doesn't work because it's added later in the list.
+            self.assertUgettext('Date/time', 'Datum/Zeit')
+
+            with self.modify_settings(INSTALLED_APPS={'remove': 'django.contrib.admin'}):
+                self.flush_caches()
+                activate('de')
+
+                # Unless the original is removed from the list.
+                self.assertUgettext('Date/time', 'Datum/Zeit (APP)')
 
 
 @override_settings(LOCALE_PATHS=extended_locale_paths)
@@ -1049,8 +1064,7 @@ class LocalePathsResolutionOrderI18NTests(ResolutionOrderI18NTests):
         self.assertUgettext('Time', 'LOCALE_PATHS')
 
     def test_locale_paths_override_app_translation(self):
-        extended_apps = list(settings.INSTALLED_APPS) + ['i18n.resolution']
-        with self.settings(INSTALLED_APPS=extended_apps):
+        with self.settings(INSTALLED_APPS=['i18n.resolution']):
             self.assertUgettext('Time', 'LOCALE_PATHS')
 
 
diff --git a/tests/initial_sql_regress/tests.py b/tests/initial_sql_regress/tests.py
index b04e638808..e725f4b102 100644
--- a/tests/initial_sql_regress/tests.py
+++ b/tests/initial_sql_regress/tests.py
@@ -1,8 +1,7 @@
 from django.core.management.color import no_style
 from django.core.management.sql import custom_sql_for_model
 from django.db import connections, DEFAULT_DB_ALIAS
-from django.test import TestCase
-from django.test.utils import override_settings
+from django.test import TestCase, override_settings
 
 from .models import Simple
 
diff --git a/tests/invalid_models_tests/__init__.py b/tests/invalid_models_tests/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/tests/invalid_models_tests/invalid_models/__init__.py b/tests/invalid_models_tests/invalid_models/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/tests/invalid_models/invalid_models/models.py b/tests/invalid_models_tests/invalid_models/models.py
similarity index 100%
rename from tests/invalid_models/invalid_models/models.py
rename to tests/invalid_models_tests/invalid_models/models.py
diff --git a/tests/invalid_models/tests.py b/tests/invalid_models_tests/tests.py
similarity index 68%
rename from tests/invalid_models/tests.py
rename to tests/invalid_models_tests/tests.py
index 712484c611..08cea2e15f 100644
--- a/tests/invalid_models/tests.py
+++ b/tests/invalid_models_tests/tests.py
@@ -1,9 +1,9 @@
 import sys
 import unittest
 
-from django.core.apps import app_cache
+from django.apps import apps
 from django.core.management.validation import get_validation_errors
-from django.test.utils import override_settings
+from django.test import override_settings
 from django.utils.six import StringIO
 
 
@@ -18,13 +18,7 @@ class InvalidModelTestCase(unittest.TestCase):
         self.stdout = StringIO()
         sys.stdout = self.stdout
 
-        # The models need to be removed after the test in order to prevent bad
-        # interactions with the flush operation in other tests.
-        self._old_models = app_cache.app_configs['invalid_models'].models.copy()
-
     def tearDown(self):
-        app_cache.app_configs['invalid_models'].models = self._old_models
-        app_cache._get_models_cache = {}
         sys.stdout = self.old_stdout
 
     # Technically, this isn't an override -- TEST_SWAPPED_MODEL must be
@@ -32,21 +26,19 @@ class InvalidModelTestCase(unittest.TestCase):
     # easier to set this up as an override than to require every developer
     # to specify a value in their test settings.
     @override_settings(
+        INSTALLED_APPS=['invalid_models_tests.invalid_models'],
         TEST_SWAPPED_MODEL='invalid_models.ReplacementModel',
         TEST_SWAPPED_MODEL_BAD_VALUE='not-a-model',
         TEST_SWAPPED_MODEL_BAD_MODEL='not_an_app.Target',
     )
     def test_invalid_models(self):
-        try:
-            module = app_cache.load_app("invalid_models.invalid_models")
-        except Exception:
-            self.fail('Unable to load invalid model module')
+        app_config = apps.get_app_config("invalid_models")
+        get_validation_errors(self.stdout, app_config)
 
-        get_validation_errors(self.stdout, module)
         self.stdout.seek(0)
         error_log = self.stdout.read()
         actual = error_log.split('\n')
-        expected = module.model_errors.split('\n')
+        expected = app_config.models_module.model_errors.split('\n')
 
         unexpected = [err for err in actual if err not in expected]
         missing = [err for err in expected if err not in actual]
diff --git a/tests/logging_tests/tests.py b/tests/logging_tests/tests.py
index 1f9c8920c9..5b536f9e82 100644
--- a/tests/logging_tests/tests.py
+++ b/tests/logging_tests/tests.py
@@ -3,10 +3,9 @@ from __future__ import unicode_literals
 import logging
 import warnings
 
-from django.conf import LazySettings
 from django.core import mail
-from django.test import TestCase, RequestFactory
-from django.test.utils import override_settings, patch_logger
+from django.test import TestCase, RequestFactory, override_settings
+from django.test.utils import patch_logger
 from django.utils.encoding import force_text
 from django.utils.log import (CallbackFilter, RequireDebugFalse,
     RequireDebugTrue)
@@ -92,8 +91,8 @@ class WarningLoggerTests(TestCase):
     """
     def setUp(self):
         # If tests are invoke with "-Wall" (or any -W flag actually) then
-        # warning logging gets disabled (see django/conf/__init__.py). However,
-        # these tests expect warnings to be logged, so manually force warnings
+        # warning logging gets disabled (see configure_logging in django/utils/log.py).
+        # However, these tests expect warnings to be logged, so manually force warnings
         # to the logs. Use getattr() here because the logging capture state is
         # undocumented and (I assume) brittle.
         self._old_capture_state = bool(getattr(logging, '_warnings_showwarning', False))
@@ -342,15 +341,14 @@ def dictConfig(config):
 dictConfig.called = False
 
 
-class SettingsConfigureLogging(TestCase):
+class SetupConfigureLogging(TestCase):
     """
-    Test that calling settings.configure() initializes the logging
-    configuration.
+    Test that calling django.setup() initializes the logging configuration.
     """
+    @override_settings(LOGGING_CONFIG='logging_tests.tests.dictConfig')
     def test_configure_initializes_logging(self):
-        settings = LazySettings()
-        settings.configure(
-            LOGGING_CONFIG='logging_tests.tests.dictConfig')
+        from django import setup
+        setup()
         self.assertTrue(dictConfig.called)
 
 
diff --git a/tests/mail/tests.py b/tests/mail/tests.py
index 9683374fc5..ebb8ec5448 100644
--- a/tests/mail/tests.py
+++ b/tests/mail/tests.py
@@ -2,7 +2,6 @@
 from __future__ import unicode_literals
 
 import asyncore
-from email import message_from_file, message_from_string
 from email.mime.text import MIMEText
 import os
 import shutil
@@ -19,15 +18,18 @@ from django.core.mail import (EmailMessage, mail_admins, mail_managers,
 from django.core.mail.backends import console, dummy, locmem, filebased, smtp
 from django.core.mail.message import BadHeaderError
 from django.test import SimpleTestCase
-from django.test.utils import override_settings
-from django.utils.encoding import force_str, force_text
-from django.utils.six import PY3, StringIO, string_types
+from django.test import override_settings
+from django.utils.encoding import force_text, force_bytes
+from django.utils.six import PY3, StringIO, binary_type
 from django.utils.translation import ugettext_lazy
 
 if PY3:
     from email.utils import parseaddr
+    from email import message_from_bytes, message_from_binary_file
 else:
     from email.Utils import parseaddr
+    from email import (message_from_string as message_from_bytes,
+        message_from_file as message_from_binary_file)
 
 
 class HeadersCheckMixin(object):
@@ -40,13 +42,9 @@ class HeadersCheckMixin(object):
         string with the contens of an email message.
         :param headers: should be a set of (header-name, header-value) tuples.
         """
-        if isinstance(message, string_types):
-            just_headers = message.split('\n\n', 1)[0]
-            hlist = just_headers.split('\n')
-            pairs = [hl.split(':', 1) for hl in hlist]
-            msg_headers = {(n, v.lstrip()) for (n, v) in pairs}
-        else:
-            msg_headers = set(message.items())
+        if isinstance(message, binary_type):
+            message = message_from_bytes(message)
+        msg_headers = set(message.items())
         self.assertTrue(headers.issubset(msg_headers), msg='Message is missing '
                         'the following headers: %s' % (headers - msg_headers),)
 
@@ -231,13 +229,13 @@ class MailTests(HeadersCheckMixin, SimpleTestCase):
             ('MIME-Version', '1.0'),
             ('Content-Type', 'text/plain; charset="iso-8859-1"'),
             ('Content-Transfer-Encoding', 'quoted-printable')})
-        self.assertTrue(payload0.as_string().endswith('\n\nFirstname S=FCrname is a great guy.'))
+        self.assertTrue(payload0.as_bytes().endswith(b'\n\nFirstname S=FCrname is a great guy.'))
         payload1 = msg.message().get_payload(1)
         self.assertMessageHasHeaders(payload1, {
             ('MIME-Version', '1.0'),
             ('Content-Type', 'text/html; charset="iso-8859-1"'),
             ('Content-Transfer-Encoding', 'quoted-printable')})
-        self.assertTrue(payload1.as_string().endswith('\n\n<p>Firstname S=FCrname is a <strong>great</strong> guy.</p>'))
+        self.assertTrue(payload1.as_bytes().endswith(b'\n\n<p>Firstname S=FCrname is a <strong>great</strong> guy.</p>'))
 
     def test_attachments(self):
         """Regression test for #9367"""
@@ -248,8 +246,8 @@ class MailTests(HeadersCheckMixin, SimpleTestCase):
         msg = EmailMultiAlternatives(subject, text_content, from_email, [to], headers=headers)
         msg.attach_alternative(html_content, "text/html")
         msg.attach("an attachment.pdf", b"%PDF-1.4.%...", mimetype="application/pdf")
-        msg_str = msg.message().as_string()
-        message = message_from_string(msg_str)
+        msg_bytes = msg.message().as_bytes()
+        message = message_from_bytes(msg_bytes)
         self.assertTrue(message.is_multipart())
         self.assertEqual(message.get_content_type(), 'multipart/mixed')
         self.assertEqual(message.get_default_type(), 'text/plain')
@@ -265,8 +263,8 @@ class MailTests(HeadersCheckMixin, SimpleTestCase):
         msg = EmailMessage(subject, content, from_email, [to], headers=headers)
         # Unicode in file name
         msg.attach("une pièce jointe.pdf", b"%PDF-1.4.%...", mimetype="application/pdf")
-        msg_str = msg.message().as_string()
-        message = message_from_string(msg_str)
+        msg_bytes = msg.message().as_bytes()
+        message = message_from_bytes(msg_bytes)
         payload = message.get_payload()
         self.assertEqual(payload[1].get_filename(), 'une pièce jointe.pdf')
 
@@ -348,31 +346,31 @@ class MailTests(HeadersCheckMixin, SimpleTestCase):
         # Regression for #13433 - Make sure that EmailMessage doesn't mangle
         # 'From ' in message body.
         email = EmailMessage('Subject', 'From the future', 'bounce@example.com', ['to@example.com'], headers={'From': 'from@example.com'})
-        self.assertFalse('>From the future' in email.message().as_string())
+        self.assertFalse(b'>From the future' in email.message().as_bytes())
 
     def test_dont_base64_encode(self):
         # Ticket #3472
         # Shouldn't use Base64 encoding at all
         msg = EmailMessage('Subject', 'UTF-8 encoded body', 'bounce@example.com', ['to@example.com'], headers={'From': 'from@example.com'})
-        self.assertFalse('Content-Transfer-Encoding: base64' in msg.message().as_string())
+        self.assertFalse(b'Content-Transfer-Encoding: base64' in msg.message().as_bytes())
 
         # Ticket #11212
         # Shouldn't use quoted printable, should detect it can represent content with 7 bit data
         msg = EmailMessage('Subject', 'Body with only ASCII characters.', 'bounce@example.com', ['to@example.com'], headers={'From': 'from@example.com'})
-        s = msg.message().as_string()
-        self.assertFalse('Content-Transfer-Encoding: quoted-printable' in s)
-        self.assertTrue('Content-Transfer-Encoding: 7bit' in s)
+        s = msg.message().as_bytes()
+        self.assertFalse(b'Content-Transfer-Encoding: quoted-printable' in s)
+        self.assertTrue(b'Content-Transfer-Encoding: 7bit' in s)
 
         # Shouldn't use quoted printable, should detect it can represent content with 8 bit data
         msg = EmailMessage('Subject', 'Body with latin characters: àáä.', 'bounce@example.com', ['to@example.com'], headers={'From': 'from@example.com'})
-        s = msg.message().as_string()
-        self.assertFalse(str('Content-Transfer-Encoding: quoted-printable') in s)
-        self.assertTrue(str('Content-Transfer-Encoding: 8bit') in s)
+        s = msg.message().as_bytes()
+        self.assertFalse(b'Content-Transfer-Encoding: quoted-printable' in s)
+        self.assertTrue(b'Content-Transfer-Encoding: 8bit' in s)
 
         msg = EmailMessage('Subject', 'Body with non latin characters: А Б В Г Д Е Ж Ѕ З И І К Л М Н О П.', 'bounce@example.com', ['to@example.com'], headers={'From': 'from@example.com'})
-        s = msg.message().as_string()
-        self.assertFalse(str('Content-Transfer-Encoding: quoted-printable') in s)
-        self.assertTrue(str('Content-Transfer-Encoding: 8bit') in s)
+        s = msg.message().as_bytes()
+        self.assertFalse(b'Content-Transfer-Encoding: quoted-printable' in s)
+        self.assertTrue(b'Content-Transfer-Encoding: 8bit' in s)
 
     def test_dont_base64_encode_message_rfc822(self):
         # Ticket #18967
@@ -476,7 +474,7 @@ class BaseEmailBackendTests(HeadersCheckMixin, object):
         self.assertEqual(num_sent, 1)
         message = self.get_the_message()
         self.assertEqual(message["subject"], '=?utf-8?q?Ch=C3=A8re_maman?=')
-        self.assertEqual(force_text(message.get_payload()), 'Je t\'aime très fort')
+        self.assertEqual(force_text(message.get_payload(decode=True)), 'Je t\'aime très fort')
 
     def test_send_many(self):
         email1 = EmailMessage('Subject', 'Content1', 'from@example.com', ['to@example.com'])
@@ -692,9 +690,9 @@ class FileBackendTests(BaseEmailBackendTests, SimpleTestCase):
     def get_mailbox_content(self):
         messages = []
         for filename in os.listdir(self.tmp_dir):
-            with open(os.path.join(self.tmp_dir, filename), 'r') as fp:
-                session = force_text(fp.read()).split('\n' + ('-' * 79) + '\n')
-            messages.extend(message_from_string(force_str(m)) for m in session if m)
+            with open(os.path.join(self.tmp_dir, filename), 'rb') as fp:
+                session = fp.read().split(force_bytes('\n' + ('-' * 79) + '\n', encoding='ascii'))
+            messages.extend(message_from_bytes(m) for m in session if m)
         return messages
 
     def test_file_sessions(self):
@@ -704,8 +702,8 @@ class FileBackendTests(BaseEmailBackendTests, SimpleTestCase):
         connection.send_messages([msg])
 
         self.assertEqual(len(os.listdir(self.tmp_dir)), 1)
-        with open(os.path.join(self.tmp_dir, os.listdir(self.tmp_dir)[0])) as fp:
-            message = message_from_file(fp)
+        with open(os.path.join(self.tmp_dir, os.listdir(self.tmp_dir)[0]), 'rb') as fp:
+            message = message_from_binary_file(fp)
         self.assertEqual(message.get_content_type(), 'text/plain')
         self.assertEqual(message.get('subject'), 'Subject')
         self.assertEqual(message.get('from'), 'from@example.com')
@@ -746,8 +744,8 @@ class ConsoleBackendTests(BaseEmailBackendTests, SimpleTestCase):
         self.stream = sys.stdout = StringIO()
 
     def get_mailbox_content(self):
-        messages = force_text(self.stream.getvalue()).split('\n' + ('-' * 79) + '\n')
-        return [message_from_string(force_str(m)) for m in messages if m]
+        messages = self.stream.getvalue().split(str('\n' + ('-' * 79) + '\n'))
+        return [message_from_bytes(force_bytes(m)) for m in messages if m]
 
     def test_console_stream_kwarg(self):
         """
@@ -756,14 +754,15 @@ class ConsoleBackendTests(BaseEmailBackendTests, SimpleTestCase):
         s = StringIO()
         connection = mail.get_connection('django.core.mail.backends.console.EmailBackend', stream=s)
         send_mail('Subject', 'Content', 'from@example.com', ['to@example.com'], connection=connection)
-        self.assertMessageHasHeaders(s.getvalue(), {
+        message = force_bytes(s.getvalue().split('\n' + ('-' * 79) + '\n')[0])
+        self.assertMessageHasHeaders(message, {
             ('MIME-Version', '1.0'),
             ('Content-Type', 'text/plain; charset="utf-8"'),
             ('Content-Transfer-Encoding', '7bit'),
             ('Subject', 'Subject'),
             ('From', 'from@example.com'),
             ('To', 'to@example.com')})
-        self.assertIn('\nDate: ', s.getvalue())
+        self.assertIn(b'\nDate: ', message)
 
 
 class FakeSMTPChannel(smtpd.SMTPChannel):
@@ -793,7 +792,9 @@ class FakeSMTPServer(smtpd.SMTPServer, threading.Thread):
         self.sink_lock = threading.Lock()
 
     def process_message(self, peer, mailfrom, rcpttos, data):
-        m = message_from_string(data)
+        if PY3:
+            data = data.encode('utf-8')
+        m = message_from_bytes(data)
         maddr = parseaddr(m.get('from'))[1]
         if mailfrom != maddr:
             return "553 '%s' != '%s'" % (mailfrom, maddr)
diff --git a/tests/managers_regress/tests.py b/tests/managers_regress/tests.py
index f2897862ec..0d24873a10 100644
--- a/tests/managers_regress/tests.py
+++ b/tests/managers_regress/tests.py
@@ -1,10 +1,9 @@
 from __future__ import unicode_literals
 
-from django.core.apps import app_cache
+from django.apps import apps
 from django.db import models
 from django.template import Context, Template
-from django.test import TestCase
-from django.test.utils import override_settings
+from django.test import TestCase, override_settings
 from django.utils.encoding import force_text
 
 from .models import (
@@ -111,7 +110,7 @@ class ManagersRegressionTests(TestCase):
     def test_swappable_manager(self):
         # The models need to be removed after the test in order to prevent bad
         # interactions with the flush operation in other tests.
-        _old_models = app_cache.app_configs['managers_regress'].models.copy()
+        _old_models = apps.app_configs['managers_regress'].models.copy()
 
         try:
             class SwappableModel(models.Model):
@@ -127,14 +126,15 @@ class ManagersRegressionTests(TestCase):
                 self.assertEqual(str(e), "Manager isn't available; SwappableModel has been swapped for 'managers_regress.Parent'")
 
         finally:
-            app_cache.app_configs['managers_regress'].models = _old_models
-            app_cache._get_models_cache = {}
+            apps.app_configs['managers_regress'].models = _old_models
+            apps.all_models['managers_regress'] = _old_models
+            apps.clear_cache()
 
     @override_settings(TEST_SWAPPABLE_MODEL='managers_regress.Parent')
     def test_custom_swappable_manager(self):
         # The models need to be removed after the test in order to prevent bad
         # interactions with the flush operation in other tests.
-        _old_models = app_cache.app_configs['managers_regress'].models.copy()
+        _old_models = apps.app_configs['managers_regress'].models.copy()
 
         try:
             class SwappableModel(models.Model):
@@ -154,14 +154,15 @@ class ManagersRegressionTests(TestCase):
                 self.assertEqual(str(e), "Manager isn't available; SwappableModel has been swapped for 'managers_regress.Parent'")
 
         finally:
-            app_cache.app_configs['managers_regress'].models = _old_models
-            app_cache._get_models_cache = {}
+            apps.app_configs['managers_regress'].models = _old_models
+            apps.all_models['managers_regress'] = _old_models
+            apps.clear_cache()
 
     @override_settings(TEST_SWAPPABLE_MODEL='managers_regress.Parent')
     def test_explicit_swappable_manager(self):
         # The models need to be removed after the test in order to prevent bad
         # interactions with the flush operation in other tests.
-        _old_models = app_cache.app_configs['managers_regress'].models.copy()
+        _old_models = apps.app_configs['managers_regress'].models.copy()
 
         try:
             class SwappableModel(models.Model):
@@ -181,8 +182,9 @@ class ManagersRegressionTests(TestCase):
                 self.assertEqual(str(e), "Manager isn't available; SwappableModel has been swapped for 'managers_regress.Parent'")
 
         finally:
-            app_cache.app_configs['managers_regress'].models = _old_models
-            app_cache._get_models_cache = {}
+            apps.app_configs['managers_regress'].models = _old_models
+            apps.all_models['managers_regress'] = _old_models
+            apps.clear_cache()
 
     def test_regress_3871(self):
         related = RelatedModel.objects.create()
diff --git a/tests/middleware/tests.py b/tests/middleware/tests.py
index 0124e33c98..d4b8827f7b 100644
--- a/tests/middleware/tests.py
+++ b/tests/middleware/tests.py
@@ -18,8 +18,8 @@ from django.middleware.common import CommonMiddleware, BrokenLinkEmailsMiddlewar
 from django.middleware.http import ConditionalGetMiddleware
 from django.middleware.gzip import GZipMiddleware
 from django.middleware.transaction import TransactionMiddleware
-from django.test import TransactionTestCase, TestCase, RequestFactory
-from django.test.utils import override_settings, IgnoreDeprecationWarningsMixin
+from django.test import TransactionTestCase, TestCase, RequestFactory, override_settings
+from django.test.utils import IgnoreDeprecationWarningsMixin
 from django.utils import six
 from django.utils.encoding import force_str
 from django.utils.six.moves import xrange
diff --git a/tests/middleware_exceptions/tests.py b/tests/middleware_exceptions/tests.py
index 47852f35fa..b11986d4d0 100644
--- a/tests/middleware_exceptions/tests.py
+++ b/tests/middleware_exceptions/tests.py
@@ -5,8 +5,7 @@ from django.core.signals import got_request_exception
 from django.http import HttpResponse
 from django.template.response import TemplateResponse
 from django.template import Template
-from django.test import TestCase
-from django.test.utils import override_settings
+from django.test import TestCase, override_settings
 
 
 class TestException(Exception):
diff --git a/tests/migrate_signals/models.py b/tests/migrate_signals/models.py
index 55a8657a3c..2cd71391fb 100644
--- a/tests/migrate_signals/models.py
+++ b/tests/migrate_signals/models.py
@@ -1,2 +1,2 @@
-# Remove this module when pre/post_migrate are refactored to use something
-# other than a models module for their "sender" argument.
+# This module has to exist, otherwise pre/post_migrate aren't sent for the
+# migrate_signals application.
diff --git a/tests/migrate_signals/tests.py b/tests/migrate_signals/tests.py
index 9daa7ae376..7e1d5be103 100644
--- a/tests/migrate_signals/tests.py
+++ b/tests/migrate_signals/tests.py
@@ -1,12 +1,12 @@
+from django.apps import apps
 from django.db.models import signals
 from django.test import TestCase
 from django.core import management
 from django.utils import six
 
-from . import models
 
-
-PRE_MIGRATE_ARGS = ['app', 'create_models', 'verbosity', 'interactive', 'db']
+APP_CONFIG = apps.get_app_config('migrate_signals')
+PRE_MIGRATE_ARGS = ['app_config', 'verbosity', 'interactive', 'db']
 MIGRATE_DATABASE = 'default'
 MIGRATE_VERBOSITY = 1
 MIGRATE_INTERACTIVE = False
@@ -39,7 +39,7 @@ class OneTimeReceiver(object):
             self.call_counter = self.call_counter + 1
             self.call_args = kwargs
             # we need to test only one call of migrate
-            signals.pre_migrate.disconnect(pre_migrate_receiver, sender=models)
+            signals.pre_migrate.disconnect(pre_migrate_receiver, sender=APP_CONFIG)
 
 
 # We connect receiver here and not in unit test code because we need to
@@ -51,21 +51,19 @@ class OneTimeReceiver(object):
 #   3. Test runner calls migrate for create default database.
 #   4. Test runner execute our unit test code.
 pre_migrate_receiver = OneTimeReceiver()
-signals.pre_migrate.connect(pre_migrate_receiver, sender=models)
+signals.pre_migrate.connect(pre_migrate_receiver, sender=APP_CONFIG)
 
 
 class MigrateSignalTests(TestCase):
 
-    available_apps = [
-        'migrate_signals',
-    ]
+    available_apps = ['migrate_signals']
 
     def test_pre_migrate_call_time(self):
         self.assertEqual(pre_migrate_receiver.call_counter, 1)
 
     def test_pre_migrate_args(self):
         r = PreMigrateReceiver()
-        signals.pre_migrate.connect(r, sender=models)
+        signals.pre_migrate.connect(r, sender=APP_CONFIG)
         management.call_command('migrate', database=MIGRATE_DATABASE,
             verbosity=MIGRATE_VERBOSITY, interactive=MIGRATE_INTERACTIVE,
             load_initial_data=False, stdout=six.StringIO())
@@ -73,7 +71,7 @@ class MigrateSignalTests(TestCase):
         args = r.call_args
         self.assertEqual(r.call_counter, 1)
         self.assertEqual(set(args), set(PRE_MIGRATE_ARGS))
-        self.assertEqual(args['app'], models)
+        self.assertEqual(args['app_config'], APP_CONFIG)
         self.assertEqual(args['verbosity'], MIGRATE_VERBOSITY)
         self.assertEqual(args['interactive'], MIGRATE_INTERACTIVE)
         self.assertEqual(args['db'], 'default')
diff --git a/tests/migrations/models.py b/tests/migrations/models.py
index cfc9604551..f76a84054f 100644
--- a/tests/migrations/models.py
+++ b/tests/migrations/models.py
@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 from __future__ import unicode_literals
 
-from django.core.apps.cache import AppCache
+from django.apps.registry import Apps
 from django.db import models
 from django.utils.encoding import python_2_unicode_compatible
 
@@ -12,7 +12,7 @@ class UnicodeModel(models.Model):
 
     class Meta:
         # Disable auto loading of this model as we load it on our own
-        app_cache = AppCache()
+        apps = Apps()
         verbose_name = 'úñí©óðé µóðéø'
         verbose_name_plural = 'úñí©óðé µóðéøß'
 
@@ -32,4 +32,4 @@ class UnserializableModel(models.Model):
 
     class Meta:
         # Disable auto loading of this model as we load it on our own
-        app_cache = AppCache()
+        apps = Apps()
diff --git a/tests/migrations/test_commands.py b/tests/migrations/test_commands.py
index 59cd56e78b..e53b26c638 100644
--- a/tests/migrations/test_commands.py
+++ b/tests/migrations/test_commands.py
@@ -5,9 +5,9 @@ import codecs
 import os
 import shutil
 
-from django.core.apps import app_cache
+from django.apps import apps
 from django.core.management import call_command, CommandError
-from django.test.utils import override_settings
+from django.test import override_settings
 from django.utils import six
 from django.utils._os import upath
 from django.utils.encoding import force_text
@@ -131,11 +131,12 @@ class MakeMigrationsTests(MigrationTestBase):
         self.test_dir = os.path.abspath(os.path.dirname(upath(__file__)))
         self.migration_dir = os.path.join(self.test_dir, 'migrations_%d' % self.creation_counter)
         self.migration_pkg = "migrations.migrations_%d" % self.creation_counter
-        self._old_models = app_cache.app_configs['migrations'].models.copy()
+        self._old_models = apps.app_configs['migrations'].models.copy()
 
     def tearDown(self):
-        app_cache.app_configs['migrations'].models = self._old_models
-        app_cache._get_models_cache = {}
+        apps.app_configs['migrations'].models = self._old_models
+        apps.all_models['migrations'] = self._old_models
+        apps.clear_cache()
 
         os.chdir(self.test_dir)
         try:
@@ -151,7 +152,7 @@ class MakeMigrationsTests(MigrationTestBase):
 
     def test_files_content(self):
         self.assertTableNotExists("migrations_unicodemodel")
-        app_cache.register_model('migrations', UnicodeModel)
+        apps.register_model('migrations', UnicodeModel)
         with override_settings(MIGRATION_MODULES={"migrations": self.migration_pkg}):
             call_command("makemigrations", "migrations", verbosity=0)
 
@@ -187,7 +188,7 @@ class MakeMigrationsTests(MigrationTestBase):
 
     def test_failing_migration(self):
         #21280 - If a migration fails to serialize, it shouldn't generate an empty file.
-        app_cache.register_model('migrations', UnserializableModel)
+        apps.register_model('migrations', UnserializableModel)
 
         with six.assertRaisesRegex(self, ValueError, r'Cannot serialize'):
             with override_settings(MIGRATION_MODULES={"migrations": self.migration_pkg}):
diff --git a/tests/migrations/test_executor.py b/tests/migrations/test_executor.py
index 5c0131d1d3..e8dcacd80e 100644
--- a/tests/migrations/test_executor.py
+++ b/tests/migrations/test_executor.py
@@ -1,6 +1,7 @@
-from django.test.utils import override_settings
 from django.db import connection
 from django.db.migrations.executor import MigrationExecutor
+from django.test import override_settings
+
 from .test_base import MigrationTestBase
 
 
diff --git a/tests/migrations/test_loader.py b/tests/migrations/test_loader.py
index 80ac9ffd73..f661a03b02 100644
--- a/tests/migrations/test_loader.py
+++ b/tests/migrations/test_loader.py
@@ -1,7 +1,6 @@
 from unittest import skipIf
 
-from django.test import TestCase
-from django.test.utils import override_settings
+from django.test import TestCase, override_settings
 from django.db import connection
 from django.db.migrations.loader import MigrationLoader, AmbiguityError
 from django.db.migrations.recorder import MigrationRecorder
@@ -44,13 +43,16 @@ class LoaderTests(TestCase):
     def test_load(self):
         """
         Makes sure the loader can load the migrations for the test apps,
-        and then render them out to a new AppCache.
+        and then render them out to a new Apps.
         """
         # Load and test the plan
         migration_loader = MigrationLoader(connection)
         self.assertEqual(
             migration_loader.graph.forwards_plan(("migrations", "0002_second")),
-            [("migrations", "0001_initial"), ("migrations", "0002_second")],
+            [
+                ("migrations", "0001_initial"),
+                ("migrations", "0002_second"),
+            ],
         )
         # Now render it out!
         project_state = migration_loader.graph.project_state(("migrations", "0002_second"))
@@ -68,6 +70,30 @@ class LoaderTests(TestCase):
             ["id", "author"]
         )
 
+    @override_settings(MIGRATION_MODULES={"migrations": "migrations.test_migrations_unmigdep"})
+    def test_load_unmigrated_dependency(self):
+        """
+        Makes sure the loader can load migrations with a dependency on an unmigrated app.
+        """
+        # Load and test the plan
+        migration_loader = MigrationLoader(connection)
+        self.assertEqual(
+            migration_loader.graph.forwards_plan(("migrations", "0001_initial")),
+            [
+                ("auth", "__first__"),
+                ("migrations", "0001_initial"),
+            ],
+        )
+        # Now render it out!
+        project_state = migration_loader.graph.project_state(("migrations", "0001_initial"))
+        self.assertEqual(len([m for a, m in project_state.models if a == "migrations"]), 1)
+
+        book_state = project_state.models["migrations", "book"]
+        self.assertEqual(
+            [x for x, y in book_state.fields],
+            ["id", "user"]
+        )
+
     @override_settings(MIGRATION_MODULES={"migrations": "migrations.test_migrations"})
     def test_name_match(self):
         "Tests prefix name matching"
diff --git a/tests/migrations/test_migrations/0002_second.py b/tests/migrations/test_migrations/0002_second.py
index ace9a83347..736e844825 100644
--- a/tests/migrations/test_migrations/0002_second.py
+++ b/tests/migrations/test_migrations/0002_second.py
@@ -3,7 +3,9 @@ from django.db import migrations, models
 
 class Migration(migrations.Migration):
 
-    dependencies = [("migrations", "0001_initial")]
+    dependencies = [
+        ("migrations", "0001_initial"),
+    ]
 
     operations = [
 
diff --git a/tests/migrations/test_migrations_unmigdep/0001_initial.py b/tests/migrations/test_migrations_unmigdep/0001_initial.py
new file mode 100644
index 0000000000..f4c11b4657
--- /dev/null
+++ b/tests/migrations/test_migrations_unmigdep/0001_initial.py
@@ -0,0 +1,20 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("auth", "__first__"),
+    ]
+
+    operations = [
+
+        migrations.CreateModel(
+            "Book",
+            [
+                ("id", models.AutoField(primary_key=True)),
+                ("user", models.ForeignKey("auth.User", null=True)),
+            ],
+        )
+
+    ]
diff --git a/tests/migrations/test_migrations_unmigdep/__init__.py b/tests/migrations/test_migrations_unmigdep/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/tests/migrations/test_operations.py b/tests/migrations/test_operations.py
index 0ce030a66c..d11fda23c8 100644
--- a/tests/migrations/test_operations.py
+++ b/tests/migrations/test_operations.py
@@ -203,8 +203,8 @@ class OperationTests(MigrationTestBase):
         self.assertColumnNotExists("test_adflmm_pony", "stables")
         # Make sure the M2M field actually works
         with atomic():
-            new_app_cache = new_state.render()
-            Pony = new_app_cache.get_model("test_adflmm", "Pony")
+            new_apps = new_state.render()
+            Pony = new_apps.get_model("test_adflmm", "Pony")
             p = Pony.objects.create(pink=False, weight=4.55)
             p.stables.create()
             self.assertEqual(p.stables.count(), 1)
diff --git a/tests/migrations/test_state.py b/tests/migrations/test_state.py
index 7a06ecd474..e2d970e0f5 100644
--- a/tests/migrations/test_state.py
+++ b/tests/migrations/test_state.py
@@ -1,4 +1,4 @@
-from django.core.apps.cache import AppCache
+from django.apps.registry import Apps
 from django.db import models
 from django.db.migrations.state import ProjectState, ModelState, InvalidBasesError
 from django.test import TestCase
@@ -11,10 +11,10 @@ class StateTests(TestCase):
 
     def test_create(self):
         """
-        Tests making a ProjectState from an AppCache
+        Tests making a ProjectState from an Apps
         """
 
-        new_app_cache = AppCache()
+        new_apps = Apps(["migrations"])
 
         class Author(models.Model):
             name = models.CharField(max_length=255)
@@ -23,13 +23,13 @@ class StateTests(TestCase):
 
             class Meta:
                 app_label = "migrations"
-                app_cache = new_app_cache
+                apps = new_apps
                 unique_together = ["name", "bio"]
 
         class AuthorProxy(Author):
             class Meta:
                 app_label = "migrations"
-                app_cache = new_app_cache
+                apps = new_apps
                 proxy = True
                 ordering = ["name"]
 
@@ -40,11 +40,11 @@ class StateTests(TestCase):
 
             class Meta:
                 app_label = "migrations"
-                app_cache = new_app_cache
+                apps = new_apps
                 verbose_name = "tome"
                 db_table = "test_tome"
 
-        project_state = ProjectState.from_app_cache(new_app_cache)
+        project_state = ProjectState.from_apps(new_apps)
         author_state = project_state.models['migrations', 'author']
         author_proxy_state = project_state.models['migrations', 'authorproxy']
         book_state = project_state.models['migrations', 'book']
@@ -75,7 +75,7 @@ class StateTests(TestCase):
 
     def test_render(self):
         """
-        Tests rendering a ProjectState into an AppCache.
+        Tests rendering a ProjectState into an Apps.
         """
         project_state = ProjectState()
         project_state.add_model_state(ModelState(
@@ -90,9 +90,9 @@ class StateTests(TestCase):
             None,
         ))
 
-        new_app_cache = project_state.render()
-        self.assertEqual(new_app_cache.get_model("migrations", "Tag")._meta.get_field_by_name("name")[0].max_length, 100)
-        self.assertEqual(new_app_cache.get_model("migrations", "Tag")._meta.get_field_by_name("hidden")[0].null, False)
+        new_apps = project_state.render()
+        self.assertEqual(new_apps.get_model("migrations", "Tag")._meta.get_field_by_name("name")[0].max_length, 100)
+        self.assertEqual(new_apps.get_model("migrations", "Tag")._meta.get_field_by_name("hidden")[0].null, False)
 
     def test_render_model_inheritance(self):
         class Book(models.Model):
@@ -100,90 +100,90 @@ class StateTests(TestCase):
 
             class Meta:
                 app_label = "migrations"
-                app_cache = AppCache()
+                apps = Apps()
 
         class Novel(Book):
             class Meta:
                 app_label = "migrations"
-                app_cache = AppCache()
+                apps = Apps()
 
         # First, test rendering individually
-        app_cache = AppCache()
+        apps = Apps(["migrations"])
 
         # We shouldn't be able to render yet
         ms = ModelState.from_model(Novel)
         with self.assertRaises(InvalidBasesError):
-            ms.render(app_cache)
+            ms.render(apps)
 
-        # Once the parent model is in the app cache, it should be fine
-        ModelState.from_model(Book).render(app_cache)
-        ModelState.from_model(Novel).render(app_cache)
+        # Once the parent model is in the app registry, it should be fine
+        ModelState.from_model(Book).render(apps)
+        ModelState.from_model(Novel).render(apps)
 
     def test_render_model_with_multiple_inheritance(self):
         class Foo(models.Model):
             class Meta:
                 app_label = "migrations"
-                app_cache = AppCache()
+                apps = Apps()
 
         class Bar(models.Model):
             class Meta:
                 app_label = "migrations"
-                app_cache = AppCache()
+                apps = Apps()
 
         class FooBar(Foo, Bar):
             class Meta:
                 app_label = "migrations"
-                app_cache = AppCache()
+                apps = Apps()
 
-        app_cache = AppCache()
+        apps = Apps(["migrations"])
 
         # We shouldn't be able to render yet
         ms = ModelState.from_model(FooBar)
         with self.assertRaises(InvalidBasesError):
-            ms.render(app_cache)
+            ms.render(apps)
 
-        # Once the parent models are in the app cache, it should be fine
-        ModelState.from_model(Foo).render(app_cache)
-        ModelState.from_model(Bar).render(app_cache)
-        ModelState.from_model(FooBar).render(app_cache)
+        # Once the parent models are in the app registry, it should be fine
+        ModelState.from_model(Foo).render(apps)
+        ModelState.from_model(Bar).render(apps)
+        ModelState.from_model(FooBar).render(apps)
 
     def test_render_project_dependencies(self):
         """
         Tests that the ProjectState render method correctly renders models
         to account for inter-model base dependencies.
         """
-        new_app_cache = AppCache()
+        new_apps = Apps()
 
         class A(models.Model):
             class Meta:
                 app_label = "migrations"
-                app_cache = new_app_cache
+                apps = new_apps
 
         class B(A):
             class Meta:
                 app_label = "migrations"
-                app_cache = new_app_cache
+                apps = new_apps
 
         class C(B):
             class Meta:
                 app_label = "migrations"
-                app_cache = new_app_cache
+                apps = new_apps
 
         class D(A):
             class Meta:
                 app_label = "migrations"
-                app_cache = new_app_cache
+                apps = new_apps
 
         class E(B):
             class Meta:
                 app_label = "migrations"
-                app_cache = new_app_cache
+                apps = new_apps
                 proxy = True
 
         class F(D):
             class Meta:
                 app_label = "migrations"
-                app_cache = new_app_cache
+                apps = new_apps
                 proxy = True
 
         # Make a ProjectState and render it
@@ -194,8 +194,8 @@ class StateTests(TestCase):
         project_state.add_model_state(ModelState.from_model(D))
         project_state.add_model_state(ModelState.from_model(E))
         project_state.add_model_state(ModelState.from_model(F))
-        final_app_cache = project_state.render()
-        self.assertEqual(len(final_app_cache.get_models()), 6)
+        final_apps = project_state.render()
+        self.assertEqual(len(final_apps.get_models()), 6)
 
         # Now make an invalid ProjectState and make sure it fails
         project_state = ProjectState()
diff --git a/tests/migrations/test_writer.py b/tests/migrations/test_writer.py
index 76fe5b5a9e..42e6c4356d 100644
--- a/tests/migrations/test_writer.py
+++ b/tests/migrations/test_writer.py
@@ -5,11 +5,10 @@ from __future__ import unicode_literals
 import datetime
 import os
 
-from django.core.apps import app_cache
 from django.core.validators import RegexValidator, EmailValidator
 from django.db import models, migrations
 from django.db.migrations.writer import MigrationWriter
-from django.test import TestCase, override_settings
+from django.test import TestCase
 from django.utils import six
 from django.utils.deconstruct import deconstructible
 from django.utils.translation import ugettext_lazy as _
@@ -122,9 +121,8 @@ class WriterTests(TestCase):
 
         base_dir = os.path.dirname(os.path.dirname(__file__))
 
-        with override_settings(INSTALLED_APPS=test_apps):
-            for app in test_apps:
-                app_cache.load_app(app)
+        for app in test_apps:
+            with self.modify_settings(INSTALLED_APPS={'append': app}):
                 migration = migrations.Migration('0001_initial', app.split('.')[-1])
                 expected_path = os.path.join(base_dir, *(app.split('.') + ['migrations', '0001_initial.py']))
                 writer = MigrationWriter(migration)
diff --git a/tests/model_forms/tests.py b/tests/model_forms/tests.py
index bf7b3d296a..c5e16a2c14 100644
--- a/tests/model_forms/tests.py
+++ b/tests/model_forms/tests.py
@@ -14,7 +14,7 @@ from django.db import connection
 from django.db.models.query import EmptyQuerySet
 from django.forms.models import model_to_dict
 from django.utils._os import upath
-from django.test import TestCase
+from django.test import TestCase, skipUnlessDBFeature
 from django.utils import six
 
 from .models import (Article, ArticleStatus, BetterWriter, BigInt, Book,
@@ -637,6 +637,7 @@ class UniqueTest(TestCase):
         self.assertEqual(len(form.errors), 1)
         self.assertEqual(form.errors['__all__'], ['Price with this Price and Quantity already exists.'])
 
+    @skipUnlessDBFeature('ignores_nulls_in_unique_constraints')
     def test_unique_null(self):
         title = 'I May Be Wrong But I Doubt It'
         form = BookForm({'title': title, 'author': self.writer.pk})
diff --git a/tests/model_formsets/tests.py b/tests/model_formsets/tests.py
index ac9d68132e..c1e01cd6be 100644
--- a/tests/model_formsets/tests.py
+++ b/tests/model_formsets/tests.py
@@ -55,8 +55,8 @@ class DeletionTests(TestCase):
             'form-0-name': 'test',
             'form-1-id': '',
             'form-1-name': 'x' * 1000,  # Too long
-            'form-1-id': six.text_type(poet.id),  # Violate unique constraint
-            'form-1-name': 'test2',
+            'form-2-id': six.text_type(poet.id),  # Violate unique constraint
+            'form-2-name': 'test2',
         }
         formset = PoetFormSet(data, queryset=Poet.objects.all())
         # Make sure this form doesn't pass validation.
diff --git a/tests/modeladmin/tests.py b/tests/modeladmin/tests.py
index 38bfcc25dd..0c7a115fef 100644
--- a/tests/modeladmin/tests.py
+++ b/tests/modeladmin/tests.py
@@ -13,8 +13,8 @@ from django.contrib.admin import (SimpleListFilter,
 from django.core.exceptions import ImproperlyConfigured
 from django.forms.models import BaseModelFormSet
 from django.forms.widgets import Select
-from django.test import TestCase
-from django.test.utils import str_prefix, override_settings
+from django.test import TestCase, override_settings
+from django.test.utils import str_prefix
 from django.utils import six
 
 from .models import Band, Concert, ValidationTestModel, ValidationTestInlineModel
diff --git a/tests/multiple_database/tests.py b/tests/multiple_database/tests.py
index 222d236bb0..8ffe00578b 100644
--- a/tests/multiple_database/tests.py
+++ b/tests/multiple_database/tests.py
@@ -10,8 +10,7 @@ from django.core import management
 from django.db import connections, router, DEFAULT_DB_ALIAS, transaction
 from django.db.models import signals
 from django.db.utils import ConnectionRouter
-from django.test import TestCase
-from django.test.utils import override_settings
+from django.test import TestCase, override_settings
 from django.utils.six import StringIO
 
 from .models import Book, Person, Pet, Review, UserProfile
diff --git a/tests/no_models/tests.py b/tests/no_models/tests.py
index 34ef724446..bd17364071 100644
--- a/tests/no_models/tests.py
+++ b/tests/no_models/tests.py
@@ -1,4 +1,4 @@
-from django.core.apps import app_cache
+from django.apps import apps
 from django.test import TestCase
 
 
@@ -6,5 +6,5 @@ class NoModelTests(TestCase):
 
     def test_no_models(self):
         """Test that it's possible to load an app with no models.py file."""
-        app_config = app_cache.get_app_config('no_models')
+        app_config = apps.get_app_config('no_models')
         self.assertIsNone(app_config.models_module)
diff --git a/tests/one_to_one_regress/tests.py b/tests/one_to_one_regress/tests.py
index da4309e821..17528de311 100644
--- a/tests/one_to_one_regress/tests.py
+++ b/tests/one_to_one_regress/tests.py
@@ -1,5 +1,6 @@
 from __future__ import unicode_literals
 
+from django.db import connection
 from django.test import TestCase
 
 from .models import (Bar, Favorites, HiddenPointer, Place, Restaurant, Target,
@@ -226,12 +227,15 @@ class OneToOneRegressionTests(TestCase):
             with self.assertRaises(UndergroundBar.DoesNotExist):
                 p.undergroundbar
 
-        UndergroundBar.objects.create()
+        # Several instances of the origin are only possible if database allows
+        # inserting multiple NULL rows for a unique constraint
+        if connection.features.ignores_nulls_in_unique_constraints:
+            UndergroundBar.objects.create()
 
-        # When there are several instances of the origin
-        with self.assertNumQueries(0):
-            with self.assertRaises(UndergroundBar.DoesNotExist):
-                p.undergroundbar
+            # When there are several instances of the origin
+            with self.assertNumQueries(0):
+                with self.assertRaises(UndergroundBar.DoesNotExist):
+                    p.undergroundbar
 
     def test_set_reverse_on_unsaved_object(self):
         """
diff --git a/tests/prefetch_related/tests.py b/tests/prefetch_related/tests.py
index 7570bdce6e..5dfca0fa99 100644
--- a/tests/prefetch_related/tests.py
+++ b/tests/prefetch_related/tests.py
@@ -3,8 +3,7 @@ from __future__ import unicode_literals
 from django.contrib.contenttypes.models import ContentType
 from django.db import connection
 from django.db.models import Prefetch
-from django.test import TestCase
-from django.test.utils import override_settings
+from django.test import TestCase, override_settings
 from django.utils import six
 
 from .models import (Author, Book, Reader, Qualification, Teacher, Department,
diff --git a/tests/proxy_model_inheritance/tests.py b/tests/proxy_model_inheritance/tests.py
index 861ab4af17..5ad5e08c25 100644
--- a/tests/proxy_model_inheritance/tests.py
+++ b/tests/proxy_model_inheritance/tests.py
@@ -1,50 +1,38 @@
-from __future__ import unicode_literals
+from __future__ import absolute_import, unicode_literals
 
 import os
 import sys
 
-from django.conf import settings
-from django.core.apps import app_cache
 from django.core.management import call_command
 from django.test import TestCase, TransactionTestCase
-from django.test.utils import override_settings
 from django.utils._os import upath
 
 from .models import (ConcreteModel, ConcreteModelSubclass,
     ConcreteModelSubclassProxy)
 
 
-@override_settings(INSTALLED_APPS=('app1', 'app2'))
 class ProxyModelInheritanceTests(TransactionTestCase):
     """
     Proxy model inheritance across apps can result in migrate not creating the table
     for the proxied model (as described in #12286).  This test creates two dummy
     apps and calls migrate, then verifies that the table has been created.
     """
-
     available_apps = []
 
     def setUp(self):
         self.old_sys_path = sys.path[:]
         sys.path.append(os.path.dirname(os.path.abspath(upath(__file__))))
-        for app in settings.INSTALLED_APPS:
-            app_cache.load_app(app)
 
     def tearDown(self):
         sys.path = self.old_sys_path
-        del app_cache.app_configs['app1']
-        del app_cache.app_configs['app2']
 
     def test_table_exists(self):
-        try:
-            app_cache.set_available_apps(settings.INSTALLED_APPS)
+        with self.modify_settings(INSTALLED_APPS={'append': ['app1', 'app2']}):
             call_command('migrate', verbosity=0)
-        finally:
-            app_cache.unset_available_apps()
-        from .app1.models import ProxyModel
-        from .app2.models import NiceModel
-        self.assertEqual(NiceModel.objects.all().count(), 0)
-        self.assertEqual(ProxyModel.objects.all().count(), 0)
+            from app1.models import ProxyModel
+            from app2.models import NiceModel
+            self.assertEqual(NiceModel.objects.all().count(), 0)
+            self.assertEqual(ProxyModel.objects.all().count(), 0)
 
 
 class MultiTableInheritanceProxyTest(TestCase):
@@ -54,7 +42,6 @@ class MultiTableInheritanceProxyTest(TestCase):
         Deleting an instance of a model proxying a multi-table inherited
         subclass should cascade delete down the whole inheritance chain (see
         #18083).
-
         """
         instance = ConcreteModelSubclassProxy.objects.create()
         instance.delete()
diff --git a/tests/proxy_models/tests.py b/tests/proxy_models/tests.py
index 3389f3597f..0f2b5349be 100644
--- a/tests/proxy_models/tests.py
+++ b/tests/proxy_models/tests.py
@@ -1,14 +1,13 @@
 from __future__ import unicode_literals
 
+from django.apps import apps
 from django.contrib import admin
 from django.contrib.contenttypes.models import ContentType
 from django.core import management
-from django.core.apps import app_cache
 from django.core.exceptions import FieldError
 from django.db import models, DEFAULT_DB_ALIAS
 from django.db.models import signals
-from django.test import TestCase
-from django.test.utils import override_settings
+from django.test import TestCase, override_settings
 
 
 from .models import (MyPerson, Person, StatusPerson, LowerStatusPerson,
@@ -156,7 +155,7 @@ class ProxyModelTests(TestCase):
     def test_swappable(self):
         # The models need to be removed after the test in order to prevent bad
         # interactions with the flush operation in other tests.
-        _old_models = app_cache.app_configs['proxy_models'].models.copy()
+        _old_models = apps.app_configs['proxy_models'].models.copy()
 
         try:
             class SwappableModel(models.Model):
@@ -174,8 +173,9 @@ class ProxyModelTests(TestCase):
                     class Meta:
                         proxy = True
         finally:
-            app_cache.app_configs['proxy_models'].models = _old_models
-            app_cache._get_models_cache = {}
+            apps.app_configs['proxy_models'].models = _old_models
+            apps.all_models['proxy_models'] = _old_models
+            apps.clear_cache()
 
     def test_myperson_manager(self):
         Person.objects.create(name="fred")
diff --git a/tests/requests/tests.py b/tests/requests/tests.py
index 850cf70c2f..bb56369371 100644
--- a/tests/requests/tests.py
+++ b/tests/requests/tests.py
@@ -13,9 +13,9 @@ from django.core.exceptions import SuspiciousOperation
 from django.core.handlers.wsgi import WSGIRequest, LimitedStream
 from django.http import (HttpRequest, HttpResponse, parse_cookie,
     build_request_repr, UnreadablePostError, RawPostDataException)
-from django.test import SimpleTestCase, TransactionTestCase
+from django.test import SimpleTestCase, TransactionTestCase, override_settings
 from django.test.client import FakePayload
-from django.test.utils import override_settings, str_prefix
+from django.test.utils import str_prefix
 from django.utils import six
 from django.utils.http import cookie_date, urlencode
 from django.utils.six.moves.urllib.parse import urlencode as original_urlencode
diff --git a/tests/runtests.py b/tests/runtests.py
index badbd6fbec..dcd9c885bd 100755
--- a/tests/runtests.py
+++ b/tests/runtests.py
@@ -9,6 +9,7 @@ import sys
 import tempfile
 import warnings
 
+import django
 from django import contrib
 from django.utils._os import upath
 from django.utils import six
@@ -80,14 +81,13 @@ def get_test_modules():
 
 
 def get_installed():
-    from django.core.apps import app_cache
-    return [app_config.name for app_config in app_cache.get_app_configs()]
+    from django.apps import apps
+    return [app_config.name for app_config in apps.get_app_configs()]
 
 
 def setup(verbosity, test_labels):
-    import django
+    from django.apps import apps, AppConfig
     from django.conf import settings
-    from django.core.apps import app_cache
     from django.test import TransactionTestCase, TestCase
 
     print("Testing against Django installed in '%s'" % os.path.dirname(django.__file__))
@@ -125,10 +125,18 @@ def setup(verbosity, test_labels):
         handler = logging.StreamHandler()
         logger.addHandler(handler)
 
+    warnings.filterwarnings(
+        'ignore',
+        'django.contrib.comments is deprecated and will be removed before Django 1.8.',
+        DeprecationWarning
+    )
+    warnings.filterwarnings(
+        'ignore',
+        'Model class django.contrib.comments.models.*supported in Django 1.9.',
+        PendingDeprecationWarning
+    )
     # Load all the ALWAYS_INSTALLED_APPS.
-    with warnings.catch_warnings():
-        warnings.filterwarnings('ignore', 'django.contrib.comments is deprecated and will be removed before Django 1.8.', DeprecationWarning)
-        app_cache.populate()
+    django.setup()
 
     # Load all the test model apps.
     test_modules = get_test_modules()
@@ -154,19 +162,21 @@ def setup(verbosity, test_labels):
         if not test_labels:
             module_found_in_labels = True
         else:
-            match = lambda label: (
-                module_label == label or  # exact match
-                module_label.startswith(label + '.')  # ancestor match
-            )
-
-            module_found_in_labels = any(match(l) for l in test_labels_set)
+            module_found_in_labels = any(
+                # exact match or ancestor match
+                module_label == label or module_label.startswith(label + '.')
+                for label in test_labels_set)
 
         if module_found_in_labels:
             if verbosity >= 2:
                 print("Importing application %s" % module_name)
-            app_cache.load_app(module_label)
+            # HACK.
             if module_label not in settings.INSTALLED_APPS:
                 settings.INSTALLED_APPS.append(module_label)
+            app_config = AppConfig.create(module_label)
+            apps.app_configs[app_config.label] = app_config
+            app_config.import_models(apps.all_models[app_config.label])
+            apps.clear_cache()
 
     return state
 
diff --git a/tests/schema/models.py b/tests/schema/models.py
index 8b24b88c05..67cfcf6a89 100644
--- a/tests/schema/models.py
+++ b/tests/schema/models.py
@@ -1,11 +1,12 @@
-from django.core.apps.cache import AppCache
+from django.apps.registry import Apps
 from django.db import models
+from django.utils.encoding import python_2_unicode_compatible
 
 # Because we want to test creation and deletion of these as separate things,
-# these models are all inserted into a separate AppCache so the main test
+# these models are all inserted into a separate Apps so the main test
 # runner doesn't migrate them.
 
-new_app_cache = AppCache()
+new_apps = Apps()
 
 
 class Author(models.Model):
@@ -13,14 +14,14 @@ class Author(models.Model):
     height = models.PositiveIntegerField(null=True, blank=True)
 
     class Meta:
-        app_cache = new_app_cache
+        apps = new_apps
 
 
 class AuthorWithM2M(models.Model):
     name = models.CharField(max_length=255)
 
     class Meta:
-        app_cache = new_app_cache
+        apps = new_apps
 
 
 class Book(models.Model):
@@ -30,7 +31,7 @@ class Book(models.Model):
     # tags = models.ManyToManyField("Tag", related_name="books")
 
     class Meta:
-        app_cache = new_app_cache
+        apps = new_apps
 
 
 class BookWithM2M(models.Model):
@@ -40,7 +41,7 @@ class BookWithM2M(models.Model):
     tags = models.ManyToManyField("TagM2MTest", related_name="books")
 
     class Meta:
-        app_cache = new_app_cache
+        apps = new_apps
 
 
 class BookWithSlug(models.Model):
@@ -50,7 +51,7 @@ class BookWithSlug(models.Model):
     slug = models.CharField(max_length=20, unique=True)
 
     class Meta:
-        app_cache = new_app_cache
+        apps = new_apps
         db_table = "schema_book"
 
 
@@ -59,7 +60,7 @@ class Tag(models.Model):
     slug = models.SlugField(unique=True)
 
     class Meta:
-        app_cache = new_app_cache
+        apps = new_apps
 
 
 class TagM2MTest(models.Model):
@@ -67,7 +68,7 @@ class TagM2MTest(models.Model):
     slug = models.SlugField(unique=True)
 
     class Meta:
-        app_cache = new_app_cache
+        apps = new_apps
 
 
 class TagIndexed(models.Model):
@@ -75,7 +76,7 @@ class TagIndexed(models.Model):
     slug = models.SlugField(unique=True)
 
     class Meta:
-        app_cache = new_app_cache
+        apps = new_apps
         index_together = [["slug", "title"]]
 
 
@@ -84,7 +85,7 @@ class TagUniqueRename(models.Model):
     slug2 = models.SlugField(unique=True)
 
     class Meta:
-        app_cache = new_app_cache
+        apps = new_apps
         db_table = "schema_tag"
 
 
@@ -93,7 +94,7 @@ class UniqueTest(models.Model):
     slug = models.SlugField(unique=False)
 
     class Meta:
-        app_cache = new_app_cache
+        apps = new_apps
         unique_together = ["year", "slug"]
 
 
@@ -101,4 +102,16 @@ class BookWithLongName(models.Model):
     author_foreign_key_with_really_long_field_name = models.ForeignKey(Author)
 
     class Meta:
-        app_cache = new_app_cache
+        apps = new_apps
+
+
+# Based on tests/reserved_names/models.py
+@python_2_unicode_compatible
+class Thing(models.Model):
+    when = models.CharField(max_length=1, primary_key=True)
+
+    class Meta:
+        db_table = 'drop'
+
+    def __str__(self):
+        return self.when
diff --git a/tests/schema/tests.py b/tests/schema/tests.py
index 66450956ef..e0000e2b9d 100644
--- a/tests/schema/tests.py
+++ b/tests/schema/tests.py
@@ -3,13 +3,13 @@ import datetime
 import unittest
 
 from django.test import TransactionTestCase
-from django.db import connection, DatabaseError, IntegrityError
+from django.db import connection, DatabaseError, IntegrityError, OperationalError
 from django.db.models.fields import IntegerField, TextField, CharField, SlugField
 from django.db.models.fields.related import ManyToManyField, ForeignKey
 from django.db.transaction import atomic
 from .models import (Author, AuthorWithM2M, Book, BookWithLongName,
     BookWithSlug, BookWithM2M, Tag, TagIndexed, TagM2MTest, TagUniqueRename,
-    UniqueTest)
+    UniqueTest, Thing)
 
 
 class SchemaTests(TransactionTestCase):
@@ -26,6 +26,7 @@ class SchemaTests(TransactionTestCase):
     models = [
         Author, AuthorWithM2M, Book, BookWithLongName, BookWithSlug,
         BookWithM2M, Tag, TagIndexed, TagM2MTest, TagUniqueRename, UniqueTest,
+        Thing
     ]
 
     # Utility functions
@@ -683,3 +684,26 @@ class SchemaTests(TransactionTestCase):
             column_name,
             connection.introspection.get_indexes(connection.cursor(), BookWithLongName._meta.db_table),
         )
+
+    def test_creation_deletion_reserved_names(self):
+        """
+        Tries creating a model's table, and then deleting it when it has a
+        SQL reserved name.
+        """
+        # Create the table
+        with connection.schema_editor() as editor:
+            try:
+                editor.create_model(Thing)
+            except OperationalError as e:
+                self.fail("Errors when applying initial migration for a model "
+                          "with a table named after a SQL reserved word: %s" % e)
+        # Check that it's there
+        list(Thing.objects.all())
+        # Clean up that table
+        with connection.schema_editor() as editor:
+            editor.delete_model(Thing)
+        # Check that it's gone
+        self.assertRaises(
+            DatabaseError,
+            lambda: list(Thing.objects.all()),
+        )
diff --git a/tests/select_for_update/tests.py b/tests/select_for_update/tests.py
index 6fadbdb799..278458ed39 100644
--- a/tests/select_for_update/tests.py
+++ b/tests/select_for_update/tests.py
@@ -8,7 +8,7 @@ from django.db import transaction, connection, router
 from django.db.utils import ConnectionHandler, DEFAULT_DB_ALIAS, DatabaseError
 from django.test import (TransactionTestCase, skipIfDBFeature,
     skipUnlessDBFeature)
-from django.test.utils import override_settings
+from django.test import override_settings
 
 from multiple_database.routers import TestRouter
 
diff --git a/tests/serializers/tests.py b/tests/serializers/tests.py
index b9e3bb543f..6433101878 100644
--- a/tests/serializers/tests.py
+++ b/tests/serializers/tests.py
@@ -16,8 +16,8 @@ except ImportError:
 
 from django.core import management, serializers
 from django.db import transaction, connection
-from django.test import TestCase, TransactionTestCase
-from django.test.utils import Approximate, override_settings
+from django.test import TestCase, TransactionTestCase, override_settings
+from django.test.utils import Approximate
 from django.utils import six
 from django.utils.six import StringIO
 
diff --git a/tests/servers/tests.py b/tests/servers/tests.py
index 5ce86d3529..8f8a310c71 100644
--- a/tests/servers/tests.py
+++ b/tests/servers/tests.py
@@ -9,7 +9,7 @@ import socket
 
 from django.core.exceptions import ImproperlyConfigured
 from django.test import LiveServerTestCase
-from django.test.utils import override_settings
+from django.test import override_settings
 from django.utils.http import urlencode
 from django.utils.six.moves.urllib.error import HTTPError
 from django.utils.six.moves.urllib.request import urlopen
diff --git a/tests/settings_tests/tests.py b/tests/settings_tests/tests.py
index b148887e34..9b2f5c79fa 100644
--- a/tests/settings_tests/tests.py
+++ b/tests/settings_tests/tests.py
@@ -1,23 +1,62 @@
+import os
 import unittest
 import warnings
 
 from django.conf import settings
 from django.core.exceptions import ImproperlyConfigured
 from django.http import HttpRequest
-from django.test import SimpleTestCase, TransactionTestCase, TestCase, signals
-from django.test.utils import override_settings
+from django.test import (SimpleTestCase, TransactionTestCase, TestCase,
+    modify_settings, override_settings, signals)
 from django.utils import six
 
 
-@override_settings(TEST='override', TEST_OUTER='outer')
+@modify_settings(ITEMS={
+    'prepend': ['b'],
+    'append': ['d'],
+    'remove': ['a', 'e']
+})
+@override_settings(ITEMS=['a', 'c', 'e'], ITEMS_OUTER=[1, 2, 3],
+                   TEST='override', TEST_OUTER='outer')
 class FullyDecoratedTranTestCase(TransactionTestCase):
 
     available_apps = []
 
     def test_override(self):
+        self.assertListEqual(settings.ITEMS, ['b', 'c', 'd'])
+        self.assertListEqual(settings.ITEMS_OUTER, [1, 2, 3])
         self.assertEqual(settings.TEST, 'override')
         self.assertEqual(settings.TEST_OUTER, 'outer')
 
+    @modify_settings(ITEMS={
+        'append': ['e', 'f'],
+        'prepend': ['a'],
+        'remove': ['d', 'c'],
+    })
+    def test_method_list_override(self):
+        self.assertListEqual(settings.ITEMS, ['a', 'b', 'e', 'f'])
+        self.assertListEqual(settings.ITEMS_OUTER, [1, 2, 3])
+
+    @modify_settings(ITEMS={
+        'append': ['b'],
+        'prepend': ['d'],
+        'remove': ['a', 'c', 'e'],
+    })
+    def test_method_list_override_no_ops(self):
+        self.assertListEqual(settings.ITEMS, ['b', 'd'])
+
+    @modify_settings(ITEMS={
+        'append': 'e',
+        'prepend': 'a',
+        'remove': 'c',
+    })
+    def test_method_list_override_strings(self):
+        self.assertListEqual(settings.ITEMS, ['a', 'b', 'd', 'e'])
+
+    @modify_settings(ITEMS={'remove': ['b', 'd']})
+    @modify_settings(ITEMS={'append': ['b'], 'prepend': ['d']})
+    def test_method_list_override_nested_order(self):
+        self.assertListEqual(settings.ITEMS, ['d', 'c', 'b'])
+
     @override_settings(TEST='override2')
     def test_method_override(self):
         self.assertEqual(settings.TEST, 'override2')
@@ -30,14 +69,26 @@ class FullyDecoratedTranTestCase(TransactionTestCase):
         self.assertEqual(FullyDecoratedTranTestCase.__module__, __name__)
 
 
-@override_settings(TEST='override')
+@modify_settings(ITEMS={
+    'prepend': ['b'],
+    'append': ['d'],
+    'remove': ['a', 'e']
+})
+@override_settings(ITEMS=['a', 'c', 'e'], TEST='override')
 class FullyDecoratedTestCase(TestCase):
 
     def test_override(self):
+        self.assertListEqual(settings.ITEMS, ['b', 'c', 'd'])
         self.assertEqual(settings.TEST, 'override')
 
+    @modify_settings(ITEMS={
+        'append': 'e',
+        'prepend': 'a',
+        'remove': 'c',
+    })
     @override_settings(TEST='override2')
     def test_method_override(self):
+        self.assertListEqual(settings.ITEMS, ['a', 'b', 'd', 'e'])
         self.assertEqual(settings.TEST, 'override2')
 
 
@@ -72,14 +123,17 @@ class ClassDecoratedTestCase(ClassDecoratedTestCaseSuper):
             self.fail()
 
 
-@override_settings(TEST='override-parent')
+@modify_settings(ITEMS={'append': 'mother'})
+@override_settings(ITEMS=['father'], TEST='override-parent')
 class ParentDecoratedTestCase(TestCase):
     pass
 
 
+@modify_settings(ITEMS={'append': ['child']})
 @override_settings(TEST='override-child')
 class ChildDecoratedTestCase(ParentDecoratedTestCase):
     def test_override_settings_inheritance(self):
+        self.assertEqual(settings.ITEMS, ['father', 'mother', 'child'])
         self.assertEqual(settings.TEST, 'override-child')
 
 
@@ -231,32 +285,13 @@ class TestComplexSettingOverride(TestCase):
                 self.assertEqual(settings.TEST_WARN, 'override')
 
             self.assertEqual(len(w), 1)
-            self.assertEqual(w[0].filename, __file__)
+            # File extension may by .py, .pyc, etc. Compare only basename.
+            self.assertEqual(os.path.splitext(w[0].filename)[0],
+                             os.path.splitext(__file__)[0])
             self.assertEqual(str(w[0].message),
                 'Overriding setting TEST_WARN can lead to unexpected behaviour.')
 
 
-class UniqueSettingsTests(TestCase):
-    """
-    Tests for the INSTALLED_APPS setting.
-    """
-    settings_module = settings
-
-    def setUp(self):
-        self._installed_apps = self.settings_module.INSTALLED_APPS
-
-    def tearDown(self):
-        self.settings_module.INSTALLED_APPS = self._installed_apps
-
-    def test_unique(self):
-        """
-        An ImproperlyConfigured exception is raised if the INSTALLED_APPS contains
-        any duplicate strings.
-        """
-        with self.assertRaises(ImproperlyConfigured):
-            self.settings_module.INSTALLED_APPS = ("myApp1", "myApp1", "myApp2", "myApp3")
-
-
 class TrailingSlashURLTests(TestCase):
     """
     Tests for the MEDIA_URL and STATIC_URL settings.
diff --git a/tests/staticfiles_tests/test_liveserver.py b/tests/staticfiles_tests/test_liveserver.py
index 71f4bb89a1..b7e309e1a7 100644
--- a/tests/staticfiles_tests/test_liveserver.py
+++ b/tests/staticfiles_tests/test_liveserver.py
@@ -7,7 +7,7 @@ django.test.LiveServerTestCase.
 import os
 
 from django.core.exceptions import ImproperlyConfigured
-from django.test.utils import override_settings
+from django.test import override_settings
 from django.utils.six.moves.urllib.request import urlopen
 from django.utils._os import upath
 
@@ -86,6 +86,9 @@ class StaticLiveServerChecks(LiveServerBase):
 
 class StaticLiveServerView(LiveServerBase):
 
+    # The test is going to access a static file stored in this application.
+    available_apps = ['staticfiles_tests.apps.test']
+
     def urlopen(self, url):
         return urlopen(self.live_server_url + url)
 
diff --git a/tests/staticfiles_tests/tests.py b/tests/staticfiles_tests/tests.py
index f5d871587c..1de9f9ed84 100644
--- a/tests/staticfiles_tests/tests.py
+++ b/tests/staticfiles_tests/tests.py
@@ -14,8 +14,7 @@ from django.conf import settings
 from django.core.cache.backends.base import BaseCache
 from django.core.exceptions import ImproperlyConfigured
 from django.core.management import call_command
-from django.test import TestCase
-from django.test.utils import override_settings
+from django.test import TestCase, override_settings
 from django.utils.encoding import force_text
 from django.utils.functional import empty
 from django.utils._os import rmtree_errorhandler, upath
@@ -225,6 +224,17 @@ class TestFindStatic(CollectionTestCase, TestDefaults):
         self.assertIn('apps', force_text(lines[1]))
 
 
+class TestConfiguration(StaticFilesTestCase):
+    def test_location_empty(self):
+        err = six.StringIO()
+        for root in ['', None]:
+            with override_settings(STATIC_ROOT=root):
+                with six.assertRaisesRegex(
+                        self, ImproperlyConfigured,
+                        'without having set the STATIC_ROOT setting to a filesystem path'):
+                    call_command('collectstatic', interactive=False, verbosity=0, stderr=err)
+
+
 class TestCollection(CollectionTestCase, TestDefaults):
     """
     Test ``collectstatic`` management command.
@@ -298,7 +308,7 @@ class TestCollectionDryRun(CollectionTestCase, TestNoFilesCreated):
 class TestCollectionFilesOverride(CollectionTestCase):
     """
     Test overriding duplicated files by ``collectstatic`` management command.
-    Check for proper handling of apps order in INSTALLED_APPS even if file modification
+    Check for proper handling of apps order in installed apps even if file modification
     dates are in different order:
 
         'staticfiles_tests.apps.test',
@@ -314,7 +324,7 @@ class TestCollectionFilesOverride(CollectionTestCase):
         # prepare duplicate of file2.txt from no_label app
         # this file will have modification time older than no_label/static/file2.txt
         # anyway it should be taken to STATIC_ROOT because 'test' app is before
-        # 'no_label' app in INSTALLED_APPS
+        # 'no_label' app in installed apps
         self.testfile_path = os.path.join(TEST_ROOT, 'apps', 'test', 'static', 'file2.txt')
         with open(self.testfile_path, 'w+') as f:
             f.write('duplicate of file2.txt')
@@ -340,7 +350,7 @@ class TestCollectionFilesOverride(CollectionTestCase):
         self.assertFileContains('file2.txt', 'duplicate of file2.txt')
 
         # and now change modification time of no_label/static/file2.txt
-        # test app is first in INSTALLED_APPS so file2.txt should remain unmodified
+        # test app is first in installed apps so file2.txt should remain unmodified
         mtime = os.path.getmtime(self.testfile_path)
         atime = os.path.getatime(self.testfile_path)
         os.utime(self.orig_path, (mtime + 1, atime + 1))
diff --git a/tests/swappable_models/tests.py b/tests/swappable_models/tests.py
index fec9db5af8..de2105d2ec 100644
--- a/tests/swappable_models/tests.py
+++ b/tests/swappable_models/tests.py
@@ -4,10 +4,8 @@ from django.utils.six import StringIO
 
 from django.contrib.auth.models import Permission
 from django.contrib.contenttypes.models import ContentType
-from django.core.apps import app_cache
 from django.core import management
-from django.test import TestCase
-from django.test.utils import override_settings
+from django.test import TestCase, override_settings
 
 from swappable_models.models import Article
 
@@ -20,16 +18,6 @@ class SwappableModelTests(TestCase):
         'django.contrib.contenttypes',
     ]
 
-    def setUp(self):
-        # This test modifies the installed apps, so we need to make sure
-        # we're not dealing with a cached app list.
-        app_cache._get_models_cache.clear()
-
-    def tearDown(self):
-        # By fiddling with swappable models, we alter the installed models
-        # cache, so flush it to make sure there are no side effects.
-        app_cache._get_models_cache.clear()
-
     @override_settings(TEST_ARTICLE_MODEL='swappable_models.AlternateArticle')
     def test_generated_data(self):
         "Permissions and content types are not created for a swapped model"
diff --git a/tests/syndication_tests/__init__.py b/tests/syndication_tests/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/tests/syndication/feeds.py b/tests/syndication_tests/feeds.py
similarity index 100%
rename from tests/syndication/feeds.py
rename to tests/syndication_tests/feeds.py
diff --git a/tests/syndication/fixtures/feeddata.json b/tests/syndication_tests/fixtures/feeddata.json
similarity index 78%
rename from tests/syndication/fixtures/feeddata.json
rename to tests/syndication_tests/fixtures/feeddata.json
index 52e5028fcd..b273e21cae 100644
--- a/tests/syndication/fixtures/feeddata.json
+++ b/tests/syndication_tests/fixtures/feeddata.json
@@ -1,6 +1,6 @@
 [
   {
-    "model": "syndication.entry",
+    "model": "syndication_tests.entry",
     "pk": 1,
     "fields": {
       "title": "My first entry",
@@ -9,7 +9,7 @@
     }
   },
   {
-    "model": "syndication.entry",
+    "model": "syndication_tests.entry",
     "pk": 2,
     "fields": {
       "title": "My second entry",
@@ -18,7 +18,7 @@
     }
   },
   {
-    "model": "syndication.entry",
+    "model": "syndication_tests.entry",
     "pk": 3,
     "fields": {
       "title": "My third entry",
@@ -27,7 +27,7 @@
     }
   },
   {
-    "model": "syndication.entry",
+    "model": "syndication_tests.entry",
     "pk": 4,
     "fields": {
       "title": "A & B < C > D",
@@ -36,7 +36,7 @@
     }
   },
   {
-    "model": "syndication.entry",
+    "model": "syndication_tests.entry",
     "pk": 5,
     "fields": {
       "title": "My last entry",
@@ -45,7 +45,7 @@
     }
   },
   {
-    "model": "syndication.article",
+    "model": "syndication_tests.article",
     "pk": 1,
     "fields": {
       "title": "My first article",
diff --git a/tests/syndication/models.py b/tests/syndication_tests/models.py
similarity index 100%
rename from tests/syndication/models.py
rename to tests/syndication_tests/models.py
diff --git a/tests/syndication/templates/syndication/description.html b/tests/syndication_tests/templates/syndication/description.html
similarity index 100%
rename from tests/syndication/templates/syndication/description.html
rename to tests/syndication_tests/templates/syndication/description.html
diff --git a/tests/syndication/templates/syndication/description_context.html b/tests/syndication_tests/templates/syndication/description_context.html
similarity index 100%
rename from tests/syndication/templates/syndication/description_context.html
rename to tests/syndication_tests/templates/syndication/description_context.html
diff --git a/tests/syndication/templates/syndication/title.html b/tests/syndication_tests/templates/syndication/title.html
similarity index 100%
rename from tests/syndication/templates/syndication/title.html
rename to tests/syndication_tests/templates/syndication/title.html
diff --git a/tests/syndication/templates/syndication/title_context.html b/tests/syndication_tests/templates/syndication/title_context.html
similarity index 100%
rename from tests/syndication/templates/syndication/title_context.html
rename to tests/syndication_tests/templates/syndication/title_context.html
diff --git a/tests/syndication/tests.py b/tests/syndication_tests/tests.py
similarity index 99%
rename from tests/syndication/tests.py
rename to tests/syndication_tests/tests.py
index a3b75369be..b5d1ec4bfc 100644
--- a/tests/syndication/tests.py
+++ b/tests/syndication_tests/tests.py
@@ -54,7 +54,7 @@ class SyndicationFeedTest(FeedTestCase):
     """
     Tests for the high-level syndication feed framework.
     """
-    urls = 'syndication.urls'
+    urls = 'syndication_tests.urls'
 
     def test_rss2_feed(self):
         """
diff --git a/tests/syndication/urls.py b/tests/syndication_tests/urls.py
similarity index 100%
rename from tests/syndication/urls.py
rename to tests/syndication_tests/urls.py
diff --git a/tests/tablespaces/tests.py b/tests/tablespaces/tests.py
index 4a62ad5a45..8c69e70a19 100644
--- a/tests/tablespaces/tests.py
+++ b/tests/tablespaces/tests.py
@@ -1,7 +1,7 @@
 from __future__ import unicode_literals
 
+from django.apps import apps
 from django.conf import settings
-from django.core.apps import app_cache
 from django.db import connection
 from django.core.management.color import no_style
 from django.test import TestCase, skipIfDBFeature, skipUnlessDBFeature
@@ -26,7 +26,7 @@ class TablespacesTests(TestCase):
     def setUp(self):
         # The unmanaged models need to be removed after the test in order to
         # prevent bad interactions with the flush operation in other tests.
-        self._old_models = app_cache.app_configs['tablespaces'].models.copy()
+        self._old_models = apps.app_configs['tablespaces'].models.copy()
 
         for model in Article, Authors, Reviewers, Scientist:
             model._meta.managed = True
@@ -35,8 +35,9 @@ class TablespacesTests(TestCase):
         for model in Article, Authors, Reviewers, Scientist:
             model._meta.managed = False
 
-        app_cache.app_configs['tablespaces'].models = self._old_models
-        app_cache._get_models_cache = {}
+        apps.app_configs['tablespaces'].models = self._old_models
+        apps.all_models['tablespaces'] = self._old_models
+        apps.clear_cache()
 
     def assertNumContains(self, haystack, needle, count):
         real_count = haystack.count(needle)
diff --git a/tests/template_tests/test_loaders.py b/tests/template_tests/test_loaders.py
index 6e74477e83..42330b8782 100644
--- a/tests/template_tests/test_loaders.py
+++ b/tests/template_tests/test_loaders.py
@@ -23,8 +23,7 @@ except ImportError:
 from django.template import TemplateDoesNotExist, Context
 from django.template.loaders.eggs import Loader as EggLoader
 from django.template import loader
-from django.test import TestCase
-from django.test.utils import override_settings
+from django.test import TestCase, override_settings
 from django.utils import six
 from django.utils._os import upath
 from django.utils.six import StringIO
@@ -49,7 +48,6 @@ def create_egg(name, resources):
 
 
 @unittest.skipUnless(pkg_resources, 'setuptools is not installed')
-@override_settings(INSTALLED_APPS=[])
 class EggLoaderTest(TestCase):
     def setUp(self):
         # Defined here b/c at module scope we may not have pkg_resources
@@ -98,9 +96,8 @@ class EggLoaderTest(TestCase):
         self.assertEqual(contents, "y")
         self.assertEqual(template_name, "egg:egg_1:templates/y.html")
 
-    @override_settings(INSTALLED_APPS=[])
     def test_not_installed(self):
-        "Loading an existent template from an egg not included in INSTALLED_APPS should fail"
+        "Loading an existent template from an egg not included in any app should fail"
         egg_loader = EggLoader()
         self.assertRaises(TemplateDoesNotExist, egg_loader.load_template_source, "y.html")
 
diff --git a/tests/template_tests/test_nodelist.py b/tests/template_tests/test_nodelist.py
index 12abd20331..1c48d3f7ce 100644
--- a/tests/template_tests/test_nodelist.py
+++ b/tests/template_tests/test_nodelist.py
@@ -2,7 +2,7 @@ from unittest import TestCase
 
 from django.template import VariableNode, Context
 from django.template.loader import get_template_from_string
-from django.test.utils import override_settings
+from django.test import override_settings
 
 
 class NodelistTest(TestCase):
diff --git a/tests/template_tests/test_parser.py b/tests/template_tests/test_parser.py
index 275d7ea4be..017e78a863 100644
--- a/tests/template_tests/test_parser.py
+++ b/tests/template_tests/test_parser.py
@@ -7,7 +7,7 @@ from unittest import TestCase
 
 from django.template import (TokenParser, FilterExpression, Parser, Variable,
     Template, TemplateSyntaxError, Library)
-from django.test.utils import override_settings
+from django.test import override_settings
 from django.utils import six
 
 
diff --git a/tests/template_tests/test_response.py b/tests/template_tests/test_response.py
index f5f6158b2f..17d8f11ba5 100644
--- a/tests/template_tests/test_response.py
+++ b/tests/template_tests/test_response.py
@@ -10,7 +10,7 @@ from django.conf import settings
 from django.template import Template, Context
 from django.template.response import (TemplateResponse, SimpleTemplateResponse,
                                       ContentNotRenderedError)
-from django.test.utils import override_settings
+from django.test import override_settings
 from django.utils._os import upath
 
 
diff --git a/tests/template_tests/tests.py b/tests/template_tests/tests.py
index 651d46d4f1..0afb3a8729 100644
--- a/tests/template_tests/tests.py
+++ b/tests/template_tests/tests.py
@@ -1873,24 +1873,26 @@ class TemplateTagLoading(TestCase):
             self.assertTrue('ImportError' in e.args[0])
             self.assertTrue('Xtemplate' in e.args[0])
 
-    @override_settings(INSTALLED_APPS=('tagsegg',))
     def test_load_error_egg(self):
         ttext = "{% load broken_egg %}"
         egg_name = '%s/tagsegg.egg' % self.egg_dir
         sys.path.append(egg_name)
-        self.assertRaises(template.TemplateSyntaxError, template.Template, ttext)
+        with self.assertRaises(template.TemplateSyntaxError):
+            with self.settings(INSTALLED_APPS=['tagsegg']):
+                template.Template(ttext)
         try:
-            template.Template(ttext)
+            with self.settings(INSTALLED_APPS=['tagsegg']):
+                template.Template(ttext)
         except template.TemplateSyntaxError as e:
             self.assertTrue('ImportError' in e.args[0])
             self.assertTrue('Xtemplate' in e.args[0])
 
-    @override_settings(INSTALLED_APPS=('tagsegg',))
     def test_load_working_egg(self):
         ttext = "{% load working_egg %}"
         egg_name = '%s/tagsegg.egg' % self.egg_dir
         sys.path.append(egg_name)
-        template.Template(ttext)
+        with self.settings(INSTALLED_APPS=['tagsegg']):
+            template.Template(ttext)
 
 
 class RequestContextTests(unittest.TestCase):
diff --git a/tests/test_client/tests.py b/tests/test_client/tests.py
index d914a89043..5fa6360eda 100644
--- a/tests/test_client/tests.py
+++ b/tests/test_client/tests.py
@@ -24,7 +24,7 @@ from __future__ import unicode_literals
 
 from django.core import mail
 from django.test import Client, TestCase, RequestFactory
-from django.test.utils import override_settings
+from django.test import override_settings
 
 from .views import get_view
 
@@ -84,6 +84,20 @@ class ClientTest(TestCase):
 
         self.assertEqual(response['X-DJANGO-TEST'], 'Slartibartfast')
 
+    def test_response_attached_request(self):
+        """
+        Check that the returned response has a ``request`` attribute with the
+        originating environ dict and a ``wsgi_request`` with the originating
+        ``WSGIRequest`` instance.
+        """
+        response = self.client.get("/test_client/header_view/")
+
+        self.assertTrue(hasattr(response, 'request'))
+        self.assertTrue(hasattr(response, 'wsgi_request'))
+        for key, value in response.request.items():
+            self.assertIn(key, response.wsgi_request.environ)
+            self.assertEqual(response.wsgi_request.environ[key], value)
+
     def test_raw_post(self):
         "POST raw data (with a content type) to a view"
         test_doc = """<?xml version="1.0" encoding="utf-8"?><library><book><title>Blink</title><author>Malcolm Gladwell</author></book></library>"""
diff --git a/tests/test_client_regress/tests.py b/tests/test_client_regress/tests.py
index 1bee0b95e7..afb3993cd1 100644
--- a/tests/test_client_regress/tests.py
+++ b/tests/test_client_regress/tests.py
@@ -12,9 +12,9 @@ from django.core.urlresolvers import reverse
 from django.template import (TemplateSyntaxError,
     Context, Template, loader)
 import django.template.context
-from django.test import Client, TestCase
+from django.test import Client, TestCase, override_settings
 from django.test.client import encode_file, RequestFactory
-from django.test.utils import ContextList, override_settings, str_prefix
+from django.test.utils import ContextList, str_prefix
 from django.template.response import SimpleTemplateResponse
 from django.utils._os import upath
 from django.utils.translation import ugettext_lazy
diff --git a/tests/test_discovery_sample/empty.py b/tests/test_discovery_sample/empty.py
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/tests/test_discovery_sample/tests_sample.py b/tests/test_discovery_sample/tests_sample.py
index fb1e14c715..d538771b0f 100644
--- a/tests/test_discovery_sample/tests_sample.py
+++ b/tests/test_discovery_sample/tests_sample.py
@@ -13,3 +13,7 @@ class TestDjangoTestCase(DjangoTestCase):
 
     def test_sample(self):
         self.assertEqual(1, 1)
+
+
+class EmptyTestCase(TestCase):
+    pass
diff --git a/tests/test_runner/test_discover_runner.py b/tests/test_runner/test_discover_runner.py
index d577f26826..c0448bd43a 100644
--- a/tests/test_runner/test_discover_runner.py
+++ b/tests/test_runner/test_discover_runner.py
@@ -1,16 +1,21 @@
 from contextlib import contextmanager
 import os
-from unittest import expectedFailure, TestSuite, TextTestRunner, defaultTestLoader
+from unittest import TestSuite, TextTestRunner, defaultTestLoader
 
 from django.test import TestCase
 from django.test.runner import DiscoverRunner
 
 
-def expectedFailureIf(condition):
-    """Marks a test as an expected failure if ``condition`` is met."""
-    if condition:
-        return expectedFailure
-    return lambda func: func
+@contextmanager
+def change_cwd(directory):
+    current_dir = os.path.abspath(os.path.dirname(__file__))
+    new_dir = os.path.join(current_dir, directory)
+    old_cwd = os.getcwd()
+    os.chdir(new_dir)
+    try:
+        yield
+    finally:
+        os.chdir(old_cwd)
 
 
 class DiscoverRunnerTest(TestCase):
@@ -51,23 +56,53 @@ class DiscoverRunnerTest(TestCase):
         self.assertEqual(count, 1)
 
     def test_file_path(self):
-        @contextmanager
-        def change_cwd_to_tests():
-            """Change CWD to tests directory (one level up from this file)"""
-            current_dir = os.path.abspath(os.path.dirname(__file__))
-            tests_dir = os.path.join(current_dir, '..')
-            old_cwd = os.getcwd()
-            os.chdir(tests_dir)
-            yield
-            os.chdir(old_cwd)
-
-        with change_cwd_to_tests():
+        with change_cwd(".."):
             count = DiscoverRunner().build_suite(
                 ["test_discovery_sample/"],
             ).countTestCases()
 
         self.assertEqual(count, 3)
 
+    def test_empty_label(self):
+        """
+        If the test label is empty, discovery should happen on the current
+        working directory.
+        """
+        with change_cwd("."):
+            suite = DiscoverRunner().build_suite([])
+            self.assertEqual(
+                suite._tests[0].id().split(".")[0],
+                os.path.basename(os.getcwd()),
+            )
+
+    def test_empty_test_case(self):
+        count = DiscoverRunner().build_suite(
+            ["test_discovery_sample.tests_sample.EmptyTestCase"],
+        ).countTestCases()
+
+        self.assertEqual(count, 0)
+
+    def test_discovery_on_package(self):
+        count = DiscoverRunner().build_suite(
+            ["test_discovery_sample.tests"],
+        ).countTestCases()
+
+        self.assertEqual(count, 1)
+
+    def test_ignore_adjacent(self):
+        """
+        When given a dotted path to a module, unittest discovery searches
+        not just the module, but also the directory containing the module.
+
+        This results in tests from adjacent modules being run when they
+        should not. The discover runner avoids this behavior.
+        """
+        count = DiscoverRunner().build_suite(
+            ["test_discovery_sample.empty"],
+        ).countTestCases()
+
+        self.assertEqual(count, 0)
+
     def test_overrideable_test_suite(self):
         self.assertEqual(DiscoverRunner().test_suite, TestSuite)
 
diff --git a/tests/test_runner/tests.py b/tests/test_runner/tests.py
index 04fa3b8784..2066181c67 100644
--- a/tests/test_runner/tests.py
+++ b/tests/test_runner/tests.py
@@ -3,7 +3,6 @@ Tests for django test runner
 """
 from __future__ import unicode_literals
 
-from importlib import import_module
 from optparse import make_option
 import types
 import unittest
@@ -225,24 +224,21 @@ class ModulesTestsPackages(IgnoreAllDeprecationWarningsMixin, unittest.TestCase)
 
     def test_get_tests(self):
         "Check that the get_tests helper function can find tests in a directory"
-        from django.core.apps.base import AppConfig
+        from django.apps import AppConfig
         from django.test.simple import get_tests
-        app_config = AppConfig(
-            'test_runner.valid_app',
-            import_module('test_runner.valid_app'),
-            import_module('test_runner.valid_app.models'))
+        app_config = AppConfig.create('test_runner.valid_app')
+        app_config.import_models({})
         tests = get_tests(app_config)
         self.assertIsInstance(tests, types.ModuleType)
 
     def test_import_error(self):
         "Test for #12658 - Tests with ImportError's shouldn't fail silently"
-        from django.core.apps.base import AppConfig
+        from django.apps import AppConfig
         from django.test.simple import get_tests
-        app_config = AppConfig(
-            'test_runner_invalid_app',
-            import_module('test_runner_invalid_app'),
-            import_module('test_runner_invalid_app.models'))
-        self.assertRaises(ImportError, get_tests, app_config)
+        app_config = AppConfig.create('test_runner_invalid_app')
+        app_config.import_models({})
+        with self.assertRaises(ImportError):
+            get_tests(app_config)
 
 
 class Sqlite3InMemoryTestDbs(TestCase):
@@ -368,12 +364,14 @@ class DeprecationDisplayTest(AdminScriptTestCase):
     def test_runner_deprecation_verbosity_default(self):
         args = ['test', '--settings=test_project.settings', 'test_runner_deprecation_app']
         out, err = self.run_django_admin(args)
+        self.assertIn("Ran 1 test", err)
         self.assertIn("DeprecationWarning: warning from test", err)
         self.assertIn("DeprecationWarning: module-level warning from deprecation_app", err)
 
     def test_runner_deprecation_verbosity_zero(self):
-        args = ['test', '--settings=settings', '--verbosity=0']
+        args = ['test', '--settings=test_project.settings', '--verbosity=0', 'test_runner_deprecation_app']
         out, err = self.run_django_admin(args)
+        self.assertIn("Ran 1 test", err)
         self.assertFalse("DeprecationWarning: warning from test" in err)
 
 
diff --git a/tests/test_suite_override/tests.py b/tests/test_suite_override/tests.py
index b464659275..c485b801bc 100644
--- a/tests/test_suite_override/tests.py
+++ b/tests/test_suite_override/tests.py
@@ -1,6 +1,6 @@
 import unittest
 
-from django.core.apps import app_cache
+from django.apps import apps
 from django.test.utils import IgnoreAllDeprecationWarningsMixin
 
 
@@ -20,7 +20,7 @@ class SuiteOverrideTest(IgnoreAllDeprecationWarningsMixin, unittest.TestCase):
         """
 
         from django.test.simple import build_suite
-        app_config = app_cache.get_app_config("test_suite_override")
+        app_config = apps.get_app_config("test_suite_override")
         suite = build_suite(app_config)
         self.assertEqual(suite.countTestCases(), 1)
 
diff --git a/tests/timezones/tests.py b/tests/timezones/tests.py
index 5eb98fcf00..4b45ddbb7b 100644
--- a/tests/timezones/tests.py
+++ b/tests/timezones/tests.py
@@ -17,8 +17,8 @@ from django.core.urlresolvers import reverse
 from django.db.models import Min, Max
 from django.http import HttpRequest
 from django.template import Context, RequestContext, Template, TemplateSyntaxError
-from django.test import TestCase, skipIfDBFeature, skipUnlessDBFeature
-from django.test.utils import override_settings, requires_tz_support
+from django.test import TestCase, override_settings, skipIfDBFeature, skipUnlessDBFeature
+from django.test.utils import requires_tz_support
 from django.utils import six
 from django.utils import timezone
 
diff --git a/tests/transactions_regress/tests.py b/tests/transactions_regress/tests.py
index 24bd860731..cada46edb2 100644
--- a/tests/transactions_regress/tests.py
+++ b/tests/transactions_regress/tests.py
@@ -5,8 +5,8 @@ from unittest import skipIf, skipUnless, SkipTest
 from django.db import (connection, connections, transaction, DEFAULT_DB_ALIAS, DatabaseError,
                        IntegrityError)
 from django.db.transaction import commit_on_success, commit_manually, TransactionManagementError
-from django.test import TransactionTestCase, skipUnlessDBFeature
-from django.test.utils import override_settings, IgnoreDeprecationWarningsMixin
+from django.test import TransactionTestCase, override_settings, skipUnlessDBFeature
+from django.test.utils import IgnoreDeprecationWarningsMixin
 
 from .models import Mod, M2mA, M2mB, SubMod
 
diff --git a/tests/urlpatterns_reverse/tests.py b/tests/urlpatterns_reverse/tests.py
index da0c5bee1a..a7fb342da7 100644
--- a/tests/urlpatterns_reverse/tests.py
+++ b/tests/urlpatterns_reverse/tests.py
@@ -12,8 +12,7 @@ from django.core.urlresolvers import (reverse, reverse_lazy, resolve, get_callab
     RegexURLPattern)
 from django.http import HttpRequest, HttpResponseRedirect, HttpResponsePermanentRedirect
 from django.shortcuts import redirect
-from django.test import TestCase
-from django.test.utils import override_settings
+from django.test import TestCase, override_settings
 from django.utils import six
 
 from . import urlconf_outer, middleware, views
diff --git a/tests/utils_tests/test_autoreload.py b/tests/utils_tests/test_autoreload.py
index d6e22ad8ee..1024b02efe 100644
--- a/tests/utils_tests/test_autoreload.py
+++ b/tests/utils_tests/test_autoreload.py
@@ -27,7 +27,7 @@ class TestFilenameGenerator(TestCase):
         self.assertIn(os.path.join(LOCALE_PATH, 'nl', 'LC_MESSAGES', 'django.mo'),
                       filenames)
 
-    @override_settings(INSTALLED_APPS=())
+    @override_settings(INSTALLED_APPS=[])
     def test_project_root_locale(self):
         """
         Test that gen_filenames also yields from the current directory (project
@@ -43,10 +43,10 @@ class TestFilenameGenerator(TestCase):
         finally:
             os.chdir(old_cwd)
 
-    @override_settings(INSTALLED_APPS=('django.contrib.admin',))
+    @override_settings(INSTALLED_APPS=['django.contrib.admin'])
     def test_app_locales(self):
         """
-        Test that gen_filenames also yields from INSTALLED_APPS locales.
+        Test that gen_filenames also yields from locale dirs in installed apps.
         """
         filenames = list(gen_filenames())
         self.assertIn(os.path.join(os.path.dirname(admin.__file__), 'locale',
diff --git a/tests/utils_tests/test_dateformat.py b/tests/utils_tests/test_dateformat.py
index ebf46f3ee7..c0b42db3dc 100644
--- a/tests/utils_tests/test_dateformat.py
+++ b/tests/utils_tests/test_dateformat.py
@@ -3,8 +3,7 @@ from __future__ import unicode_literals
 from datetime import datetime, date
 import time
 
-from django.test import TestCase
-from django.test.utils import override_settings
+from django.test import TestCase, override_settings
 from django.utils.dateformat import format
 from django.utils import dateformat
 from django.utils.timezone import utc, get_fixed_timezone, get_default_timezone, make_aware
diff --git a/tests/utils_tests/test_module_loading.py b/tests/utils_tests/test_module_loading.py
index 5a7eadcedf..0bba98e8c2 100644
--- a/tests/utils_tests/test_module_loading.py
+++ b/tests/utils_tests/test_module_loading.py
@@ -6,8 +6,7 @@ import unittest
 from zipimport import zipimporter
 
 from django.core.exceptions import ImproperlyConfigured
-from django.test import SimpleTestCase
-from django.test.utils import override_settings
+from django.test import SimpleTestCase, modify_settings
 from django.utils import six
 from django.utils.module_loading import autodiscover_modules, import_by_path, module_has_submodule
 from django.utils._os import upath
@@ -135,7 +134,7 @@ class ModuleImportTestCase(unittest.TestCase):
             'Should have more than the calling frame in the traceback.')
 
 
-@override_settings(INSTALLED_APPS=('utils_tests.test_module',))
+@modify_settings(INSTALLED_APPS={'append': 'utils_tests.test_module'})
 class AutodiscoverModulesTestCase(SimpleTestCase):
 
     def test_autodiscover_modules_found(self):
diff --git a/tests/utils_tests/test_timezone.py b/tests/utils_tests/test_timezone.py
index fe67d105c3..1d608d0951 100644
--- a/tests/utils_tests/test_timezone.py
+++ b/tests/utils_tests/test_timezone.py
@@ -3,7 +3,7 @@ import datetime
 import pickle
 import unittest
 
-from django.test.utils import override_settings
+from django.test import override_settings
 from django.utils import timezone
 
 
diff --git a/tests/validation/test_unique.py b/tests/validation/test_unique.py
index f05256a6f1..76c7ec174f 100644
--- a/tests/validation/test_unique.py
+++ b/tests/validation/test_unique.py
@@ -3,7 +3,7 @@ from __future__ import unicode_literals
 import datetime
 import unittest
 
-from django.core.apps.cache import AppCache
+from django.apps.registry import Apps
 from django.core.exceptions import ValidationError
 from django.db import models
 from django.test import TestCase
@@ -58,7 +58,7 @@ class GetUniqueCheckTests(unittest.TestCase):
 
                 Meta = type(str('Meta'), (), {
                     'unique_together': unique_together,
-                    'app_cache': AppCache()
+                    'apps': Apps()
                 })
 
             checks, _ = M()._get_unique_checks()
diff --git a/tests/validators/tests.py b/tests/validators/tests.py
index b0d1376aee..23fa1e3830 100644
--- a/tests/validators/tests.py
+++ b/tests/validators/tests.py
@@ -18,6 +18,7 @@ from django.test.utils import str_prefix
 
 
 NOW = datetime.now()
+EXTENDED_SCHEMES = ['http', 'https', 'ftp', 'ftps', 'git', 'file']
 
 TEST_DATA = (
     # (validator, value, expected),
@@ -141,6 +142,7 @@ TEST_DATA = (
     (MinLengthValidator(10), '', ValidationError),
 
     (URLValidator(), 'http://www.djangoproject.com/', None),
+    (URLValidator(), 'HTTP://WWW.DJANGOPROJECT.COM/', None),
     (URLValidator(), 'http://localhost/', None),
     (URLValidator(), 'http://example.com/', None),
     (URLValidator(), 'http://www.example.com/', None),
@@ -155,6 +157,8 @@ TEST_DATA = (
     (URLValidator(), 'https://example.com/', None),
     (URLValidator(), 'ftp://example.com/', None),
     (URLValidator(), 'ftps://example.com/', None),
+    (URLValidator(EXTENDED_SCHEMES), 'file://localhost/path', None),
+    (URLValidator(EXTENDED_SCHEMES), 'git://example.com/', None),
 
     (URLValidator(), 'foo', ValidationError),
     (URLValidator(), 'http://', ValidationError),
@@ -165,6 +169,9 @@ TEST_DATA = (
     (URLValidator(), 'http://-invalid.com', ValidationError),
     (URLValidator(), 'http://inv-.alid-.com', ValidationError),
     (URLValidator(), 'http://inv-.-alid.com', ValidationError),
+    (URLValidator(), 'file://localhost/path', ValidationError),
+    (URLValidator(), 'git://example.com/', ValidationError),
+    (URLValidator(EXTENDED_SCHEMES), 'git://-invalid.com', ValidationError),
 
     (BaseValidator(True), True, None),
     (BaseValidator(True), False, ValidationError),
diff --git a/tests/view_tests/tests/test_debug.py b/tests/view_tests/tests/test_debug.py
index 261c534b2b..ca08f3cce9 100644
--- a/tests/view_tests/tests/test_debug.py
+++ b/tests/view_tests/tests/test_debug.py
@@ -16,9 +16,9 @@ from django.core import mail
 from django.core.files.uploadedfile import SimpleUploadedFile
 from django.core.urlresolvers import reverse
 from django.template.base import TemplateDoesNotExist
-from django.test import TestCase, RequestFactory
-from django.test.utils import (override_settings, setup_test_template_loader,
-    restore_template_loaders)
+from django.test import TestCase, RequestFactory, override_settings
+from django.test.utils import (
+    setup_test_template_loader, restore_template_loaders)
 from django.utils.encoding import force_text, force_bytes
 from django.utils import six
 from django.views.debug import ExceptionReporter
diff --git a/tests/view_tests/tests/test_i18n.py b/tests/view_tests/tests/test_i18n.py
index 42f82251f5..a939fd6fc1 100644
--- a/tests/view_tests/tests/test_i18n.py
+++ b/tests/view_tests/tests/test_i18n.py
@@ -6,8 +6,8 @@ import unittest
 
 from django.conf import settings
 from django.core.urlresolvers import reverse
-from django.test import LiveServerTestCase, TestCase
-from django.test.utils import override_settings
+from django.test import (
+    LiveServerTestCase, TestCase, modify_settings, override_settings)
 from django.utils import six
 from django.utils._os import upath
 from django.utils.translation import override
@@ -109,17 +109,16 @@ class JsI18NTests(TestCase):
             response = self.client.get('/views/jsi18n/')
             self.assertNotContains(response, 'Choisir une heure')
 
+    @modify_settings(INSTALLED_APPS={'append': 'view_tests.app0'})
     def test_nonenglish_default_english_userpref(self):
         """
         Same as above with the difference that there IS an 'en' translation
         available. The Javascript i18n view must return a NON empty language catalog
         with the proper English translations. See #13726 for more details.
         """
-        extended_apps = list(settings.INSTALLED_APPS) + ['view_tests.app0']
-        with self.settings(LANGUAGE_CODE='fr', INSTALLED_APPS=extended_apps):
-            with override('en-us'):
-                response = self.client.get('/views/jsi18n_english_translation/')
-                self.assertContains(response, javascript_quote('this app0 string is to be translated'))
+        with self.settings(LANGUAGE_CODE='fr'), override('en-us'):
+            response = self.client.get('/views/jsi18n_english_translation/')
+            self.assertContains(response, javascript_quote('this app0 string is to be translated'))
 
     def testI18NLanguageNonEnglishFallback(self):
         """
@@ -130,12 +129,18 @@ class JsI18NTests(TestCase):
             response = self.client.get('/views/jsi18n/')
             self.assertContains(response, 'Choisir une heure')
 
+    def test_escaping(self):
+        # Force a language via GET otherwise the gettext functions are a noop!
+        response = self.client.get('/views/jsi18n_admin/?language=de')
+        self.assertContains(response, '\\x04')
+
 
 class JsI18NTestsMultiPackage(TestCase):
     """
     Tests for django views in django/views/i18n.py that need to change
     settings.LANGUAGE_CODE and merge JS translation from several packages.
     """
+    @modify_settings(INSTALLED_APPS={'append': ['view_tests.app1', 'view_tests.app2']})
     def testI18NLanguageEnglishDefault(self):
         """
         Check if the JavaScript i18n view returns a complete language catalog
@@ -144,22 +149,19 @@ class JsI18NTestsMultiPackage(TestCase):
         translations of multiple Python packages is requested. See #13388,
         #3594 and #13514 for more details.
         """
-        extended_apps = list(settings.INSTALLED_APPS) + ['view_tests.app1', 'view_tests.app2']
-        with self.settings(LANGUAGE_CODE='en-us', INSTALLED_APPS=extended_apps):
-            with override('fr'):
-                response = self.client.get('/views/jsi18n_multi_packages1/')
-                self.assertContains(response, javascript_quote('il faut traduire cette chaîne de caractères de app1'))
+        with self.settings(LANGUAGE_CODE='en-us'), override('fr'):
+            response = self.client.get('/views/jsi18n_multi_packages1/')
+            self.assertContains(response, javascript_quote('il faut traduire cette chaîne de caractères de app1'))
 
+    @modify_settings(INSTALLED_APPS={'append': ['view_tests.app3', 'view_tests.app4']})
     def testI18NDifferentNonEnLangs(self):
         """
         Similar to above but with neither default or requested language being
         English.
         """
-        extended_apps = list(settings.INSTALLED_APPS) + ['view_tests.app3', 'view_tests.app4']
-        with self.settings(LANGUAGE_CODE='fr', INSTALLED_APPS=extended_apps):
-            with override('es-ar'):
-                response = self.client.get('/views/jsi18n_multi_packages2/')
-                self.assertContains(response, javascript_quote('este texto de app3 debe ser traducido'))
+        with self.settings(LANGUAGE_CODE='fr'), override('es-ar'):
+            response = self.client.get('/views/jsi18n_multi_packages2/')
+            self.assertContains(response, javascript_quote('este texto de app3 debe ser traducido'))
 
     def testI18NWithLocalePaths(self):
         extended_locale_paths = settings.LOCALE_PATHS + (
@@ -179,7 +181,8 @@ skip_selenium = not os.environ.get('DJANGO_SELENIUM_TESTS', False)
 @unittest.skipUnless(firefox, 'Selenium not installed')
 class JavascriptI18nTests(LiveServerTestCase):
 
-    available_apps = []
+    # The test cases use translations from these apps.
+    available_apps = ['django.contrib.admin', 'view_tests']
     urls = 'view_tests.urls'
 
     @classmethod
@@ -189,7 +192,6 @@ class JavascriptI18nTests(LiveServerTestCase):
 
     @classmethod
     def tearDownClass(cls):
-        cls.selenium.refresh()  # see ticket #21227
         cls.selenium.quit()
         super(JavascriptI18nTests, cls).tearDownClass()
 
@@ -209,8 +211,3 @@ class JavascriptI18nTests(LiveServerTestCase):
         self.assertEqual(elem.text, "1 Resultat")
         elem = self.selenium.find_element_by_id("npgettext_plur")
         self.assertEqual(elem.text, "455 Resultate")
-
-    def test_escaping(self):
-        # Force a language via GET otherwise the gettext functions are a noop!
-        response = self.client.get('/jsi18n_admin/?language=de')
-        self.assertContains(response, '\\x04')
diff --git a/tests/view_tests/tests/test_shortcuts.py b/tests/view_tests/tests/test_shortcuts.py
index eb08433a44..7b14637143 100644
--- a/tests/view_tests/tests/test_shortcuts.py
+++ b/tests/view_tests/tests/test_shortcuts.py
@@ -1,5 +1,4 @@
-from django.test import TestCase
-from django.test.utils import override_settings
+from django.test import TestCase, override_settings
 
 
 @override_settings(
diff --git a/tests/view_tests/tests/test_static.py b/tests/view_tests/tests/test_static.py
index 34e4021080..8b051c5e62 100644
--- a/tests/view_tests/tests/test_static.py
+++ b/tests/view_tests/tests/test_static.py
@@ -6,8 +6,7 @@ import unittest
 
 from django.conf.urls.static import static
 from django.http import HttpResponseNotModified
-from django.test import SimpleTestCase
-from django.test.utils import override_settings
+from django.test import SimpleTestCase, override_settings
 from django.utils.http import http_date
 from django.views.static import was_modified_since
 
diff --git a/tests/wsgi/tests.py b/tests/wsgi/tests.py
index 90397bb742..567ca94f98 100644
--- a/tests/wsgi/tests.py
+++ b/tests/wsgi/tests.py
@@ -7,9 +7,8 @@ from django.core.servers.basehttp import get_internal_wsgi_application
 from django.core.signals import request_started
 from django.core.wsgi import get_wsgi_application
 from django.db import close_old_connections
-from django.test import TestCase
+from django.test import TestCase, override_settings
 from django.test.client import RequestFactory
-from django.test.utils import override_settings
 from django.utils import six