diff --git a/.circleci/config.yml b/.circleci/config.yml
index 9855ef7..8416914 100644
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -25,14 +25,23 @@
 common: &common
   jobs:
     - python/pip-run-tests:
+        name: python27
+        image: circleci/python:2.7
+    - python/pip-run-tests:
+        name: python34
+        image: circleci/python:3.4
+    - python/pip-run-tests:
+        name: python35
+        image: circleci/python:3.5
+    - python/pip-run-tests:
         name: python36
         image: circleci/python:3.6
     - python/pip-run-tests:
         name: python37
         image: circleci/python:3.7
     - python/pip-run-tests:
-        name: python38
-        image: circleci/python:3.8
+        name: pypy27
+        image: pypy:2.7
     - python/pip-run-tests:
         name: pypy36
         image: pypy:3.6
@@ -40,9 +49,12 @@
     - python/coverage:
         name: coverage
         requires:
+          - python27
+          - python34
+          - python35
           - python36
           - python37
-          - python38
+          - pypy27
           - pypy36
 
     - python/pip-docs:
@@ -59,8 +71,8 @@
             only: master
 
     - check-package:
-        name: check-package-python36
-        image: circleci/python:3.6
+        name: check-package-python27
+        image: circleci/python:2.7
         requires:
           - package
 
@@ -71,8 +83,9 @@
           - package
 
     - check-package:
-        name: check-package-python38
-        image: circleci/python:3.8
+        name: check-package-pypy27
+        image: pypy:2.7
+        python: pypy
         requires:
           - package
 
@@ -87,9 +100,9 @@
         name: release
         config: .carthorse.yml
         requires:
-          - check-package-python36
+          - check-package-python27
           - check-package-python37
-          - check-package-python38
+          - check-package-pypy27
           - check-package-pypy36
 
 workflows:
diff --git a/.coveragerc b/.coveragerc
index 7b4f0a2..5a29219 100644
--- a/.coveragerc
+++ b/.coveragerc
@@ -1,12 +1,12 @@
 [run]
 source = mock
+omit = mock/tests/__main__.py
 
 [report]
 exclude_lines =
     pragma: no cover
     if __name__ == .__main__.:
     : pass
-    : yield
 
 [paths]
 source =
diff --git a/CHANGELOG.rst b/CHANGELOG.rst
index 7439fe5..919648b 100644
--- a/CHANGELOG.rst
+++ b/CHANGELOG.rst
@@ -1,126 +1,3 @@
-4.0.2
------
-
-- Issue #39915: Ensure :attr:`unittest.mock.AsyncMock.await_args_list` has
-  call objects in the order of awaited arguments instead of using
-  :attr:`unittest.mock.Mock.call_args` which has the last value of the call.
-  Patch by Karthikeyan Singaravelan.
-
-4.0.1
------
-
-- Remove the universal marker from the wheel.
-
-4.0.0
------
-
-- No Changes from 4.0.0b1.
-
-4.0.0b1
--------
-
-- The release is a fresh cut of cpython's `4a686504`__. All changes to :mod:`mock`
-  from that commit and before are included in this release along with the
-  subsequent changes listed below.
-
-  __ https://github.com/python/cpython/commit/4a686504eb2bbf69adf78077458508a7ba131667
-
-- Issue #37972: Subscripts to the `unittest.mock.call` objects now receive
-  the same chaining mechanism as any other custom attributes, so that the
-  following usage no longer raises a `TypeError`:
-
-  call().foo().__getitem__('bar')
-
-  Patch by blhsing
-
-- Issue #38839: Fix some unused functions in tests. Patch by Adam Johnson.
-
-- Issue #39485: Fix a bug in :func:`unittest.mock.create_autospec` that
-  would complain about the wrong number of arguments for custom descriptors
-  defined in an extension module returning functions.
-
-- Issue #39082: Allow AsyncMock to correctly patch static/class methods
-
-- Issue #38093: Fixes AsyncMock so it doesn't crash when used with
-  AsyncContextManagers or AsyncIterators.
-
-- Issue #38859: AsyncMock now returns StopAsyncIteration on the exaustion of
-  a side_effects iterable. Since PEP-479 its Impossible to raise a
-  StopIteration exception from a coroutine.
-
-- Issue #38163: Child mocks will now detect their type as either synchronous
-  or asynchronous, asynchronous child mocks will be AsyncMocks and
-  synchronous child mocks will be either MagicMock or Mock (depending on
-  their parent type).
-
-- Issue #38473: Use signature from inner mock for autospecced methods
-  attached with :func:`unittest.mock.attach_mock`. Patch by Karthikeyan
-  Singaravelan.
-
-- Issue #38136: Changes AsyncMock call count and await count to be two
-  different counters. Now await count only counts when a coroutine has been
-  awaited, not when it has been called, and vice-versa. Update the
-  documentation around this.
-
-- Issue #37555: Fix `NonCallableMock._call_matcher` returning tuple instead
-  of `_Call` object when `self._spec_signature` exists. Patch by Elizabeth
-  Uselton
-
-- Issue #37251: Remove `__code__` check in AsyncMock that incorrectly
-  evaluated function specs as async objects but failed to evaluate classes
-  with `__await__` but no `__code__` attribute defined as async objects.
-
-- Issue #38669: Raise :exc:`TypeError` when passing target as a string with
-  :meth:`unittest.mock.patch.object`.
-
-- Issue #25597: Ensure, if ``wraps`` is supplied to
-  :class:`unittest.mock.MagicMock`, it is used to calculate return values
-  for the magic methods instead of using the default return values. Patch by
-  Karthikeyan Singaravelan.
-
-- Issue #38108: Any synchronous magic methods on an AsyncMock now return a
-  MagicMock. Any asynchronous magic methods on a MagicMock now return an
-  AsyncMock.
-
-- Issue #21478: Record calls to parent when autospecced object is attached
-  to a mock using :func:`unittest.mock.attach_mock`. Patch by Karthikeyan
-  Singaravelan.
-
-- Issue #38857: AsyncMock fix for return values that are awaitable types.
-  This also covers side_effect iterable values that happend to be awaitable,
-  and wraps callables that return an awaitable type. Before these awaitables
-  were being awaited instead of being returned as is.
-
-- Issue #38932: Mock fully resets child objects on reset_mock(). Patch by
-  Vegard Stikbakke
-
-- Issue #37685: Fixed ``__eq__``, ``__lt__`` etc implementations in some
-  classes. They now return :data:`NotImplemented` for unsupported type of
-  the other operand. This allows the other operand to play role (for example
-  the equality comparison with :data:`~unittest.mock.ANY` will return
-  ``True``).
-
-- Issue #37212: :func:`unittest.mock.call` now preserves the order of
-  keyword arguments in repr output. Patch by Karthikeyan Singaravelan.
-
-- Issue #37828: Fix default mock name in
-  :meth:`unittest.mock.Mock.assert_called` exceptions. Patch by Abraham
-  Toriz Cruz.
-
-- Issue #36871: Improve error handling for the assert_has_calls and
-  assert_has_awaits methods of mocks. Fixed a bug where any errors
-  encountered while binding the expected calls to the mock's spec were
-  silently swallowed, leading to misleading error output.
-
-- Issue #21600: Fix :func:`mock.patch.stopall` to stop active patches that
-  were created with :func:`mock.patch.dict`.
-
-- Issue #38161: Removes _AwaitEvent from AsyncMock.
-
-- Issue #36871: Ensure method signature is used instead of constructor
-  signature of a class while asserting mock object against method calls.
-  Patch by Karthikeyan Singaravelan.
-
 3.0.5
 -----
 
diff --git a/MANIFEST.in b/MANIFEST.in
index 27027db..7f47ab6 100644
--- a/MANIFEST.in
+++ b/MANIFEST.in
@@ -1,3 +1,2 @@
 include LICENSE.txt
 include *.rst
-recursive-include mock/tests *.py
diff --git a/METADATA b/METADATA
index 75c4841..e0d0615 100644
--- a/METADATA
+++ b/METADATA
@@ -1,5 +1,9 @@
 name: "mock"
-description: "mock is a library for testing in Python. It allows you to replace parts of your system under test with mock objects and make assertions about how they have been used."
+description:
+    "mock is a library for testing in Python. It allows you to replace parts of "
+    "your system under test with mock objects and make assertions about how "
+    "they have been used."
+
 third_party {
   url {
     type: HOMEPAGE
@@ -9,11 +13,7 @@
     type: GIT
     value: "https://github.com/testing-cabal/mock"
   }
-  version: "4.0.2"
+  version: "2.0.0"
+  last_upgrade_date { year: 2018 month: 8 day: 1 }
   license_type: NOTICE
-  last_upgrade_date {
-    year: 2020
-    month: 3
-    day: 11
-  }
 }
diff --git a/README.rst b/README.rst
index 279f2dc..b4f3163 100644
--- a/README.rst
+++ b/README.rst
@@ -7,7 +7,7 @@
 onwards.
 
 This package contains a rolling backport of the standard library mock code
-compatible with Python 3.6 and up.
+compatible with Python 2.7 and 3.4 and up.
 
 Please see the standard library documentation for more details.
 
diff --git a/docs/conf.py b/docs/conf.py
index e978b46..d2be5a5 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -26,13 +26,7 @@
 
 # Add any Sphinx extension module names here, as strings. They can be extensions
 # coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
-extensions = [
-    'sphinx.ext.intersphinx',
-    ]
-
-intersphinx_mapping = {
-    'python': ('http://docs.python.org/dev', None),
-}
+extensions = ['sphinx.ext.doctest']
 
 doctest_global_setup = """
 import os
@@ -77,7 +71,7 @@
 # The default replacements for |version| and |release|, also used in various
 # other places throughout the built documents. Supplied by pbr.
 #
-version = release = mock.__version__
+version = release = mock.mock.__version__
 
 # There are two options for replacing |today|: either, you set today to some
 # non-false value, then it is used: (Set from pbr)
diff --git a/docs/index.txt b/docs/index.txt
index 95f6817..4e8bc17 100644
--- a/docs/index.txt
+++ b/docs/index.txt
@@ -25,8 +25,6 @@
 
 * Version 2.0.0 is the last version offering official Jython support.
 
-* version 3.0.5 is the last version supporting Python 3.5 and lower.
-
 .. index:: installing
 .. _installing:
 
@@ -79,6 +77,9 @@
 Committers can just push as desired: since all semantic development takes
 place in cPython, the backport process is as lightweight as we can make it.
 
+mock is CI tested using Travis-CI on Python versions 2.7, 3.4,
+3.5, 3.6, pypy, pypy3.
+
 If you end up fixing anything backport-specific, please add an entry
 to the top of ``CHANGELOG.rst`` so it shows up in the next release
 notes.
@@ -103,6 +104,17 @@
 Backporting rules
 -----------------
 
+- ``isinstance`` checks in cPython to ``type`` need to check ``ClassTypes``.
+  Code calling ``obj.isidentifier`` needs to change to ``_isidentifier(obj)``.
+
+- f-strings need to be rewritten using some other string substitution.
+
+- ``assertRaisesRegex`` needs to be ``assertRaisesRegexp`` for Python 2.
+
+- If test code won't compile on a particular version of Python, move it to
+  a matching ``_py{version}.py`` file. If ``{version}`` isn't 3, adjust
+  ``conftest.py``.
+
 - If code such as this causes coverage checking to drop below 100%:
 
   .. code-block:: python
@@ -117,20 +129,6 @@
 
       def will_never_be_called(): pass
 
-- If code such as this causes coverage checking to drop below 100%:
-
-  .. code-block:: python
-
-      def will_never_be_called():
-          yield
-
-  It should be adjusted to the following pattern, preferably upstream,
-  so that the ``.coveragerc`` in this repo knows to ignore it:
-
-  .. code-block:: python
-
-      def will_never_be_called(): yield
-
 Backporting process
 -------------------
 
@@ -143,7 +141,7 @@
        git clone https://github.com/python/cpython.git
        git clone https://github.com/testing-cabal/mock.git
 
-   Make sure they are both on master and up to date!
+   Make sure they both on master and up to date!
 
 2. Create a branch in your ``mock`` clone and switch to it.
 
@@ -179,25 +177,5 @@
 
 5. Rinse and repeat until ``backport.py`` reports no more patches need applying.
 
-6. If ``backport.py`` has updated ``lastsync.txt`` but not committed it,
-   now would be a good time to commit that change.
-
-Checking coverage in upstream
------------------------------
-
-Assuming you have the checkout structure as above, and you have compiled your cpython
-master branch, then roughly as follows:
-
-.. code-block:: bash
-
-   ~/vcs/cpython/python.exe -m venv ~/virtualenvs/cpython-master
-   source ~/virtualenvs/cpython-master/bin/activate
-   pip install -U setuptools pip
-   pip install pytest pytest-cov
-   cd vcs/cpython/Lib/unittest
-   pytest --cov unittest.mock --cov unittest.test.testmock \
-          --cov-config ~/vcs/git/mock/.coveragerc \
-          --cov-report term-missing:skip-covered \
-          test/testmock/test*
-
-Ignore ``test/testmock/__*__.py`` as these aren't present in the backport.
+6. If ``backport.py`` has updated ``lastsync.txt``, now would be a good time
+   to commit that change.
diff --git a/lastsync.txt b/lastsync.txt
index c2edac8..1f18392 100644
--- a/lastsync.txt
+++ b/lastsync.txt
@@ -1 +1 @@
-e553f204bf0e39b1d701a364bc71b286acb9433f
+11a8832c98b3db78727312154dd1d3ba76d639ec
diff --git a/mock/__init__.py b/mock/__init__.py
index 180dee5..8f383f0 100644
--- a/mock/__init__.py
+++ b/mock/__init__.py
@@ -1,15 +1,4 @@
 from __future__ import absolute_import
-
-import re, sys
-
-IS_PYPY = 'PyPy' in sys.version
-
 import mock.mock as _mock
 from mock.mock import *
-
-__version__ = '4.0.2'
-version_info = tuple(int(p) for p in
-                     re.match(r'(\d+).(\d+).(\d+)', __version__).groups())
-
-
-__all__ = ('__version__', 'version_info') + _mock.__all__
+__all__ = _mock.__all__
diff --git a/mock/backports.py b/mock/backports.py
deleted file mode 100644
index 6f20494..0000000
--- a/mock/backports.py
+++ /dev/null
@@ -1,89 +0,0 @@
-import sys
-
-
-if sys.version_info[:2] < (3, 8):
-
-    import asyncio, functools
-    from asyncio.coroutines import _is_coroutine
-    from inspect import ismethod, isfunction, CO_COROUTINE
-    from unittest import TestCase
-
-    def _unwrap_partial(func):
-        while isinstance(func, functools.partial):
-            func = func.func
-        return func
-
-    def _has_code_flag(f, flag):
-        """Return true if ``f`` is a function (or a method or functools.partial
-        wrapper wrapping a function) whose code object has the given ``flag``
-        set in its flags."""
-        while ismethod(f):
-            f = f.__func__
-        f = _unwrap_partial(f)
-        if not isfunction(f):
-            return False
-        return bool(f.__code__.co_flags & flag)
-
-    def iscoroutinefunction(obj):
-        """Return true if the object is a coroutine function.
-
-        Coroutine functions are defined with "async def" syntax.
-        """
-        return (
-            _has_code_flag(obj, CO_COROUTINE) or
-            getattr(obj, '_is_coroutine', None) is _is_coroutine
-        )
-
-
-    class IsolatedAsyncioTestCase(TestCase):
-
-        def __init__(self, methodName='runTest'):
-            super().__init__(methodName)
-            self._asyncioTestLoop = None
-            self._asyncioCallsQueue = None
-
-        async def _asyncioLoopRunner(self, fut):
-            self._asyncioCallsQueue = queue = asyncio.Queue()
-            fut.set_result(None)
-            while True:
-                query = await queue.get()
-                queue.task_done()
-                assert query is None
-
-        def _setupAsyncioLoop(self):
-            assert self._asyncioTestLoop is None
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
-            loop.set_debug(True)
-            self._asyncioTestLoop = loop
-            fut = loop.create_future()
-            self._asyncioCallsTask = loop.create_task(self._asyncioLoopRunner(fut))
-            loop.run_until_complete(fut)
-
-        def _tearDownAsyncioLoop(self):
-            assert self._asyncioTestLoop is not None
-            loop = self._asyncioTestLoop
-            self._asyncioTestLoop = None
-            self._asyncioCallsQueue.put_nowait(None)
-            loop.run_until_complete(self._asyncioCallsQueue.join())
-
-            try:
-                # shutdown asyncgens
-                loop.run_until_complete(loop.shutdown_asyncgens())
-            finally:
-                asyncio.set_event_loop(None)
-                loop.close()
-
-        def run(self, result=None):
-            self._setupAsyncioLoop()
-            try:
-                return super().run(result)
-            finally:
-                self._tearDownAsyncioLoop()
-
-
-else:
-
-    from asyncio import iscoroutinefunction
-    from unittest import IsolatedAsyncioTestCase
-
diff --git a/mock/mock.py b/mock/mock.py
index 4766672..2d39253 100644
--- a/mock/mock.py
+++ b/mock/mock.py
@@ -1,10 +1,41 @@
 # mock.py
 # Test tools for mocking and patching.
-# Maintained by Michael Foord
-# Backport for other versions of Python available from
-# https://pypi.org/project/mock
+# E-mail: fuzzyman AT voidspace DOT org DOT uk
+#
+# http://www.voidspace.org.uk/python/mock/
+#
+# Copyright (c) 2007-2013, Michael Foord & the mock team
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+#       notice, this list of conditions and the following disclaimer.
+#
+#     * Redistributions in binary form must reproduce the above
+#       copyright notice, this list of conditions and the following
+#       disclaimer in the documentation and/or other materials provided
+#       with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+from __future__ import absolute_import
 
 __all__ = (
+    '__version__',
+    'version_info',
     'Mock',
     'MagicMock',
     'patch',
@@ -13,8 +44,8 @@
     'ANY',
     'call',
     'create_autospec',
-    'AsyncMock',
     'FILTER_DIR',
+    'CallableMixin',
     'NonCallableMock',
     'NonCallableMagicMock',
     'mock_open',
@@ -23,44 +54,79 @@
 )
 
 
-import asyncio
-import contextlib
+from functools import partial
 import io
 import inspect
 import pprint
 import sys
-import builtins
-from asyncio import iscoroutinefunction
-from types import CodeType, ModuleType, MethodType
+try:
+    import builtins
+except ImportError:
+    import __builtin__ as builtins
+from types import ModuleType, MethodType
 from unittest.util import safe_repr
-from functools import wraps, partial
 
-from mock import IS_PYPY
-from .backports import iscoroutinefunction
+import six
+from six import wraps
+
+__version__ = '3.0.5'
+version_info = tuple(int(p) for p in __version__.split('.'))
+
+import mock
+
+try:
+    inspectsignature = inspect.signature
+except AttributeError:
+    import funcsigs
+    inspectsignature = funcsigs.signature
+
+
+# TODO: use six.
+try:
+    unicode
+except NameError:
+    # Python 3
+    basestring = unicode = str
+
+try:
+    long
+except NameError:
+    # Python 3
+    long = int
+
+if six.PY2:
+    # Python 2's next() can't handle a non-iterator with a __next__ method.
+    _next = next
+    def next(obj, _next=_next):
+        if getattr(obj, '__next__', None):
+            return obj.__next__()
+        return _next(obj)
+
+    del _next
+
 
 _builtins = {name for name in dir(builtins) if not name.startswith('_')}
 
+try:
+    _isidentifier = str.isidentifier
+except AttributeError:
+    # Python 2.X
+    import keyword
+    import re
+    regex = re.compile(r'^[a-z_][a-z0-9_]*$', re.I)
+    def _isidentifier(string):
+        if string in keyword.kwlist:
+            return False
+        return regex.match(string)
+
+
+# NOTE: This FILTER_DIR is not used. The binding in mock.FILTER_DIR is.
 FILTER_DIR = True
 
-# Workaround for issue #12370
+# Workaround for Python issue #12370
 # Without this, the __class__ properties wouldn't be set correctly
 _safe_super = super
 
-def _is_async_obj(obj):
-    if _is_instance_mock(obj) and not isinstance(obj, AsyncMock):
-        return False
-    if hasattr(obj, '__func__'):
-        obj = getattr(obj, '__func__')
-    return iscoroutinefunction(obj) or inspect.isawaitable(obj)
-
-
-def _is_async_func(func):
-    if getattr(func, '__code__', None):
-        return iscoroutinefunction(func)
-    else:
-        return False
-
-
 def _is_instance_mock(obj):
     # can't use isinstance on Mock objects because they override __class__
     # The base class for all mocks is NonCallableMock
@@ -70,17 +136,20 @@
 def _is_exception(obj):
     return (
         isinstance(obj, BaseException) or
-        isinstance(obj, type) and issubclass(obj, BaseException)
+        isinstance(obj, ClassTypes) and issubclass(obj, BaseException)
     )
 
 
-def _extract_mock(obj):
-    # Autospecced functions will return a FunctionType with "mock" attribute
-    # which is the actual mock object that needs to be used.
-    if isinstance(obj, FunctionTypes) and hasattr(obj, 'mock'):
-        return obj.mock
-    else:
-        return obj
+class _slotted(object):
+    __slots__ = ['a']
+
+
+# Do not use this tuple.  It was never documented as a public API.
+# It will be removed.  It has no obvious signs of users on github.
+DescriptorTypes = (
+    type(_slotted.a),
+    property,
+)
 
 
 def _get_signature_object(func, as_instance, eat_self):
@@ -89,9 +158,12 @@
     signature object.
     Return a (reduced func, signature) tuple, or None.
     """
-    if isinstance(func, type) and not as_instance:
+    if isinstance(func, ClassTypes) and not as_instance:
         # If it's a type and should be modelled as a type, use __init__.
-        func = func.__init__
+        try:
+            func = func.__init__
+        except AttributeError:
+            return None
         # Skip the `self` argument in __init__
         eat_self = True
     elif not isinstance(func, FunctionTypes):
@@ -105,8 +177,9 @@
         sig_func = partial(func, None)
     else:
         sig_func = func
+
     try:
-        return func, inspect.signature(sig_func)
+        return func, inspectsignature(sig_func)
     except ValueError:
         # Certain callable types are not supported by inspect.signature()
         return None
@@ -135,10 +208,15 @@
             setattr(funcopy, attribute, getattr(func, attribute))
         except AttributeError:
             pass
+    if six.PY2:
+        try:
+            funcopy.func_defaults = func.func_defaults
+        except AttributeError:
+            pass
 
 
 def _callable(obj):
-    if isinstance(obj, type):
+    if isinstance(obj, ClassTypes):
         return True
     if isinstance(obj, (staticmethod, classmethod, MethodType)):
         return _callable(obj.__func__)
@@ -156,15 +234,25 @@
 def _instance_callable(obj):
     """Given an object, return True if the object is callable.
     For classes, return True if instances would be callable."""
-    if not isinstance(obj, type):
+    if not isinstance(obj, ClassTypes):
         # already an instance
         return getattr(obj, '__call__', None) is not None
 
-    # *could* be broken by a class overriding __mro__ or __dict__ via
-    # a metaclass
-    for base in (obj,) + obj.__mro__:
-        if base.__dict__.get('__call__') is not None:
+    if six.PY3:
+        # *could* be broken by a class overriding __mro__ or __dict__ via
+        # a metaclass
+        for base in (obj,) + obj.__mro__:
+            if base.__dict__.get('__call__') is not None:
+                return True
+    else:
+        klass = obj
+        # uses __bases__ instead of __mro__ so that we work with old style classes
+        if klass.__dict__.get('__call__') is not None:
             return True
+
+        for base in klass.__bases__:
+            if _instance_callable(base):
+                return True
     return False
 
 
@@ -173,7 +261,7 @@
     # mock. It still does signature checking by calling a lambda with the same
     # signature as the original.
 
-    skipfirst = isinstance(original, type)
+    skipfirst = isinstance(original, ClassTypes)
     result = _get_signature_object(original, instance, skipfirst)
     if result is None:
         return mock
@@ -183,13 +271,13 @@
     _copy_func_details(func, checksig)
 
     name = original.__name__
-    if not name.isidentifier():
+    if not _isidentifier(name):
         name = 'funcopy'
     context = {'_checksig_': checksig, 'mock': mock}
     src = """def %s(*args, **kwargs):
     _checksig_(*args, **kwargs)
     return mock(*args, **kwargs)""" % name
-    exec (src, context)
+    six.exec_(src, context)
     funcopy = context[name]
     _setup_func(funcopy, mock, sig)
     return funcopy
@@ -198,14 +286,14 @@
 def _setup_func(funcopy, mock, sig):
     funcopy.mock = mock
 
-    def assert_called_with(*args, **kwargs):
-        return mock.assert_called_with(*args, **kwargs)
     def assert_called(*args, **kwargs):
         return mock.assert_called(*args, **kwargs)
     def assert_not_called(*args, **kwargs):
         return mock.assert_not_called(*args, **kwargs)
     def assert_called_once(*args, **kwargs):
         return mock.assert_called_once(*args, **kwargs)
+    def assert_called_with(*args, **kwargs):
+        return mock.assert_called_with(*args, **kwargs)
     def assert_called_once_with(*args, **kwargs):
         return mock.assert_called_once_with(*args, **kwargs)
     def assert_has_calls(*args, **kwargs):
@@ -244,33 +332,6 @@
     mock._mock_delegate = funcopy
 
 
-def _setup_async_mock(mock):
-    mock._is_coroutine = asyncio.coroutines._is_coroutine
-    mock.await_count = 0
-    mock.await_args = None
-    mock.await_args_list = _CallList()
-
-    # Mock is not configured yet so the attributes are set
-    # to a function and then the corresponding mock helper function
-    # is called when the helper is accessed similar to _setup_func.
-    def wrapper(attr, *args, **kwargs):
-        return getattr(mock.mock, attr)(*args, **kwargs)
-
-    for attribute in ('assert_awaited',
-                      'assert_awaited_once',
-                      'assert_awaited_with',
-                      'assert_awaited_once_with',
-                      'assert_any_await',
-                      'assert_has_awaits',
-                      'assert_not_awaited'):
-
-        # setattr(mock, attribute, wrapper) causes late binding
-        # hence attribute will always be the last value in the loop
-        # Use partial(wrapper, attribute) to ensure the attribute is bound
-        # correctly.
-        setattr(mock, attribute, partial(wrapper, attribute))
-
-
 def _is_magic(name):
     return '__%s__' % name[2:-2] == name
 
@@ -284,7 +345,11 @@
         return 'sentinel.%s' % self.name
 
     def __reduce__(self):
-        return 'sentinel.%s' % self.name
+        return _unpickle_sentinel, (self.name, )
+
+
+def _unpickle_sentinel(name):
+    return getattr(sentinel, name)
 
 
 class _Sentinel(object):
@@ -298,9 +363,6 @@
             raise AttributeError
         return self._sentinels.setdefault(name, _SentinelObject(name))
 
-    def __reduce__(self):
-        return 'sentinel'
-
 
 sentinel = _Sentinel()
 
@@ -309,6 +371,15 @@
 _deleted = sentinel.DELETED
 
 
+class OldStyleClass:
+    pass
+ClassType = type(OldStyleClass)
+
+
+ClassTypes = (type,)
+if six.PY2:
+    ClassTypes = (type, ClassType)
+
 _allowed_names = {
     'return_value', '_mock_return_value', 'side_effect',
     '_mock_side_effect', '_mock_parent', '_mock_new_parent',
@@ -356,7 +427,13 @@
 
 
 def _check_and_set_parent(parent, value, name, new_name):
-    value = _extract_mock(value)
+    # function passed to create_autospec will have mock
+    # attribute attached to which parent must be set
+    if isinstance(value, FunctionTypes):
+        try:
+            value = value.mock
+        except AttributeError:
+            pass
 
     if not _is_instance_mock(value):
         return False
@@ -403,15 +480,8 @@
         # every instance has its own class
         # so we can create magic methods on the
         # class without stomping on other mocks
-        bases = (cls,)
-        if not issubclass(cls, AsyncMockMixin):
-            # Check if spec is an async object or function
-            bound_args = _MOCK_SIG.bind_partial(cls, *args, **kw).arguments
-            spec_arg = bound_args.get('spec_set', bound_args.get('spec'))
-            if spec_arg and _is_async_obj(spec_arg):
-                bases = (AsyncMockMixin, cls)
-        new = type(cls.__name__, bases, {'__doc__': cls.__doc__})
-        instance = _safe_super(NonCallableMock, cls).__new__(new)
+        new = type(cls.__name__, (cls,), {'__doc__': cls.__doc__})
+        instance = object.__new__(new)
         return instance
 
 
@@ -465,12 +535,10 @@
         Attach a mock as an attribute of this one, replacing its name and
         parent. Calls to the attached mock will be recorded in the
         `method_calls` and `mock_calls` attributes of this one."""
-        inner_mock = _extract_mock(mock)
-
-        inner_mock._mock_parent = None
-        inner_mock._mock_new_parent = None
-        inner_mock._mock_name = ''
-        inner_mock._mock_new_name = None
+        mock._mock_parent = None
+        mock._mock_new_parent = None
+        mock._mock_name = ''
+        mock._mock_new_name = None
 
         setattr(self, attribute, mock)
 
@@ -488,14 +556,9 @@
                        _eat_self=False):
         _spec_class = None
         _spec_signature = None
-        _spec_asyncs = []
-
-        for attr in dir(spec):
-            if iscoroutinefunction(getattr(spec, attr, None)):
-                _spec_asyncs.append(attr)
 
         if spec is not None and not _is_list(spec):
-            if isinstance(spec, type):
+            if isinstance(spec, ClassTypes):
                 _spec_class = spec
             else:
                 _spec_class = type(spec)
@@ -510,7 +573,7 @@
         __dict__['_spec_set'] = spec_set
         __dict__['_spec_signature'] = _spec_signature
         __dict__['_mock_methods'] = spec
-        __dict__['_spec_asyncs'] = _spec_asyncs
+
 
     def __get_return_value(self):
         ret = self._mock_return_value
@@ -572,7 +635,7 @@
     side_effect = property(__get_side_effect, __set_side_effect)
 
 
-    def reset_mock(self,  visited=None,*, return_value=False, side_effect=False):
+    def reset_mock(self,  visited=None, return_value=False, side_effect=False):
         "Restore the mock object to its initial state."
         if visited is None:
             visited = []
@@ -595,7 +658,7 @@
         for child in self._mock_children.values():
             if isinstance(child, _SpecState) or child is _deleted:
                 continue
-            child.reset_mock(visited, return_value=return_value, side_effect=side_effect)
+            child.reset_mock(visited)
 
         ret = self._mock_return_value
         if _is_instance_mock(ret) and ret is not self:
@@ -625,7 +688,7 @@
 
 
     def __getattr__(self, name):
-        if name in {'_mock_methods', '_mock_unsafe'}:
+        if name in ('_mock_methods', '_mock_unsafe'):
             raise AttributeError(name)
         elif self._mock_methods is not None:
             if name not in self._mock_methods or name in _all_magics:
@@ -634,8 +697,7 @@
             raise AttributeError(name)
         if not self._mock_unsafe:
             if name.startswith(('assert', 'assret')):
-                raise AttributeError("Attributes cannot start with 'assert' "
-                                     "or 'assret'")
+                raise AttributeError(name)
 
         result = self._mock_children.get(name)
         if result is _deleted:
@@ -703,7 +765,7 @@
             if self._spec_set:
                 spec_string = ' spec_set=%r'
             spec_string = spec_string % self._spec_class.__name__
-        return "<%s%s%s id='%s'>" % (
+        return "<{}{}{} id='{}'>".format(
             type(self).__name__,
             name_string,
             spec_string,
@@ -713,7 +775,8 @@
 
     def __dir__(self):
         """Filter the output of `dir(mock)` to only useful members."""
-        if not FILTER_DIR:
+        if not mock.FILTER_DIR and getattr(object, '__dir__', None):
+            # object.__dir__ is not in 2.7
             return object.__dir__(self)
 
         extras = self._mock_methods or []
@@ -723,9 +786,12 @@
             m_name for m_name, m_value in self._mock_children.items()
             if m_value is not _deleted]
 
-        from_type = [e for e in from_type if not e.startswith('_')]
-        from_dict = [e for e in from_dict if not e.startswith('_') or
-                     _is_magic(e)]
+        if mock.FILTER_DIR:
+            # object.__dir__ is not in 2.7
+            from_type = [e for e in from_type if not e.startswith('_')]
+            from_dict = [e for e in from_dict if not e.startswith('_') or
+                         _is_magic(e)]
+
         return sorted(set(extras + from_type + from_dict + from_child_mocks))
 
 
@@ -762,8 +828,8 @@
                 self._mock_children[name] = value
 
         if self._mock_sealed and not hasattr(self, name):
-            mock_name = f'{self._extract_mock_name()}.{name}'
-            raise AttributeError(f'Cannot set {mock_name}')
+            mock_name = self._extract_mock_name()+'.'+name
+            raise AttributeError('Cannot set '+mock_name)
 
         return object.__setattr__(self, name, value)
 
@@ -791,45 +857,12 @@
         return _format_call_signature(name, args, kwargs)
 
 
-    def _format_mock_failure_message(self, args, kwargs, action='call'):
-        message = 'expected %s not found.\nExpected: %s\nActual: %s'
+    def _format_mock_failure_message(self, args, kwargs):
+        message = 'expected call not found.\nExpected: %s\nActual: %s'
         expected_string = self._format_mock_call_signature(args, kwargs)
         call_args = self.call_args
         actual_string = self._format_mock_call_signature(*call_args)
-        return message % (action, expected_string, actual_string)
-
-
-    def _get_call_signature_from_name(self, name):
-        """
-        * If call objects are asserted against a method/function like obj.meth1
-        then there could be no name for the call object to lookup. Hence just
-        return the spec_signature of the method/function being asserted against.
-        * If the name is not empty then remove () and split by '.' to get
-        list of names to iterate through the children until a potential
-        match is found. A child mock is created only during attribute access
-        so if we get a _SpecState then no attributes of the spec were accessed
-        and can be safely exited.
-        """
-        if not name:
-            return self._spec_signature
-
-        sig = None
-        names = name.replace('()', '').split('.')
-        children = self._mock_children
-
-        for name in names:
-            child = children.get(name)
-            if child is None or isinstance(child, _SpecState):
-                break
-            else:
-                # If an autospecced object is attached using attach_mock the
-                # child would be a function with mock object as attribute from
-                # which signature has to be derived.
-                child = _extract_mock(child)
-                children = child._mock_children
-                sig = child._spec_signature
-
-        return sig
+        return message % (expected_string, actual_string)
 
 
     def _call_matcher(self, _call):
@@ -839,12 +872,7 @@
         This is a best effort method which relies on the spec's signature,
         if available, or falls back on the arguments themselves.
         """
-
-        if isinstance(_call, tuple) and len(_call) > 2:
-            sig = self._get_call_signature_from_name(_call[0])
-        else:
-            sig = self._spec_signature
-
+        sig = self._spec_signature
         if sig is not None:
             if len(_call) == 2:
                 name = ''
@@ -852,10 +880,10 @@
             else:
                 name, args, kwargs = _call
             try:
-                bound_call = sig.bind(*args, **kwargs)
-                return call(name, bound_call.args, bound_call.kwargs)
+                return name, sig.bind(*args, **kwargs)
             except TypeError as e:
-                return e.with_traceback(None)
+                e.__traceback__ = None
+                return e
         else:
             return _call
 
@@ -876,7 +904,7 @@
         self = _mock_self
         if self.call_count == 0:
             msg = ("Expected '%s' to have been called." %
-                  (self._mock_name or 'mock'))
+                   self._mock_name or 'mock')
             raise AssertionError(msg)
 
     def assert_called_once(_mock_self):
@@ -891,7 +919,7 @@
             raise AssertionError(msg)
 
     def assert_called_with(_mock_self, *args, **kwargs):
-        """assert that the last call was made with the specified arguments.
+        """assert that the mock was called with the specified arguments.
 
         Raises an AssertionError if the args and keyword args passed in are
         different to the last call to the mock."""
@@ -900,17 +928,20 @@
             expected = self._format_mock_call_signature(args, kwargs)
             actual = 'not called.'
             error_message = ('expected call not found.\nExpected: %s\nActual: %s'
-                    % (expected, actual))
+                             % (expected, actual))
             raise AssertionError(error_message)
 
-        def _error_message():
+        def _error_message(cause):
             msg = self._format_mock_failure_message(args, kwargs)
+            if six.PY2 and cause is not None:
+                # Tack on some diagnostics for Python without __cause__
+                msg = '{}\n{}'.format(msg, str(cause))
             return msg
-        expected = self._call_matcher(_Call((args, kwargs), two=True))
+        expected = self._call_matcher((args, kwargs))
         actual = self._call_matcher(self.call_args)
-        if actual != expected:
+        if expected != actual:
             cause = expected if isinstance(expected, Exception) else None
-            raise AssertionError(_error_message()) from cause
+            six.raise_from(AssertionError(_error_message(cause)), cause)
 
 
     def assert_called_once_with(_mock_self, *args, **kwargs):
@@ -937,22 +968,14 @@
         If `any_order` is True then the calls can be in any order, but
         they must all appear in `mock_calls`."""
         expected = [self._call_matcher(c) for c in calls]
-        cause = next((e for e in expected if isinstance(e, Exception)), None)
+        cause = expected if isinstance(expected, Exception) else None
         all_calls = _CallList(self._call_matcher(c) for c in self.mock_calls)
         if not any_order:
             if expected not in all_calls:
-                if cause is None:
-                    problem = 'Calls not found.'
-                else:
-                    problem = ('Error processing expected calls.\n'
-                               'Errors: {}').format(
-                                   [e if isinstance(e, Exception) else None
-                                    for e in expected])
-                raise AssertionError(
-                    f'{problem}\n'
-                    f'Expected: {_CallList(calls)}'
-                    f'{self._calls_repr(prefix="Actual").rstrip(".")}'
-                ) from cause
+                six.raise_from(AssertionError(
+                    'Calls not found.\nExpected: %r%s'
+                    % (_CallList(calls), self._calls_repr(prefix="Actual"))
+                ), cause)
             return
 
         all_calls = list(all_calls)
@@ -964,11 +987,11 @@
             except ValueError:
                 not_found.append(kall)
         if not_found:
-            raise AssertionError(
+            six.raise_from(AssertionError(
                 '%r does not contain all of %r in its call list, '
                 'found %r instead' % (self._mock_name or 'mock',
                                       tuple(not_found), all_calls)
-            ) from cause
+            ), cause)
 
 
     def assert_any_call(self, *args, **kwargs):
@@ -977,14 +1000,14 @@
         The assert passes if the mock has *ever* been called, unlike
         `assert_called_with` and `assert_called_once_with` that only pass if
         the call is the most recent one."""
-        expected = self._call_matcher(_Call((args, kwargs), two=True))
-        cause = expected if isinstance(expected, Exception) else None
+        expected = self._call_matcher((args, kwargs))
         actual = [self._call_matcher(c) for c in self.call_args_list]
-        if cause or expected not in _AnyComparer(actual):
+        if expected not in actual:
+            cause = expected if isinstance(expected, Exception) else None
             expected_string = self._format_mock_call_signature(args, kwargs)
-            raise AssertionError(
+            six.raise_from(AssertionError(
                 '%s call not found' % expected_string
-            ) from cause
+            ), cause)
 
 
     def _get_child_mock(self, **kw):
@@ -995,25 +1018,11 @@
 
         For non-callable mocks the callable variant will be used (rather than
         any custom subclass)."""
-        _new_name = kw.get("_new_name")
-        if _new_name in self.__dict__['_spec_asyncs']:
-            return AsyncMock(**kw)
-
         _type = type(self)
-        if issubclass(_type, MagicMock) and _new_name in _async_method_magics:
-            # Any asynchronous magic becomes an AsyncMock
-            klass = AsyncMock
-        elif issubclass(_type, AsyncMockMixin):
-            if (_new_name in _all_sync_magics or
-                    self._mock_methods and _new_name in self._mock_methods):
-                # Any synchronous method on AsyncMock becomes a MagicMock
-                klass = MagicMock
-            else:
-                klass = AsyncMock
-        elif not issubclass(_type, CallableMixin):
+        if not issubclass(_type, CallableMixin):
             if issubclass(_type, NonCallableMagicMock):
                 klass = MagicMock
-            elif issubclass(_type, NonCallableMock):
+            elif issubclass(_type, NonCallableMock) :
                 klass = Mock
         else:
             klass = _type.__mro__[1]
@@ -1036,27 +1045,9 @@
         """
         if not self.mock_calls:
             return ""
-        return f"\n{prefix}: {safe_repr(self.mock_calls)}."
+        return "\n"+prefix+": "+safe_repr(self.mock_calls)+"."
 
 
-_MOCK_SIG = inspect.signature(NonCallableMock.__init__)
-
-
-class _AnyComparer(list):
-    """A list which checks if it contains a call which may have an
-    argument of ANY, flipping the components of item and self from
-    their traditional locations so that ANY is guaranteed to be on
-    the left."""
-    def __contains__(self, item):
-        for _call in self:
-            assert len(item) == len(_call)
-            if all([
-                expected == actual
-                for expected, actual in zip(item, _call)
-            ]):
-                return True
-        return False
-
 
 def _try_iter(obj):
     if obj is None:
@@ -1073,12 +1064,14 @@
         return obj
 
 
+
 class CallableMixin(Base):
 
     def __init__(self, spec=None, side_effect=None, return_value=DEFAULT,
                  wraps=None, name=None, spec_set=None, parent=None,
                  _spec_state=None, _new_name='', _new_parent=None, **kwargs):
         self.__dict__['_mock_return_value'] = return_value
+
         _safe_super(CallableMixin, self).__init__(
             spec, wraps, name, spec_set, parent,
             _spec_state, _new_name, _new_parent, **kwargs
@@ -1096,21 +1089,15 @@
         # can't use self in-case a function / method we are mocking uses self
         # in the signature
         _mock_self._mock_check_sig(*args, **kwargs)
-        _mock_self._increment_mock_call(*args, **kwargs)
         return _mock_self._mock_call(*args, **kwargs)
 
 
     def _mock_call(_mock_self, *args, **kwargs):
-        return _mock_self._execute_mock_call(*args, **kwargs)
-
-    def _increment_mock_call(_mock_self, *args, **kwargs):
         self = _mock_self
         self.called = True
         self.call_count += 1
 
         # handle call_args
-        # needs to be set here so assertions on call arguments pass before
-        # execution in the case of awaited calls
         _call = _Call((args, kwargs), two=True)
         self.call_args = _call
         self.call_args_list.append(_call)
@@ -1150,11 +1137,6 @@
             # follow the parental chain:
             _new_parent = _new_parent._mock_new_parent
 
-    def _execute_mock_call(_mock_self, *args, **kwargs):
-        self = _mock_self
-        # separate from _increment_mock_call so that awaited functions are
-        # executed separately from their call, also AsyncMock overrides this method
-
         effect = self.side_effect
         if effect is not None:
             if _is_exception(effect):
@@ -1204,6 +1186,9 @@
       arguments as the mock, and unless it returns `DEFAULT`, the return
       value of this function is used as the return value.
 
+      Alternatively `side_effect` can be an exception class or instance. In
+      this case the exception will be raised when the mock is called.
+
       If `side_effect` is an iterable then each call to the mock will return
       the next value from the iterable. If any of the members of the iterable
       are exceptions they will be raised instead of returned.
@@ -1231,6 +1216,7 @@
     """
 
 
+
 def _dot_lookup(thing, comp, import_path):
     try:
         return getattr(thing, comp)
@@ -1301,10 +1287,8 @@
 
 
     def __call__(self, func):
-        if isinstance(func, type):
+        if isinstance(func, ClassTypes):
             return self.decorate_class(func)
-        if inspect.iscoroutinefunction(func):
-            return self.decorate_async_callable(func)
         return self.decorate_callable(func)
 
 
@@ -1322,68 +1306,41 @@
         return klass
 
 
-    @contextlib.contextmanager
-    def decoration_helper(self, patched, args, keywargs):
-        extra_args = []
-        entered_patchers = []
-        patching = None
-
-        exc_info = tuple()
-        try:
-            for patching in patched.patchings:
-                arg = patching.__enter__()
-                entered_patchers.append(patching)
-                if patching.attribute_name is not None:
-                    keywargs.update(arg)
-                elif patching.new is DEFAULT:
-                    extra_args.append(arg)
-
-            args += tuple(extra_args)
-            yield (args, keywargs)
-        except:
-            if (patching not in entered_patchers and
-                _is_started(patching)):
-                # the patcher may have been started, but an exception
-                # raised whilst entering one of its additional_patchers
-                entered_patchers.append(patching)
-            # Pass the exception to __exit__
-            exc_info = sys.exc_info()
-            # re-raise the exception
-            raise
-        finally:
-            for patching in reversed(entered_patchers):
-                patching.__exit__(*exc_info)
-
-
     def decorate_callable(self, func):
-        # NB. Keep the method in sync with decorate_async_callable()
         if hasattr(func, 'patchings'):
             func.patchings.append(self)
             return func
 
         @wraps(func)
         def patched(*args, **keywargs):
-            with self.decoration_helper(patched,
-                                        args,
-                                        keywargs) as (newargs, newkeywargs):
-                return func(*newargs, **newkeywargs)
+            extra_args = []
+            entered_patchers = []
 
-        patched.patchings = [self]
-        return patched
+            exc_info = tuple()
+            try:
+                for patching in patched.patchings:
+                    arg = patching.__enter__()
+                    entered_patchers.append(patching)
+                    if patching.attribute_name is not None:
+                        keywargs.update(arg)
+                    elif patching.new is DEFAULT:
+                        extra_args.append(arg)
 
-
-    def decorate_async_callable(self, func):
-        # NB. Keep the method in sync with decorate_callable()
-        if hasattr(func, 'patchings'):
-            func.patchings.append(self)
-            return func
-
-        @wraps(func)
-        async def patched(*args, **keywargs):
-            with self.decoration_helper(patched,
-                                        args,
-                                        keywargs) as (newargs, newkeywargs):
-                return await func(*newargs, **newkeywargs)
+                args += tuple(extra_args)
+                return func(*args, **keywargs)
+            except:
+                if (patching not in entered_patchers and
+                    _is_started(patching)):
+                    # the patcher may have been started, but an exception
+                    # raised whilst entering one of its additional_patchers
+                    entered_patchers.append(patching)
+                # Pass the exception to __exit__
+                exc_info = sys.exc_info()
+                # re-raise the exception
+                raise
+            finally:
+                for patching in reversed(entered_patchers):
+                    patching.__exit__(*exc_info)
 
         patched.patchings = [self]
         return patched
@@ -1408,7 +1365,7 @@
 
         if not self.create and original is DEFAULT:
             raise AttributeError(
-                "%s does not have the attribute %r" % (target, name)
+                "{} does not have the attribute {!r}".format(target, name)
             )
         return original, local
 
@@ -1454,13 +1411,11 @@
             if spec is not None or spec_set is not None:
                 if original is DEFAULT:
                     raise TypeError("Can't use 'spec' with create=True")
-                if isinstance(original, type):
+                if isinstance(original, ClassTypes):
                     # If we're patching out a class and there is a spec
                     inherit = True
-            if spec is None and _is_async_obj(original):
-                Klass = AsyncMock
-            else:
-                Klass = MagicMock
+
+            Klass = MagicMock
             _kwargs = {}
             if new_callable is not None:
                 Klass = new_callable
@@ -1471,10 +1426,8 @@
                 if _is_list(this_spec):
                     not_callable = '__call__' not in this_spec
                 else:
-                    not_callable = not callable(this_spec)
-                if _is_async_obj(this_spec):
-                    Klass = AsyncMock
-                elif not_callable:
+                    not_callable = not _callable(this_spec)
+                if not_callable:
                     Klass = NonCallableMagicMock
 
             if spec is not None:
@@ -1614,10 +1567,6 @@
     When used as a class decorator `patch.object` honours `patch.TEST_PREFIX`
     for choosing which methods to wrap.
     """
-    if type(target) is str:
-        raise TypeError(
-            f"{target!r} must be the actual object to be patched, not a str"
-        )
     getter = lambda: target
     return _patch(
         getter, attribute, new, spec, create,
@@ -1647,7 +1596,7 @@
     When used as a class decorator `patch.multiple` honours `patch.TEST_PREFIX`
     for choosing which methods to wrap.
     """
-    if type(target) is str:
+    if type(target) in (unicode, str):
         getter = lambda: _importer(target)
     else:
         getter = lambda: target
@@ -1684,9 +1633,8 @@
     is patched with a `new` object. When the function/with statement exits
     the patch is undone.
 
-    If `new` is omitted, then the target is replaced with an
-    `AsyncMock if the patched object is an async function or a
-    `MagicMock` otherwise. If `patch` is used as a decorator and `new` is
+    If `new` is omitted, then the target is replaced with a
+    `MagicMock`. If `patch` is used as a decorator and `new` is
     omitted, the created mock is passed in as an extra argument to the
     decorated function. If `patch` is used as a context manager the created
     mock is returned by the context manager.
@@ -1704,8 +1652,8 @@
     patch to pass in the object being mocked as the spec/spec_set object.
 
     `new_callable` allows you to specify a different class, or callable object,
-    that will be called to create the `new` object. By default `AsyncMock` is
-    used for async functions and `MagicMock` for the rest.
+    that will be called to create the `new` object. By default `MagicMock` is
+    used.
 
     A more powerful form of `spec` is `autospec`. If you set `autospec=True`
     then the mock will be created with a spec from the object being replaced.
@@ -1739,8 +1687,7 @@
     "as"; very useful if `patch` is creating a mock object for you.
 
     `patch` takes arbitrary keyword arguments. These will be passed to
-    `AsyncMock` if the patched object is asynchronous, to `MagicMock`
-    otherwise or to `new_callable` if specified.
+    the `Mock` (or `new_callable`) on construction.
 
     `patch.dict(...)`, `patch.multiple(...)` and `patch.object(...)` are
     available for alternate use-cases.
@@ -1791,7 +1738,7 @@
 
 
     def __call__(self, f):
-        if isinstance(f, type):
+        if isinstance(f, ClassTypes):
             return self.decorate_class(f)
         @wraps(f)
         def _inner(*args, **kw):
@@ -1818,12 +1765,11 @@
     def __enter__(self):
         """Patch the dict."""
         self._patch_dict()
-        return self.in_dict
 
 
     def _patch_dict(self):
         values = self.values
-        if isinstance(self.in_dict, str):
+        if isinstance(self.in_dict, basestring):
             self.in_dict = _importer(self.in_dict)
         in_dict = self.in_dict
         clear = self.clear
@@ -1864,27 +1810,11 @@
 
     def __exit__(self, *args):
         """Unpatch the dict."""
-        if self._original is not None:
-            self._unpatch_dict()
+        self._unpatch_dict()
         return False
 
-
-    def start(self):
-        """Activate a patch, returning any created mock."""
-        result = self.__enter__()
-        _patch._active_patches.append(self)
-        return result
-
-
-    def stop(self):
-        """Stop an active patch."""
-        try:
-            _patch._active_patches.remove(self)
-        except ValueError:
-            # If the patch hasn't been started this will fail
-            pass
-
-        return self.__exit__()
+    start = __enter__
+    stop = __exit__
 
 
 def _clear_dict(in_dict):
@@ -1919,26 +1849,29 @@
     "divmod rdivmod neg pos abs invert "
     "complex int float index "
     "round trunc floor ceil "
-    "bool next "
-    "fspath "
-    "aiter "
 )
 
-if IS_PYPY:
-    # PyPy has no __sizeof__: http://doc.pypy.org/en/latest/cpython_differences.html
-    magic_methods = magic_methods.replace('sizeof ', '')
-
 numerics = (
-    "add sub mul matmul div floordiv mod lshift rshift and xor or pow truediv"
+    "add sub mul matmul div floordiv mod lshift rshift and xor or pow"
 )
+if six.PY3:
+    numerics += ' truediv'
 inplace = ' '.join('i%s' % n for n in numerics.split())
 right = ' '.join('r%s' % n for n in numerics.split())
+extra = ''
+if six.PY3:
+    extra = 'bool next '
+    if sys.version_info >= (3, 6):
+        extra += 'fspath '
+else:
+    extra = 'unicode long nonzero oct hex truediv rtruediv '
 
 # not including __prepare__, __instancecheck__, __subclasscheck__
 # (as they are metaclass methods)
 # __del__ is not supported at all as it causes problems if it exists
 
 _non_defaults = {
+    '__cmp__', '__getslice__', '__setslice__', '__coerce__', # <3.x
     '__get__', '__set__', '__delete__', '__reversed__', '__missing__',
     '__reduce__', '__reduce_ex__', '__getinitargs__', '__getnewargs__',
     '__getstate__', '__setstate__', '__getformat__', '__setformat__',
@@ -1957,17 +1890,10 @@
 
 _magics = {
     '__%s__' % method for method in
-    ' '.join([magic_methods, numerics, inplace, right]).split()
+    ' '.join([magic_methods, numerics, inplace, right, extra]).split()
 }
 
-# Magic methods used for async `with` statements
-_async_method_magics = {"__aenter__", "__aexit__", "__anext__"}
-# Magic methods that are only used with async calls but are synchronous functions themselves
-_sync_async_magics = {"__aiter__"}
-_async_magics = _async_method_magics | _sync_async_magics
-
-_all_sync_magics = _magics | _non_defaults
-_all_magics = _all_sync_magics | _async_magics
+_all_magics = _magics | _non_defaults
 
 _unsupported_magics = {
     '__getattr__', '__setattr__',
@@ -1980,7 +1906,8 @@
     '__hash__': lambda self: object.__hash__(self),
     '__str__': lambda self: object.__str__(self),
     '__sizeof__': lambda self: object.__sizeof__(self),
-    '__fspath__': lambda self: f"{type(self).__name__}/{self._extract_mock_name()}/{id(self)}",
+    '__unicode__': lambda self: unicode(object.__str__(self)),
+    '__fspath__': lambda self: type(self).__name__+'/'+self._extract_mock_name()+'/'+str(id(self)),
 }
 
 _return_values = {
@@ -1995,8 +1922,11 @@
     '__complex__': 1j,
     '__float__': 1.0,
     '__bool__': True,
+    '__nonzero__': True,
+    '__oct__': '1',
+    '__hex__': '0x1',
+    '__long__': long(1),
     '__index__': 1,
-    '__aexit__': False,
 }
 
 
@@ -2029,38 +1959,29 @@
         return iter(ret_val)
     return __iter__
 
-def _get_async_iter(self):
-    def __aiter__():
-        ret_val = self.__aiter__._mock_return_value
-        if ret_val is DEFAULT:
-            return _AsyncIterator(iter([]))
-        return _AsyncIterator(iter(ret_val))
-    return __aiter__
-
 _side_effect_methods = {
     '__eq__': _get_eq,
     '__ne__': _get_ne,
     '__iter__': _get_iter,
-    '__aiter__': _get_async_iter
 }
 
 
 
 def _set_return_value(mock, method, name):
-    # If _mock_wraps is present then attach it so that wrapped object
-    # is used for return value is used when called.
-    if mock._mock_wraps is not None:
-        method._mock_wraps = getattr(mock._mock_wraps, name)
-        return
-
     fixed = _return_values.get(name, DEFAULT)
     if fixed is not DEFAULT:
         method.return_value = fixed
         return
 
-    return_calculator = _calculate_return_value.get(name)
-    if return_calculator is not None:
-        return_value = return_calculator(mock)
+    return_calulator = _calculate_return_value.get(name)
+    if return_calulator is not None:
+        try:
+            return_value = return_calulator(mock)
+        except AttributeError:
+            # XXXX why do we return AttributeError here?
+            #      set it as a side_effect instead?
+            # Answer: it makes magic mocks work on pypy?!
+            return_value = AttributeError(name)
         method.return_value = return_value
         return
 
@@ -2070,7 +1991,7 @@
 
 
 
-class MagicMixin(Base):
+class MagicMixin(object):
     def __init__(self, *args, **kw):
         self._mock_set_magics()  # make magic work for kwargs in init
         _safe_super(MagicMixin, self).__init__(*args, **kw)
@@ -2078,14 +1999,13 @@
 
 
     def _mock_set_magics(self):
-        orig_magics = _magics | _async_method_magics
-        these_magics = orig_magics
+        these_magics = _magics
 
         if getattr(self, "_mock_methods", None) is not None:
-            these_magics = orig_magics.intersection(self._mock_methods)
+            these_magics = _magics.intersection(self._mock_methods)
 
             remove_magics = set()
-            remove_magics = orig_magics - these_magics
+            remove_magics = _magics - these_magics
 
             for entry in remove_magics:
                 if entry in type(self).__dict__:
@@ -2113,12 +2033,6 @@
         self._mock_set_magics()
 
 
-class AsyncMagicMixin(MagicMixin):
-    def __init__(self, *args, **kw):
-        self._mock_set_magics()  # make magic work for kwargs in init
-        _safe_super(AsyncMagicMixin, self).__init__(*args, **kw)
-        self._mock_set_magics()  # fix magic broken by upper level init
-
 
 class MagicMock(MagicMixin, Mock):
     """
@@ -2142,7 +2056,7 @@
 
 
 
-class MagicProxy(Base):
+class MagicProxy(object):
     def __init__(self, name, parent):
         self.name = name
         self.parent = parent
@@ -2160,239 +2074,6 @@
         return self.create_mock()
 
 
-class AsyncMockMixin(Base):
-    await_count = _delegating_property('await_count')
-    await_args = _delegating_property('await_args')
-    await_args_list = _delegating_property('await_args_list')
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        # iscoroutinefunction() checks _is_coroutine property to say if an
-        # object is a coroutine. Without this check it looks to see if it is a
-        # function/method, which in this case it is not (since it is an
-        # AsyncMock).
-        # It is set through __dict__ because when spec_set is True, this
-        # attribute is likely undefined.
-        self.__dict__['_is_coroutine'] = asyncio.coroutines._is_coroutine
-        self.__dict__['_mock_await_count'] = 0
-        self.__dict__['_mock_await_args'] = None
-        self.__dict__['_mock_await_args_list'] = _CallList()
-        code_mock = NonCallableMock(spec_set=CodeType)
-        code_mock.co_flags = inspect.CO_COROUTINE
-        self.__dict__['__code__'] = code_mock
-
-    async def _execute_mock_call(_mock_self, *args, **kwargs):
-        self = _mock_self
-        # This is nearly just like super(), except for special handling
-        # of coroutines
-
-        _call = _Call((args, kwargs), two=True)
-        self.await_count += 1
-        self.await_args = _call
-        self.await_args_list.append(_call)
-
-        effect = self.side_effect
-        if effect is not None:
-            if _is_exception(effect):
-                raise effect
-            elif not _callable(effect):
-                try:
-                    result = next(effect)
-                except StopIteration:
-                    # It is impossible to propogate a StopIteration
-                    # through coroutines because of PEP 479
-                    raise StopAsyncIteration
-                if _is_exception(result):
-                    raise result
-            elif iscoroutinefunction(effect):
-                result = await effect(*args, **kwargs)
-            else:
-                result = effect(*args, **kwargs)
-
-            if result is not DEFAULT:
-                return result
-
-        if self._mock_return_value is not DEFAULT:
-            return self.return_value
-
-        if self._mock_wraps is not None:
-            if iscoroutinefunction(self._mock_wraps):
-                return await self._mock_wraps(*args, **kwargs)
-            return self._mock_wraps(*args, **kwargs)
-
-        return self.return_value
-
-    def assert_awaited(_mock_self):
-        """
-        Assert that the mock was awaited at least once.
-        """
-        self = _mock_self
-        if self.await_count == 0:
-            msg = f"Expected {self._mock_name or 'mock'} to have been awaited."
-            raise AssertionError(msg)
-
-    def assert_awaited_once(_mock_self):
-        """
-        Assert that the mock was awaited exactly once.
-        """
-        self = _mock_self
-        if not self.await_count == 1:
-            msg = (f"Expected {self._mock_name or 'mock'} to have been awaited once."
-                   f" Awaited {self.await_count} times.")
-            raise AssertionError(msg)
-
-    def assert_awaited_with(_mock_self, *args, **kwargs):
-        """
-        Assert that the last await was with the specified arguments.
-        """
-        self = _mock_self
-        if self.await_args is None:
-            expected = self._format_mock_call_signature(args, kwargs)
-            raise AssertionError(f'Expected await: {expected}\nNot awaited')
-
-        def _error_message():
-            msg = self._format_mock_failure_message(args, kwargs, action='await')
-            return msg
-
-        expected = self._call_matcher(_Call((args, kwargs), two=True))
-        actual = self._call_matcher(self.await_args)
-        if actual != expected:
-            cause = expected if isinstance(expected, Exception) else None
-            raise AssertionError(_error_message()) from cause
-
-    def assert_awaited_once_with(_mock_self, *args, **kwargs):
-        """
-        Assert that the mock was awaited exactly once and with the specified
-        arguments.
-        """
-        self = _mock_self
-        if not self.await_count == 1:
-            msg = (f"Expected {self._mock_name or 'mock'} to have been awaited once."
-                   f" Awaited {self.await_count} times.")
-            raise AssertionError(msg)
-        return self.assert_awaited_with(*args, **kwargs)
-
-    def assert_any_await(_mock_self, *args, **kwargs):
-        """
-        Assert the mock has ever been awaited with the specified arguments.
-        """
-        self = _mock_self
-        expected = self._call_matcher(_Call((args, kwargs), two=True))
-        cause = expected if isinstance(expected, Exception) else None
-        actual = [self._call_matcher(c) for c in self.await_args_list]
-        if cause or expected not in _AnyComparer(actual):
-            expected_string = self._format_mock_call_signature(args, kwargs)
-            raise AssertionError(
-                '%s await not found' % expected_string
-            ) from cause
-
-    def assert_has_awaits(_mock_self, calls, any_order=False):
-        """
-        Assert the mock has been awaited with the specified calls.
-        The :attr:`await_args_list` list is checked for the awaits.
-
-        If `any_order` is False (the default) then the awaits must be
-        sequential. There can be extra calls before or after the
-        specified awaits.
-
-        If `any_order` is True then the awaits can be in any order, but
-        they must all appear in :attr:`await_args_list`.
-        """
-        self = _mock_self
-        expected = [self._call_matcher(c) for c in calls]
-        cause = cause = next((e for e in expected if isinstance(e, Exception)), None)
-        all_awaits = _CallList(self._call_matcher(c) for c in self.await_args_list)
-        if not any_order:
-            if expected not in all_awaits:
-                if cause is None:
-                    problem = 'Awaits not found.'
-                else:
-                    problem = ('Error processing expected awaits.\n'
-                               'Errors: {}').format(
-                                   [e if isinstance(e, Exception) else None
-                                    for e in expected])
-                raise AssertionError(
-                    f'{problem}\n'
-                    f'Expected: {_CallList(calls)}\n'
-                    f'Actual: {self.await_args_list}'
-                ) from cause
-            return
-
-        all_awaits = list(all_awaits)
-
-        not_found = []
-        for kall in expected:
-            try:
-                all_awaits.remove(kall)
-            except ValueError:
-                not_found.append(kall)
-        if not_found:
-            raise AssertionError(
-                '%r not all found in await list' % (tuple(not_found),)
-            ) from cause
-
-    def assert_not_awaited(_mock_self):
-        """
-        Assert that the mock was never awaited.
-        """
-        self = _mock_self
-        if self.await_count != 0:
-            msg = (f"Expected {self._mock_name or 'mock'} to not have been awaited."
-                   f" Awaited {self.await_count} times.")
-            raise AssertionError(msg)
-
-    def reset_mock(self, *args, **kwargs):
-        """
-        See :func:`.Mock.reset_mock()`
-        """
-        super().reset_mock(*args, **kwargs)
-        self.await_count = 0
-        self.await_args = None
-        self.await_args_list = _CallList()
-
-
-class AsyncMock(AsyncMockMixin, AsyncMagicMixin, Mock):
-    """
-    Enhance :class:`Mock` with features allowing to mock
-    an async function.
-
-    The :class:`AsyncMock` object will behave so the object is
-    recognized as an async function, and the result of a call is an awaitable:
-
-    >>> mock = AsyncMock()
-    >>> iscoroutinefunction(mock)
-    True
-    >>> inspect.isawaitable(mock())
-    True
-
-
-    The result of ``mock()`` is an async function which will have the outcome
-    of ``side_effect`` or ``return_value``:
-
-    - if ``side_effect`` is a function, the async function will return the
-      result of that function,
-    - if ``side_effect`` is an exception, the async function will raise the
-      exception,
-    - if ``side_effect`` is an iterable, the async function will return the
-      next value of the iterable, however, if the sequence of result is
-      exhausted, ``StopIteration`` is raised immediately,
-    - if ``side_effect`` is not defined, the async function will return the
-      value defined by ``return_value``, hence, by default, the async function
-      returns a new :class:`AsyncMock` object.
-
-    If the outcome of ``side_effect`` or ``return_value`` is an async function,
-    the mock async function obtained when the mock object is called will be this
-    async function itself (and not an async function returning an async
-    function).
-
-    The test author can also specify a wrapped object with ``wraps``. In this
-    case, the :class:`Mock` object behavior is the same as with an
-    :class:`.Mock` object: the wrapped object may have methods
-    defined as async function functions.
-
-    Based on Martin Richard's asynctest project.
-    """
-
 
 class _ANY(object):
     "A helper object that compares equal to everything."
@@ -2406,6 +2087,8 @@
     def __repr__(self):
         return '<ANY>'
 
+    __hash__ = None
+
 ANY = _ANY()
 
 
@@ -2414,8 +2097,15 @@
     message = '%s(%%s)' % name
     formatted_args = ''
     args_string = ', '.join([repr(arg) for arg in args])
+
+    def encode_item(item):
+        if six.PY2 and isinstance(item, unicode):
+            return item.encode("utf-8")
+        else:
+            return item
+
     kwargs_string = ', '.join([
-        '%s=%r' % (key, value) for key, value in kwargs.items()
+        '{}={!r}'.format(encode_item(key), value) for key, value in sorted(kwargs.items())
     ])
     if args_string:
         formatted_args = args_string
@@ -2456,7 +2146,7 @@
             name, args, kwargs = value
         elif _len == 2:
             first, second = value
-            if isinstance(first, str):
+            if isinstance(first, basestring):
                 name = first
                 if isinstance(second, tuple):
                     args = second
@@ -2466,7 +2156,7 @@
                 args, kwargs = first, second
         elif _len == 1:
             value, = value
-            if isinstance(value, str):
+            if isinstance(value, basestring):
                 name = value
             elif isinstance(value, tuple):
                 args = value
@@ -2487,10 +2177,12 @@
 
 
     def __eq__(self, other):
+        if other is ANY:
+            return True
         try:
             len_other = len(other)
         except TypeError:
-            return NotImplemented
+            return False
 
         self_name = ''
         if len(self) == 2:
@@ -2512,7 +2204,7 @@
             if isinstance(value, tuple):
                 other_args = value
                 other_kwargs = {}
-            elif isinstance(value, str):
+            elif isinstance(value, basestring):
                 other_name = value
                 other_args, other_kwargs = (), {}
             else:
@@ -2521,7 +2213,7 @@
         elif len_other == 2:
             # could be (name, args) or (name, kwargs) or (args, kwargs)
             first, second = other
-            if isinstance(first, str):
+            if isinstance(first, basestring):
                 other_name = first
                 if isinstance(second, tuple):
                     other_args, other_kwargs = second, {}
@@ -2539,8 +2231,10 @@
         return (other_args, other_kwargs) == (self_args, self_kwargs)
 
 
-    __ne__ = object.__ne__
+    def __ne__(self, other):
+        return not self.__eq__(other)
 
+    __hash__ = None
 
     def __call__(self, *args, **kwargs):
         if self._mock_name is None:
@@ -2553,15 +2247,15 @@
     def __getattr__(self, attr):
         if self._mock_name is None:
             return _Call(name=attr, from_kall=False)
-        name = '%s.%s' % (self._mock_name, attr)
+        name = '{}.{}'.format(self._mock_name, attr)
         return _Call(name=name, parent=self, from_kall=False)
 
 
-    def __getattribute__(self, attr):
-        if attr in tuple.__dict__:
-            raise AttributeError
-        return tuple.__getattribute__(self, attr)
+    def count(self, *args, **kwargs):
+        return self.__getattr__('count')(*args, **kwargs)
 
+    def index(self, *args, **kwargs):
+        return self.__getattr__('index')(*args, **kwargs)
 
     def _get_call_arguments(self):
         if len(self) == 2:
@@ -2616,6 +2310,7 @@
 call = _Call(from_kall=False)
 
 
+
 def create_autospec(spec, spec_set=False, instance=False, _parent=None,
                     _name=None, **kwargs):
     """Create a mock object using another object as a spec. Attributes on the
@@ -2640,8 +2335,8 @@
         # interpreted as a list of strings
         spec = type(spec)
 
-    is_type = isinstance(spec, type)
-    is_async_func = _is_async_func(spec)
+    is_type = isinstance(spec, ClassTypes)
+
     _kwargs = {'spec': spec}
     if spec_set:
         _kwargs = {'spec_set': spec}
@@ -2658,11 +2353,6 @@
         # descriptors don't have a spec
         # because we don't know what type they return
         _kwargs = {}
-    elif is_async_func:
-        if instance:
-            raise RuntimeError("Instance can not be True when create_autospec "
-                               "is mocking an async function")
-        Klass = AsyncMock
     elif not _callable(spec):
         Klass = NonCallableMagicMock
     elif is_type and instance and not _instance_callable(spec):
@@ -2682,8 +2372,6 @@
         # should only happen at the top level because we don't
         # recurse for functions
         mock = _set_signature(mock, spec)
-        if is_async_func:
-            _setup_async_mock(mock)
     else:
         _check_signature(spec, mock, is_type, instance)
 
@@ -2695,6 +2383,12 @@
                                             _name='()', _parent=mock)
 
     for entry in dir(spec):
+
+        # This are __ and so treated as magic on Py3, on Py2 we need to
+        # explicitly ignore them:
+        if six.PY2 and (entry.startswith('im_') or entry.startswith('func_')):
+            continue
+
         if _is_magic(entry):
             # MagicMock already does the useful magic methods for us
             continue
@@ -2727,13 +2421,9 @@
 
             skipfirst = _must_skip(spec, entry, is_type)
             kwargs['_eat_self'] = skipfirst
-            if iscoroutinefunction(original):
-                child_klass = AsyncMock
-            else:
-                child_klass = MagicMock
-            new = child_klass(parent=parent, name=entry, _new_name=entry,
-                              _new_parent=parent,
-                              **kwargs)
+            new = MagicMock(parent=parent, name=entry, _new_name=entry,
+                            _new_parent=parent,
+                            **kwargs)
             mock._mock_children[entry] = new
             _check_signature(original, new, skipfirst=skipfirst)
 
@@ -2752,11 +2442,14 @@
     Return whether we should skip the first argument on spec's `entry`
     attribute.
     """
-    if not isinstance(spec, type):
+    if not isinstance(spec, ClassTypes):
         if entry in getattr(spec, '__dict__', {}):
             # instance attribute - shouldn't skip
             return False
         spec = spec.__class__
+    if not hasattr(spec, '__mro__'):
+        # old style class: can't have descriptors anyway
+        return is_type
 
     for klass in spec.__mro__:
         result = klass.__dict__.get(entry, DEFAULT)
@@ -2764,7 +2457,7 @@
             continue
         if isinstance(result, (staticmethod, classmethod)):
             return False
-        elif isinstance(result, FunctionTypes):
+        elif isinstance(getattr(result, '__get__', None), MethodWrapperTypes):
             # Normal method => skip if looked up on type
             # (if looked up on instance, self is already skipped)
             return is_type
@@ -2794,6 +2487,10 @@
     type(ANY.__eq__),
 )
 
+MethodWrapperTypes = (
+    type(ANY.__eq__.__get__),
+)
+
 
 file_spec = None
 
@@ -2830,8 +2527,9 @@
             return handle.read.return_value
         return _state[0].read(*args, **kwargs)
 
-    def _readline_side_effect(*args, **kwargs):
-        yield from _iter_side_effect()
+    def  _readline_side_effect(*args, **kwargs):
+        for item in _iter_side_effect():
+            yield item
         while True:
             yield _state[0].readline(*args, **kwargs)
 
@@ -2842,15 +2540,14 @@
         for line in _state[0]:
             yield line
 
-    def _next_side_effect():
-        if handle.readline.return_value is not None:
-            return handle.readline.return_value
-        return next(_state[0])
-
     global file_spec
     if file_spec is None:
-        import _io
-        file_spec = list(set(dir(_io.TextIOWrapper)).union(set(dir(_io.BytesIO))))
+        # set on first use
+        if six.PY3:
+            import _io
+            file_spec = list(set(dir(_io.TextIOWrapper)).union(set(dir(_io.BytesIO))))
+        else:
+            file_spec = file
 
     if mock is None:
         mock = MagicMock(name='open', spec=open)
@@ -2868,7 +2565,6 @@
     handle.readline.side_effect = _state[1]
     handle.readlines.side_effect = _readlines_side_effect
     handle.__iter__.side_effect = _iter_side_effect
-    handle.__next__.side_effect = _next_side_effect
 
     def reset_data(*args, **kwargs):
         _state[0] = _to_stream(read_data)
@@ -2895,7 +2591,7 @@
     def _get_child_mock(self, **kwargs):
         return MagicMock(**kwargs)
 
-    def __get__(self, obj, obj_type=None):
+    def __get__(self, obj, obj_type):
         return self()
     def __set__(self, obj, val):
         self(val)
@@ -2921,21 +2617,3 @@
             continue
         if m._mock_new_parent is mock:
             seal(m)
-
-
-class _AsyncIterator:
-    """
-    Wraps an iterator in an asynchronous iterator.
-    """
-    def __init__(self, iterator):
-        self.iterator = iterator
-        code_mock = NonCallableMock(spec_set=CodeType)
-        code_mock.co_flags = inspect.CO_ITERABLE_COROUTINE
-        self.__dict__['__code__'] = code_mock
-
-    async def __anext__(self):
-        try:
-            return next(self.iterator)
-        except StopIteration:
-            pass
-        raise StopAsyncIteration
diff --git a/mock/tests/__init__.py b/mock/tests/__init__.py
index e69de29..54ddf2e 100644
--- a/mock/tests/__init__.py
+++ b/mock/tests/__init__.py
@@ -0,0 +1,3 @@
+# Copyright (C) 2007-2012 Michael Foord & the mock team
+# E-mail: fuzzyman AT voidspace DOT org DOT uk
+# http://www.voidspace.org.uk/python/mock/
diff --git a/mock/tests/__main__.py b/mock/tests/__main__.py
new file mode 100644
index 0000000..45c633a
--- /dev/null
+++ b/mock/tests/__main__.py
@@ -0,0 +1,18 @@
+import os
+import unittest
+
+
+def load_tests(loader, standard_tests, pattern):
+    # top level directory cached on loader instance
+    this_dir = os.path.dirname(__file__)
+    pattern = pattern or "test*.py"
+    # We are inside unittest.test.testmock, so the top-level is three notches up
+    top_level_dir = os.path.dirname(os.path.dirname(os.path.dirname(this_dir)))
+    package_tests = loader.discover(start_dir=this_dir, pattern=pattern,
+                                    top_level_dir=top_level_dir)
+    standard_tests.addTests(package_tests)
+    return standard_tests
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/mock/tests/conftest.py b/mock/tests/conftest.py
new file mode 100644
index 0000000..78831f6
--- /dev/null
+++ b/mock/tests/conftest.py
@@ -0,0 +1,6 @@
+import six
+
+
+def pytest_ignore_collect(path):
+    if 'py3' in path.basename and six.PY2:
+        return True
diff --git a/mock/tests/support.py b/mock/tests/support.py
index 85fd0a3..d57a372 100644
--- a/mock/tests/support.py
+++ b/mock/tests/support.py
@@ -1,6 +1,7 @@
 import contextlib
 import sys
 
+
 target = {'foo': 'FOO'}
 
 
@@ -28,7 +29,9 @@
 
     """
     for name in names:
-        assert name not in ('sys', 'marshal', 'imp')
+        if name in ('sys', 'marshal', 'imp'):
+            raise ValueError(
+                "cannot uncache {0}".format(name))
         try:
             del sys.modules[name]
         except KeyError:
@@ -37,16 +40,7 @@
         yield
     finally:
         for name in names:
-            del sys.modules[name]
-
-
-class _ALWAYS_EQ:
-    """
-    Object that is equal to anything.
-    """
-    def __eq__(self, other):
-        return True
-    def __ne__(self, other):
-        return False
-
-ALWAYS_EQ = _ALWAYS_EQ()
+            try:
+                del sys.modules[name]
+            except KeyError:
+                pass
diff --git a/mock/tests/testasync.py b/mock/tests/testasync.py
deleted file mode 100644
index 9fd2b65..0000000
--- a/mock/tests/testasync.py
+++ /dev/null
@@ -1,1074 +0,0 @@
-
-import asyncio
-import gc
-import inspect
-import re
-import unittest
-from contextlib import contextmanager
-
-from mock import (ANY, call, AsyncMock, patch, MagicMock, Mock,
-                  create_autospec, sentinel)
-from mock.backports import IsolatedAsyncioTestCase, iscoroutinefunction
-from mock.mock import _CallList
-
-
-try:
-    from asyncio import run
-except ImportError:
-    def run(main):
-        loop = asyncio.new_event_loop()
-        try:
-            return_value = loop.run_until_complete(main)
-        finally:
-            loop.close()
-        return return_value
-
-
-def tearDownModule():
-    asyncio.set_event_loop_policy(None)
-
-
-class AsyncClass:
-    def __init__(self): pass
-    async def async_method(self): pass
-    def normal_method(self): pass
-
-    @classmethod
-    async def async_class_method(cls): pass
-
-    @staticmethod
-    async def async_static_method(): pass
-
-
-class AwaitableClass:
-    def __await__(self): yield
-
-async def async_func(): pass
-
-async def async_func_args(a, b, *, c): pass
-
-def normal_func(): pass
-
-class NormalClass(object):
-    def a(self): pass
-
-
-async_foo_name = f'{__name__}.AsyncClass'
-normal_foo_name = f'{__name__}.NormalClass'
-
-
-@contextmanager
-def assertNeverAwaited(test):
-    with test.assertWarnsRegex(RuntimeWarning, "was never awaited$"):
-        yield
-        # In non-CPython implementations of Python, this is needed because timely
-        # deallocation is not guaranteed by the garbage collector.
-        gc.collect()
-
-
-class AsyncPatchDecoratorTest(unittest.TestCase):
-    def test_is_coroutine_function_patch(self):
-        @patch.object(AsyncClass, 'async_method')
-        def test_async(mock_method):
-            self.assertTrue(iscoroutinefunction(mock_method))
-        test_async()
-
-    def test_is_async_patch(self):
-        @patch.object(AsyncClass, 'async_method')
-        def test_async(mock_method):
-            m = mock_method()
-            self.assertTrue(inspect.isawaitable(m))
-            run(m)
-
-        @patch(f'{async_foo_name}.async_method')
-        def test_no_parent_attribute(mock_method):
-            m = mock_method()
-            self.assertTrue(inspect.isawaitable(m))
-            run(m)
-
-        test_async()
-        test_no_parent_attribute()
-
-    def test_is_AsyncMock_patch(self):
-        @patch.object(AsyncClass, 'async_method')
-        def test_async(mock_method):
-            self.assertIsInstance(mock_method, AsyncMock)
-
-        test_async()
-
-    def test_is_AsyncMock_patch_staticmethod(self):
-        @patch.object(AsyncClass, 'async_static_method')
-        def test_async(mock_method):
-            self.assertIsInstance(mock_method, AsyncMock)
-
-        test_async()
-
-    def test_is_AsyncMock_patch_classmethod(self):
-        @patch.object(AsyncClass, 'async_class_method')
-        def test_async(mock_method):
-            self.assertIsInstance(mock_method, AsyncMock)
-
-        test_async()
-
-    def test_async_def_patch(self):
-        @patch(f"{__name__}.async_func", return_value=1)
-        @patch(f"{__name__}.async_func_args", return_value=2)
-        async def test_async(func_args_mock, func_mock):
-            self.assertEqual(func_args_mock._mock_name, "async_func_args")
-            self.assertEqual(func_mock._mock_name, "async_func")
-
-            self.assertIsInstance(async_func, AsyncMock)
-            self.assertIsInstance(async_func_args, AsyncMock)
-
-            self.assertEqual(await async_func(), 1)
-            self.assertEqual(await async_func_args(1, 2, c=3), 2)
-
-        run(test_async())
-        self.assertTrue(inspect.iscoroutinefunction(async_func))
-
-
-class AsyncPatchCMTest(unittest.TestCase):
-    def test_is_async_function_cm(self):
-        def test_async():
-            with patch.object(AsyncClass, 'async_method') as mock_method:
-                self.assertTrue(iscoroutinefunction(mock_method))
-
-        test_async()
-
-    def test_is_async_cm(self):
-        def test_async():
-            with patch.object(AsyncClass, 'async_method') as mock_method:
-                m = mock_method()
-                self.assertTrue(inspect.isawaitable(m))
-                run(m)
-
-        test_async()
-
-    def test_is_AsyncMock_cm(self):
-        def test_async():
-            with patch.object(AsyncClass, 'async_method') as mock_method:
-                self.assertIsInstance(mock_method, AsyncMock)
-
-        test_async()
-
-    def test_async_def_cm(self):
-        async def test_async():
-            with patch(f"{__name__}.async_func", AsyncMock()):
-                self.assertIsInstance(async_func, AsyncMock)
-            self.assertTrue(inspect.iscoroutinefunction(async_func))
-
-        run(test_async())
-
-
-class AsyncMockTest(unittest.TestCase):
-    def test_iscoroutinefunction_default(self):
-        mock = AsyncMock()
-        self.assertTrue(iscoroutinefunction(mock))
-
-    def test_iscoroutinefunction_function(self):
-        async def foo(): pass
-        mock = AsyncMock(foo)
-        self.assertTrue(iscoroutinefunction(mock))
-        self.assertTrue(inspect.iscoroutinefunction(mock))
-
-    def test_isawaitable(self):
-        mock = AsyncMock()
-        m = mock()
-        self.assertTrue(inspect.isawaitable(m))
-        run(m)
-        self.assertIn('assert_awaited', dir(mock))
-
-    def test_iscoroutinefunction_normal_function(self):
-        def foo(): pass
-        mock = AsyncMock(foo)
-        self.assertTrue(iscoroutinefunction(mock))
-        self.assertTrue(inspect.iscoroutinefunction(mock))
-
-    def test_future_isfuture(self):
-        loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(loop)
-        fut = asyncio.Future()
-        loop.stop()
-        loop.close()
-        mock = AsyncMock(fut)
-        self.assertIsInstance(mock, asyncio.Future)
-
-
-class AsyncAutospecTest(unittest.TestCase):
-    def test_is_AsyncMock_patch(self):
-        @patch(async_foo_name, autospec=True)
-        def test_async(mock_method):
-            self.assertIsInstance(mock_method.async_method, AsyncMock)
-            self.assertIsInstance(mock_method, MagicMock)
-
-        @patch(async_foo_name, autospec=True)
-        def test_normal_method(mock_method):
-            self.assertIsInstance(mock_method.normal_method, MagicMock)
-
-        test_async()
-        test_normal_method()
-
-    def test_create_autospec_instance(self):
-        with self.assertRaises(RuntimeError):
-            create_autospec(async_func, instance=True)
-
-    def test_create_autospec_awaitable_class(self):
-        awaitable_mock = create_autospec(spec=AwaitableClass())
-        self.assertIsInstance(create_autospec(awaitable_mock), AsyncMock)
-
-    def test_create_autospec(self):
-        spec = create_autospec(async_func_args)
-        awaitable = spec(1, 2, c=3)
-        async def main():
-            await awaitable
-
-        self.assertEqual(spec.await_count, 0)
-        self.assertIsNone(spec.await_args)
-        self.assertEqual(spec.await_args_list, [])
-        spec.assert_not_awaited()
-
-        run(main())
-
-        self.assertTrue(iscoroutinefunction(spec))
-        self.assertTrue(asyncio.iscoroutine(awaitable))
-        self.assertEqual(spec.await_count, 1)
-        self.assertEqual(spec.await_args, call(1, 2, c=3))
-        self.assertEqual(spec.await_args_list, [call(1, 2, c=3)])
-        spec.assert_awaited_once()
-        spec.assert_awaited_once_with(1, 2, c=3)
-        spec.assert_awaited_with(1, 2, c=3)
-        spec.assert_awaited()
-
-        with self.assertRaises(AssertionError):
-            spec.assert_any_await(e=1)
-
-
-    def test_patch_with_autospec(self):
-
-        async def test_async():
-            with patch(f"{__name__}.async_func_args", autospec=True) as mock_method:
-                awaitable = mock_method(1, 2, c=3)
-                self.assertIsInstance(mock_method.mock, AsyncMock)
-
-                self.assertTrue(iscoroutinefunction(mock_method))
-                self.assertTrue(asyncio.iscoroutine(awaitable))
-                self.assertTrue(inspect.isawaitable(awaitable))
-
-                # Verify the default values during mock setup
-                self.assertEqual(mock_method.await_count, 0)
-                self.assertEqual(mock_method.await_args_list, [])
-                self.assertIsNone(mock_method.await_args)
-                mock_method.assert_not_awaited()
-
-                await awaitable
-
-            self.assertEqual(mock_method.await_count, 1)
-            self.assertEqual(mock_method.await_args, call(1, 2, c=3))
-            self.assertEqual(mock_method.await_args_list, [call(1, 2, c=3)])
-            mock_method.assert_awaited_once()
-            mock_method.assert_awaited_once_with(1, 2, c=3)
-            mock_method.assert_awaited_with(1, 2, c=3)
-            mock_method.assert_awaited()
-
-            mock_method.reset_mock()
-            self.assertEqual(mock_method.await_count, 0)
-            self.assertIsNone(mock_method.await_args)
-            self.assertEqual(mock_method.await_args_list, [])
-
-        run(test_async())
-
-
-class AsyncSpecTest(unittest.TestCase):
-    def test_spec_normal_methods_on_class(self):
-        def inner_test(mock_type):
-            mock = mock_type(AsyncClass)
-            self.assertIsInstance(mock.async_method, AsyncMock)
-            self.assertIsInstance(mock.normal_method, MagicMock)
-
-        for mock_type in [AsyncMock, MagicMock]:
-            with self.subTest(f"test method types with {mock_type}"):
-                inner_test(mock_type)
-
-    def test_spec_normal_methods_on_class_with_mock(self):
-        mock = Mock(AsyncClass)
-        self.assertIsInstance(mock.async_method, AsyncMock)
-        self.assertIsInstance(mock.normal_method, Mock)
-
-    def test_spec_mock_type_kw(self):
-        def inner_test(mock_type):
-            async_mock = mock_type(spec=async_func)
-            self.assertIsInstance(async_mock, mock_type)
-            with assertNeverAwaited(self):
-                self.assertTrue(inspect.isawaitable(async_mock()))
-
-            sync_mock = mock_type(spec=normal_func)
-            self.assertIsInstance(sync_mock, mock_type)
-
-        for mock_type in [AsyncMock, MagicMock, Mock]:
-            with self.subTest(f"test spec kwarg with {mock_type}"):
-                inner_test(mock_type)
-
-    def test_spec_mock_type_positional(self):
-        def inner_test(mock_type):
-            async_mock = mock_type(async_func)
-            self.assertIsInstance(async_mock, mock_type)
-            with assertNeverAwaited(self):
-                self.assertTrue(inspect.isawaitable(async_mock()))
-
-            sync_mock = mock_type(normal_func)
-            self.assertIsInstance(sync_mock, mock_type)
-
-        for mock_type in [AsyncMock, MagicMock, Mock]:
-            with self.subTest(f"test spec positional with {mock_type}"):
-                inner_test(mock_type)
-
-    def test_spec_as_normal_kw_AsyncMock(self):
-        mock = AsyncMock(spec=normal_func)
-        self.assertIsInstance(mock, AsyncMock)
-        m = mock()
-        self.assertTrue(inspect.isawaitable(m))
-        run(m)
-
-    def test_spec_as_normal_positional_AsyncMock(self):
-        mock = AsyncMock(normal_func)
-        self.assertIsInstance(mock, AsyncMock)
-        m = mock()
-        self.assertTrue(inspect.isawaitable(m))
-        run(m)
-
-    def test_spec_async_mock(self):
-        @patch.object(AsyncClass, 'async_method', spec=True)
-        def test_async(mock_method):
-            self.assertIsInstance(mock_method, AsyncMock)
-
-        test_async()
-
-    def test_spec_parent_not_async_attribute_is(self):
-        @patch(async_foo_name, spec=True)
-        def test_async(mock_method):
-            self.assertIsInstance(mock_method, MagicMock)
-            self.assertIsInstance(mock_method.async_method, AsyncMock)
-
-        test_async()
-
-    def test_target_async_spec_not(self):
-        @patch.object(AsyncClass, 'async_method', spec=NormalClass.a)
-        def test_async_attribute(mock_method):
-            self.assertIsInstance(mock_method, MagicMock)
-            self.assertFalse(inspect.iscoroutine(mock_method))
-            self.assertFalse(inspect.isawaitable(mock_method))
-
-        test_async_attribute()
-
-    def test_target_not_async_spec_is(self):
-        @patch.object(NormalClass, 'a', spec=async_func)
-        def test_attribute_not_async_spec_is(mock_async_func):
-            self.assertIsInstance(mock_async_func, AsyncMock)
-        test_attribute_not_async_spec_is()
-
-    def test_spec_async_attributes(self):
-        @patch(normal_foo_name, spec=AsyncClass)
-        def test_async_attributes_coroutines(MockNormalClass):
-            self.assertIsInstance(MockNormalClass.async_method, AsyncMock)
-            self.assertIsInstance(MockNormalClass, MagicMock)
-
-        test_async_attributes_coroutines()
-
-
-class AsyncSpecSetTest(unittest.TestCase):
-    def test_is_AsyncMock_patch(self):
-        @patch.object(AsyncClass, 'async_method', spec_set=True)
-        def test_async(async_method):
-            self.assertIsInstance(async_method, AsyncMock)
-        test_async()
-
-    def test_is_async_AsyncMock(self):
-        mock = AsyncMock(spec_set=AsyncClass.async_method)
-        self.assertTrue(iscoroutinefunction(mock))
-        self.assertIsInstance(mock, AsyncMock)
-
-    def test_is_child_AsyncMock(self):
-        mock = MagicMock(spec_set=AsyncClass)
-        self.assertTrue(iscoroutinefunction(mock.async_method))
-        self.assertFalse(iscoroutinefunction(mock.normal_method))
-        self.assertIsInstance(mock.async_method, AsyncMock)
-        self.assertIsInstance(mock.normal_method, MagicMock)
-        self.assertIsInstance(mock, MagicMock)
-
-    def test_magicmock_lambda_spec(self):
-        mock_obj = MagicMock()
-        mock_obj.mock_func = MagicMock(spec=lambda x: x)
-
-        with patch.object(mock_obj, "mock_func") as cm:
-            self.assertIsInstance(cm, MagicMock)
-
-
-class AsyncArguments(IsolatedAsyncioTestCase):
-    async def test_add_return_value(self):
-        async def addition(self, var): pass
-
-        mock = AsyncMock(addition, return_value=10)
-        output = await mock(5)
-
-        self.assertEqual(output, 10)
-
-    async def test_add_side_effect_exception(self):
-        async def addition(var): pass
-        mock = AsyncMock(addition, side_effect=Exception('err'))
-        with self.assertRaises(Exception):
-            await mock(5)
-
-    async def test_add_side_effect_coroutine(self):
-        async def addition(var):
-            return var + 1
-        mock = AsyncMock(side_effect=addition)
-        result = await mock(5)
-        self.assertEqual(result, 6)
-
-    async def test_add_side_effect_normal_function(self):
-        def addition(var):
-            return var + 1
-        mock = AsyncMock(side_effect=addition)
-        result = await mock(5)
-        self.assertEqual(result, 6)
-
-    async def test_add_side_effect_iterable(self):
-        vals = [1, 2, 3]
-        mock = AsyncMock(side_effect=vals)
-        for item in vals:
-            self.assertEqual(await mock(), item)
-
-        with self.assertRaises(StopAsyncIteration) as e:
-            await mock()
-
-    async def test_add_side_effect_exception_iterable(self):
-        class SampleException(Exception):
-            pass
-
-        vals = [1, SampleException("foo")]
-        mock = AsyncMock(side_effect=vals)
-        self.assertEqual(await mock(), 1)
-
-        with self.assertRaises(SampleException) as e:
-            await mock()
-
-    async def test_return_value_AsyncMock(self):
-        value = AsyncMock(return_value=10)
-        mock = AsyncMock(return_value=value)
-        result = await mock()
-        self.assertIs(result, value)
-
-    async def test_return_value_awaitable(self):
-        fut = asyncio.Future()
-        fut.set_result(None)
-        mock = AsyncMock(return_value=fut)
-        result = await mock()
-        self.assertIsInstance(result, asyncio.Future)
-
-    async def test_side_effect_awaitable_values(self):
-        fut = asyncio.Future()
-        fut.set_result(None)
-
-        mock = AsyncMock(side_effect=[fut])
-        result = await mock()
-        self.assertIsInstance(result, asyncio.Future)
-
-        with self.assertRaises(StopAsyncIteration):
-            await mock()
-
-    async def test_side_effect_is_AsyncMock(self):
-        effect = AsyncMock(return_value=10)
-        mock = AsyncMock(side_effect=effect)
-
-        result = await mock()
-        self.assertEqual(result, 10)
-
-    async def test_wraps_coroutine(self):
-        value = asyncio.Future()
-
-        ran = False
-        async def inner():
-            nonlocal ran
-            ran = True
-            return value
-
-        mock = AsyncMock(wraps=inner)
-        result = await mock()
-        self.assertEqual(result, value)
-        mock.assert_awaited()
-        self.assertTrue(ran)
-
-    async def test_wraps_normal_function(self):
-        value = 1
-
-        ran = False
-        def inner():
-            nonlocal ran
-            ran = True
-            return value
-
-        mock = AsyncMock(wraps=inner)
-        result = await mock()
-        self.assertEqual(result, value)
-        mock.assert_awaited()
-        self.assertTrue(ran)
-
-    async def test_await_args_list_order(self):
-        async_mock = AsyncMock()
-        mock2 = async_mock(2)
-        mock1 = async_mock(1)
-        await mock1
-        await mock2
-        async_mock.assert_has_awaits([call(1), call(2)])
-        self.assertEqual(async_mock.await_args_list, [call(1), call(2)])
-        self.assertEqual(async_mock.call_args_list, [call(2), call(1)])
-
-
-class AsyncMagicMethods(unittest.TestCase):
-    def test_async_magic_methods_return_async_mocks(self):
-        m_mock = MagicMock()
-        self.assertIsInstance(m_mock.__aenter__, AsyncMock)
-        self.assertIsInstance(m_mock.__aexit__, AsyncMock)
-        self.assertIsInstance(m_mock.__anext__, AsyncMock)
-        # __aiter__ is actually a synchronous object
-        # so should return a MagicMock
-        self.assertIsInstance(m_mock.__aiter__, MagicMock)
-
-    def test_sync_magic_methods_return_magic_mocks(self):
-        a_mock = AsyncMock()
-        self.assertIsInstance(a_mock.__enter__, MagicMock)
-        self.assertIsInstance(a_mock.__exit__, MagicMock)
-        self.assertIsInstance(a_mock.__next__, MagicMock)
-        self.assertIsInstance(a_mock.__len__, MagicMock)
-
-    def test_magicmock_has_async_magic_methods(self):
-        m_mock = MagicMock()
-        self.assertTrue(hasattr(m_mock, "__aenter__"))
-        self.assertTrue(hasattr(m_mock, "__aexit__"))
-        self.assertTrue(hasattr(m_mock, "__anext__"))
-
-    def test_asyncmock_has_sync_magic_methods(self):
-        a_mock = AsyncMock()
-        self.assertTrue(hasattr(a_mock, "__enter__"))
-        self.assertTrue(hasattr(a_mock, "__exit__"))
-        self.assertTrue(hasattr(a_mock, "__next__"))
-        self.assertTrue(hasattr(a_mock, "__len__"))
-
-    def test_magic_methods_are_async_functions(self):
-        m_mock = MagicMock()
-        self.assertIsInstance(m_mock.__aenter__, AsyncMock)
-        self.assertIsInstance(m_mock.__aexit__, AsyncMock)
-        # AsyncMocks are also coroutine functions
-        self.assertTrue(iscoroutinefunction(m_mock.__aenter__))
-        self.assertTrue(iscoroutinefunction(m_mock.__aexit__))
-
-class AsyncContextManagerTest(unittest.TestCase):
-
-    class WithAsyncContextManager:
-        async def __aenter__(self, *args, **kwargs): pass
-
-        async def __aexit__(self, *args, **kwargs): pass
-
-    class WithSyncContextManager:
-        def __enter__(self, *args, **kwargs): pass
-
-        def __exit__(self, *args, **kwargs): pass
-
-    class ProductionCode:
-        # Example real-world(ish) code
-        def __init__(self):
-            self.session = None
-
-        async def main(self):
-            async with self.session.post('https://python.org') as response:
-                val = await response.json()
-                return val
-
-    def test_set_return_value_of_aenter(self):
-        def inner_test(mock_type):
-            pc = self.ProductionCode()
-            pc.session = MagicMock(name='sessionmock')
-            cm = mock_type(name='magic_cm')
-            response = AsyncMock(name='response')
-            response.json = AsyncMock(return_value={'json': 123})
-            cm.__aenter__.return_value = response
-            pc.session.post.return_value = cm
-            result = run(pc.main())
-            self.assertEqual(result, {'json': 123})
-
-        for mock_type in [AsyncMock, MagicMock]:
-            with self.subTest(f"test set return value of aenter with {mock_type}"):
-                inner_test(mock_type)
-
-    def test_mock_supports_async_context_manager(self):
-
-        def inner_test(mock_type):
-            called = False
-            cm = self.WithAsyncContextManager()
-            cm_mock = mock_type(cm)
-
-            async def use_context_manager():
-                nonlocal called
-                async with cm_mock as result:
-                    called = True
-                return result
-
-            cm_result = run(use_context_manager())
-            self.assertTrue(called)
-            self.assertTrue(cm_mock.__aenter__.called)
-            self.assertTrue(cm_mock.__aexit__.called)
-            cm_mock.__aenter__.assert_awaited()
-            cm_mock.__aexit__.assert_awaited()
-            # We mock __aenter__ so it does not return self
-            self.assertIsNot(cm_mock, cm_result)
-
-        for mock_type in [AsyncMock, MagicMock]:
-            with self.subTest(f"test context manager magics with {mock_type}"):
-                inner_test(mock_type)
- 
-    def test_mock_customize_async_context_manager(self):
-        instance = self.WithAsyncContextManager()
-        mock_instance = MagicMock(instance)
-
-        expected_result = object()
-        mock_instance.__aenter__.return_value = expected_result
-
-        async def use_context_manager():
-            async with mock_instance as result:
-                return result
-
-        self.assertIs(run(use_context_manager()), expected_result)
-
-    def test_mock_customize_async_context_manager_with_coroutine(self):
-        enter_called = False
-        exit_called = False
-
-        async def enter_coroutine(*args):
-            nonlocal enter_called
-            enter_called = True
-
-        async def exit_coroutine(*args):
-            nonlocal exit_called
-            exit_called = True
-
-        instance = self.WithAsyncContextManager()
-        mock_instance = MagicMock(instance)
-
-        mock_instance.__aenter__ = enter_coroutine
-        mock_instance.__aexit__ = exit_coroutine
-
-        async def use_context_manager():
-            async with mock_instance:
-                pass
-
-        run(use_context_manager())
-        self.assertTrue(enter_called)
-        self.assertTrue(exit_called)
-
-    def test_context_manager_raise_exception_by_default(self):
-        async def raise_in(context_manager):
-            async with context_manager:
-                raise TypeError()
-
-        instance = self.WithAsyncContextManager()
-        mock_instance = MagicMock(instance)
-        with self.assertRaises(TypeError):
-            run(raise_in(mock_instance))
-
-
-class AsyncIteratorTest(unittest.TestCase):
-    class WithAsyncIterator(object):
-        def __init__(self):
-            self.items = ["foo", "NormalFoo", "baz"]
-
-        def __aiter__(self): pass
-
-        async def __anext__(self): pass
-
-    def test_aiter_set_return_value(self):
-        mock_iter = AsyncMock(name="tester")
-        mock_iter.__aiter__.return_value = [1, 2, 3]
-        async def main():
-            return [i async for i in mock_iter]
-        result = run(main())
-        self.assertEqual(result, [1, 2, 3])
-
-    def test_mock_aiter_and_anext_asyncmock(self):
-        def inner_test(mock_type):
-            instance = self.WithAsyncIterator()
-            mock_instance = mock_type(instance)
-            # Check that the mock and the real thing bahave the same
-            # __aiter__ is not actually async, so not a coroutinefunction
-            self.assertFalse(iscoroutinefunction(instance.__aiter__))
-            self.assertFalse(iscoroutinefunction(mock_instance.__aiter__))
-            # __anext__ is async
-            self.assertTrue(iscoroutinefunction(instance.__anext__))
-            self.assertTrue(iscoroutinefunction(mock_instance.__anext__))
-
-        for mock_type in [AsyncMock, MagicMock]:
-            with self.subTest(f"test aiter and anext corourtine with {mock_type}"):
-                inner_test(mock_type)
-
-
-    def test_mock_async_for(self):
-        async def iterate(iterator):
-            accumulator = []
-            async for item in iterator:
-                accumulator.append(item)
-
-            return accumulator
-
-        expected = ["FOO", "BAR", "BAZ"]
-        def test_default(mock_type):
-            mock_instance = mock_type(self.WithAsyncIterator())
-            self.assertEqual(run(iterate(mock_instance)), [])
-
-
-        def test_set_return_value(mock_type):
-            mock_instance = mock_type(self.WithAsyncIterator())
-            mock_instance.__aiter__.return_value = expected[:]
-            self.assertEqual(run(iterate(mock_instance)), expected)
-
-        def test_set_return_value_iter(mock_type):
-            mock_instance = mock_type(self.WithAsyncIterator())
-            mock_instance.__aiter__.return_value = iter(expected[:])
-            self.assertEqual(run(iterate(mock_instance)), expected)
-
-        for mock_type in [AsyncMock, MagicMock]:
-            with self.subTest(f"default value with {mock_type}"):
-                test_default(mock_type)
-
-            with self.subTest(f"set return_value with {mock_type}"):
-                test_set_return_value(mock_type)
-
-            with self.subTest(f"set return_value iterator with {mock_type}"):
-                test_set_return_value_iter(mock_type)
-
-
-class AsyncMockAssert(unittest.TestCase):
-    def setUp(self):
-        self.mock = AsyncMock()
-
-    async def _runnable_test(self, *args, **kwargs):
-        await self.mock(*args, **kwargs)
-
-    async def _await_coroutine(self, coroutine):
-        return await coroutine
-
-    def test_assert_called_but_not_awaited(self):
-        mock = AsyncMock(AsyncClass)
-        with assertNeverAwaited(self):
-            mock.async_method()
-        self.assertTrue(iscoroutinefunction(mock.async_method))
-        mock.async_method.assert_called()
-        mock.async_method.assert_called_once()
-        mock.async_method.assert_called_once_with()
-        with self.assertRaises(AssertionError):
-            mock.assert_awaited()
-        with self.assertRaises(AssertionError):
-            mock.async_method.assert_awaited()
-
-    def test_assert_called_then_awaited(self):
-        mock = AsyncMock(AsyncClass)
-        mock_coroutine = mock.async_method()
-        mock.async_method.assert_called()
-        mock.async_method.assert_called_once()
-        mock.async_method.assert_called_once_with()
-        with self.assertRaises(AssertionError):
-            mock.async_method.assert_awaited()
-
-        run(self._await_coroutine(mock_coroutine))
-        # Assert we haven't re-called the function
-        mock.async_method.assert_called_once()
-        mock.async_method.assert_awaited()
-        mock.async_method.assert_awaited_once()
-        mock.async_method.assert_awaited_once_with()
-
-    def test_assert_called_and_awaited_at_same_time(self):
-        with self.assertRaises(AssertionError):
-            self.mock.assert_awaited()
-
-        with self.assertRaises(AssertionError):
-            self.mock.assert_called()
-
-        run(self._runnable_test())
-        self.mock.assert_called_once()
-        self.mock.assert_awaited_once()
-
-    def test_assert_called_twice_and_awaited_once(self):
-        mock = AsyncMock(AsyncClass)
-        coroutine = mock.async_method()
-        # The first call will be awaited so no warning there
-        # But this call will never get awaited, so it will warn here
-        with assertNeverAwaited(self):
-            mock.async_method()
-        with self.assertRaises(AssertionError):
-            mock.async_method.assert_awaited()
-        mock.async_method.assert_called()
-        run(self._await_coroutine(coroutine))
-        mock.async_method.assert_awaited()
-        mock.async_method.assert_awaited_once()
-
-    def test_assert_called_once_and_awaited_twice(self):
-        mock = AsyncMock(AsyncClass)
-        coroutine = mock.async_method()
-        mock.async_method.assert_called_once()
-        run(self._await_coroutine(coroutine))
-        with self.assertRaises(RuntimeError):
-            # Cannot reuse already awaited coroutine
-            run(self._await_coroutine(coroutine))
-        mock.async_method.assert_awaited()
-
-    def test_assert_awaited_but_not_called(self):
-        with self.assertRaises(AssertionError):
-            self.mock.assert_awaited()
-        with self.assertRaises(AssertionError):
-            self.mock.assert_called()
-        with self.assertRaises(TypeError):
-            # You cannot await an AsyncMock, it must be a coroutine
-            run(self._await_coroutine(self.mock))
-
-        with self.assertRaises(AssertionError):
-            self.mock.assert_awaited()
-        with self.assertRaises(AssertionError):
-            self.mock.assert_called()
-
-    def test_assert_has_calls_not_awaits(self):
-        kalls = [call('foo')]
-        with assertNeverAwaited(self):
-            self.mock('foo')
-        self.mock.assert_has_calls(kalls)
-        with self.assertRaises(AssertionError):
-            self.mock.assert_has_awaits(kalls)
-
-    def test_assert_has_mock_calls_on_async_mock_no_spec(self):
-        with assertNeverAwaited(self):
-            self.mock()
-        kalls_empty = [('', (), {})]
-        self.assertEqual(self.mock.mock_calls, kalls_empty)
-
-        with assertNeverAwaited(self):
-            self.mock('foo')
-        with assertNeverAwaited(self):
-            self.mock('baz')
-        mock_kalls = ([call(), call('foo'), call('baz')])
-        self.assertEqual(self.mock.mock_calls, mock_kalls)
-
-    def test_assert_has_mock_calls_on_async_mock_with_spec(self):
-        a_class_mock = AsyncMock(AsyncClass)
-        with assertNeverAwaited(self):
-            a_class_mock.async_method()
-        kalls_empty = [('', (), {})]
-        self.assertEqual(a_class_mock.async_method.mock_calls, kalls_empty)
-        self.assertEqual(a_class_mock.mock_calls, [call.async_method()])
-
-        with assertNeverAwaited(self):
-            a_class_mock.async_method(1, 2, 3, a=4, b=5)
-        method_kalls = [call(), call(1, 2, 3, a=4, b=5)]
-        mock_kalls = [call.async_method(), call.async_method(1, 2, 3, a=4, b=5)]
-        self.assertEqual(a_class_mock.async_method.mock_calls, method_kalls)
-        self.assertEqual(a_class_mock.mock_calls, mock_kalls)
-
-    def test_async_method_calls_recorded(self):
-        with assertNeverAwaited(self):
-            self.mock.something(3, fish=None)
-        with assertNeverAwaited(self):
-            self.mock.something_else.something(6, cake=sentinel.Cake)
-
-        self.assertEqual(self.mock.method_calls, [
-            ("something", (3,), {'fish': None}),
-            ("something_else.something", (6,), {'cake': sentinel.Cake})
-        ],
-            "method calls not recorded correctly")
-        self.assertEqual(self.mock.something_else.method_calls,
-                         [("something", (6,), {'cake': sentinel.Cake})],
-                         "method calls not recorded correctly")
-
-    def test_async_arg_lists(self):
-        def assert_attrs(mock):
-            names = ('call_args_list', 'method_calls', 'mock_calls')
-            for name in names:
-                attr = getattr(mock, name)
-                self.assertIsInstance(attr, _CallList)
-                self.assertIsInstance(attr, list)
-                self.assertEqual(attr, [])
-
-        assert_attrs(self.mock)
-        with assertNeverAwaited(self):
-            self.mock()
-        with assertNeverAwaited(self):
-            self.mock(1, 2)
-        with assertNeverAwaited(self):
-            self.mock(a=3)
-
-        self.mock.reset_mock()
-        assert_attrs(self.mock)
-
-        a_mock = AsyncMock(AsyncClass)
-        with assertNeverAwaited(self):
-            a_mock.async_method()
-        with assertNeverAwaited(self):
-            a_mock.async_method(1, a=3)
-
-        a_mock.reset_mock()
-        assert_attrs(a_mock)
-
-    def test_assert_awaited(self):
-        with self.assertRaises(AssertionError):
-            self.mock.assert_awaited()
-
-        run(self._runnable_test())
-        self.mock.assert_awaited()
-
-    def test_assert_awaited_once(self):
-        with self.assertRaises(AssertionError):
-            self.mock.assert_awaited_once()
-
-        run(self._runnable_test())
-        self.mock.assert_awaited_once()
-
-        run(self._runnable_test())
-        with self.assertRaises(AssertionError):
-            self.mock.assert_awaited_once()
-
-    def test_assert_awaited_with(self):
-        msg = 'Not awaited'
-        with self.assertRaisesRegex(AssertionError, msg):
-            self.mock.assert_awaited_with('foo')
-
-        run(self._runnable_test())
-        msg = 'expected await not found'
-        with self.assertRaisesRegex(AssertionError, msg):
-            self.mock.assert_awaited_with('foo')
-
-        run(self._runnable_test('foo'))
-        self.mock.assert_awaited_with('foo')
-
-        run(self._runnable_test('SomethingElse'))
-        with self.assertRaises(AssertionError):
-            self.mock.assert_awaited_with('foo')
-
-    def test_assert_awaited_once_with(self):
-        with self.assertRaises(AssertionError):
-            self.mock.assert_awaited_once_with('foo')
-
-        run(self._runnable_test('foo'))
-        self.mock.assert_awaited_once_with('foo')
-
-        run(self._runnable_test('foo'))
-        with self.assertRaises(AssertionError):
-            self.mock.assert_awaited_once_with('foo')
-
-    def test_assert_any_wait(self):
-        with self.assertRaises(AssertionError):
-            self.mock.assert_any_await('foo')
-
-        run(self._runnable_test('baz'))
-        with self.assertRaises(AssertionError):
-            self.mock.assert_any_await('foo')
-
-        run(self._runnable_test('foo'))
-        self.mock.assert_any_await('foo')
-
-        run(self._runnable_test('SomethingElse'))
-        self.mock.assert_any_await('foo')
-
-    def test_assert_has_awaits_no_order(self):
-        calls = [call('foo'), call('baz')]
-
-        with self.assertRaises(AssertionError) as cm:
-            self.mock.assert_has_awaits(calls)
-        self.assertEqual(len(cm.exception.args), 1)
-
-        run(self._runnable_test('foo'))
-        with self.assertRaises(AssertionError):
-            self.mock.assert_has_awaits(calls)
-
-        run(self._runnable_test('foo'))
-        with self.assertRaises(AssertionError):
-            self.mock.assert_has_awaits(calls)
-
-        run(self._runnable_test('baz'))
-        self.mock.assert_has_awaits(calls)
-
-        run(self._runnable_test('SomethingElse'))
-        self.mock.assert_has_awaits(calls)
-
-    def test_awaits_asserts_with_any(self):
-        class Foo:
-            def __eq__(self, other): pass
-
-        run(self._runnable_test(Foo(), 1))
-
-        self.mock.assert_has_awaits([call(ANY, 1)])
-        self.mock.assert_awaited_with(ANY, 1)
-        self.mock.assert_any_await(ANY, 1)
-
-    def test_awaits_asserts_with_spec_and_any(self):
-        class Foo:
-            def __eq__(self, other): pass
-
-        mock_with_spec = AsyncMock(spec=Foo)
-
-        async def _custom_mock_runnable_test(*args):
-            await mock_with_spec(*args)
-
-        run(_custom_mock_runnable_test(Foo(), 1))
-        mock_with_spec.assert_has_awaits([call(ANY, 1)])
-        mock_with_spec.assert_awaited_with(ANY, 1)
-        mock_with_spec.assert_any_await(ANY, 1)
-
-    def test_assert_has_awaits_ordered(self):
-        calls = [call('foo'), call('baz')]
-        with self.assertRaises(AssertionError):
-            self.mock.assert_has_awaits(calls, any_order=True)
-
-        run(self._runnable_test('baz'))
-        with self.assertRaises(AssertionError):
-            self.mock.assert_has_awaits(calls, any_order=True)
-
-        run(self._runnable_test('bamf'))
-        with self.assertRaises(AssertionError):
-            self.mock.assert_has_awaits(calls, any_order=True)
-
-        run(self._runnable_test('foo'))
-        self.mock.assert_has_awaits(calls, any_order=True)
-
-        run(self._runnable_test('qux'))
-        self.mock.assert_has_awaits(calls, any_order=True)
-
-    def test_assert_not_awaited(self):
-        self.mock.assert_not_awaited()
-
-        run(self._runnable_test())
-        with self.assertRaises(AssertionError):
-            self.mock.assert_not_awaited()
-
-    def test_assert_has_awaits_not_matching_spec_error(self):
-        async def f(x=None): pass
-
-        self.mock = AsyncMock(spec=f)
-        run(self._runnable_test(1))
-
-        with self.assertRaisesRegex(
-                AssertionError,
-                '^{}$'.format(
-                    re.escape('Awaits not found.\n'
-                              'Expected: [call()]\n'
-                              'Actual: [call(1)]'))) as cm:
-            self.mock.assert_has_awaits([call()])
-        self.assertIsNone(cm.exception.__cause__)
-
-        with self.assertRaisesRegex(
-                AssertionError,
-                '^{}$'.format(
-                    re.escape(
-                        'Error processing expected awaits.\n'
-                        "Errors: [None, TypeError('too many positional "
-                        "arguments')]\n"
-                        'Expected: [call(), call(1, 2)]\n'
-                        'Actual: [call(1)]').replace(
-                            "arguments\\'", "arguments\\',?")
-                )) as cm:
-            self.mock.assert_has_awaits([call(), call(1, 2)])
-        self.assertIsInstance(cm.exception.__cause__, TypeError)
diff --git a/mock/tests/testcallable.py b/mock/tests/testcallable.py
index 41715ed..729947e 100644
--- a/mock/tests/testcallable.py
+++ b/mock/tests/testcallable.py
@@ -8,8 +8,9 @@
 from mock import (
     Mock, MagicMock, NonCallableMagicMock,
     NonCallableMock, patch, create_autospec,
+    CallableMixin
 )
-from mock.mock import CallableMixin
+
 
 
 class TestCallable(unittest.TestCase):
@@ -105,8 +106,14 @@
         class Multi(SomeClass, Sub):
             pass
 
+        class OldStyle:
+            def __call__(self): pass
+
+        class OldStyleSub(OldStyle):
+            pass
+
         for arg in 'spec', 'spec_set':
-            for Klass in CallableX, Sub, Multi:
+            for Klass in CallableX, Sub, Multi, OldStyle, OldStyleSub:
                 with patch('%s.X' % __name__, **{arg: Klass}) as mock:
                     instance = mock()
                     mock.assert_called_once_with()
diff --git a/mock/tests/testhelpers.py b/mock/tests/testhelpers.py
index 2a28796..d56a47f 100644
--- a/mock/tests/testhelpers.py
+++ b/mock/tests/testhelpers.py
@@ -1,6 +1,12 @@
+# Copyright (C) 2007-2012 Michael Foord & the mock team
+# E-mail: fuzzyman AT voidspace DOT org DOT uk
+# http://www.voidspace.org.uk/python/mock/
+import socket
+
 import inspect
+import six
+import sys
 import time
-import types
 import unittest
 
 from mock import (
@@ -8,12 +14,13 @@
     Mock, ANY, patch, PropertyMock
 )
 from mock.mock import _Call, _CallList, _callable
-from mock import IS_PYPY
 
 from datetime import datetime
 from functools import partial
 
-import pytest
+
+if six.PY2:
+    import funcsigs
 
 
 class SomeClass(object):
@@ -22,6 +29,7 @@
     def three(self, a=None): pass
 
 
+
 class AnyTest(unittest.TestCase):
 
     def test_any(self):
@@ -68,28 +76,7 @@
             self.assertEqual(expected, mock.mock_calls)
             self.assertEqual(mock.mock_calls, expected)
 
-    def test_any_no_spec(self):
-        # This is a regression test for bpo-37555
-        class Foo:
-            def __eq__(self, other): pass
 
-        mock = Mock()
-        mock(Foo(), 1)
-        mock.assert_has_calls([call(ANY, 1)])
-        mock.assert_called_with(ANY, 1)
-        mock.assert_any_call(ANY, 1)
-
-    def test_any_and_spec_set(self):
-        # This is a regression test for bpo-37555
-        class Foo:
-            def __eq__(self, other): pass
-
-        mock = Mock(spec=Foo)
-
-        mock(Foo(), 1)
-        mock.assert_has_calls([call(ANY, 1)])
-        mock.assert_called_with(ANY, 1)
-        mock.assert_any_call(ANY, 1)
 
 class CallTest(unittest.TestCase):
 
@@ -359,26 +346,6 @@
         self.assertEqual(_Call((('bar', 'barz'),),)[0], '')
         self.assertEqual(_Call((('bar', 'barz'), {'hello': 'world'}),)[0], '')
 
-    def test_dunder_call(self):
-        m = MagicMock()
-        m().foo()['bar']()
-        self.assertEqual(
-            m.mock_calls,
-            [call(), call().foo(), call().foo().__getitem__('bar'), call().foo().__getitem__()()]
-        )
-        m = MagicMock()
-        m().foo()['bar'] = 1
-        self.assertEqual(
-            m.mock_calls,
-            [call(), call().foo(), call().foo().__setitem__('bar', 1)]
-        )
-        m = MagicMock()
-        iter(m().foo())
-        self.assertEqual(
-            m.mock_calls,
-            [call(), call().foo(), call().foo().__iter__()]
-        )
-
 
 class SpecSignatureTest(unittest.TestCase):
 
@@ -451,9 +418,12 @@
         m = create_autospec(Foo, a='3')
         self.assertEqual(m.a, '3')
 
-
+    @unittest.skipUnless(six.PY3, "Keyword only arguments Python 3 specific")
     def test_create_autospec_keyword_only_arguments(self):
-        def foo(a, *, b=None): pass
+        func_def = "def foo(a, *, b=None): pass\n"
+        namespace = {}
+        exec (func_def, namespace)
+        foo = namespace['foo']
 
         m = create_autospec(foo)
         m(1)
@@ -463,7 +433,6 @@
         m(2, b=3)
         m.assert_called_with(2, b=3)
 
-
     def test_function_as_instance_attribute(self):
         obj = SomeClass()
         def f(a): pass
@@ -502,16 +471,16 @@
             self._check_someclass_mock(mock)
 
 
+    @unittest.skipIf('PyPy' in sys.version,
+                     "This fails on pypy, "
+                     "see https://github.com/testing-cabal/mock/issues/452")
     def test_spec_has_descriptor_returning_function(self):
-
         class CrazyDescriptor(object):
-
             def __get__(self, obj, type_):
                 if obj is None:
                     return lambda x: None
 
         class MyClass(object):
-
             some_attr = CrazyDescriptor()
 
         mock = create_autospec(MyClass)
@@ -521,13 +490,11 @@
         with self.assertRaises(TypeError):
             mock.some_attr(1, 2)
 
-
+    @unittest.skipIf(six.PY2, "object.__dir__ doesn't exist in Python 2")
     def test_spec_has_function_not_in_bases(self):
-
         class CrazyClass(object):
-
             def __dir__(self):
-                return super(CrazyClass, self).__dir__()+['crazy']
+                return super(CrazyClass, self).__dir__() + ['crazy']
 
             def __getattr__(self, item):
                 if item == 'crazy':
@@ -538,7 +505,6 @@
         with self.assertRaises(AttributeError):
             inst.other
         self.assertEqual(inst.crazy(42), 42)
-
         mock = create_autospec(inst)
         mock.crazy(42)
         with self.assertRaises(TypeError):
@@ -547,6 +513,8 @@
             mock.crazy(1, 2)
 
 
+    @unittest.skipIf('PyPy' in sys.version and sys.version_info < (3, 0),
+                     "Fails on pypy2 due to incorrect signature for dict.pop from funcsigs")
     def test_builtin_functions_types(self):
         # we could replace builtin functions / methods with a function
         # with *args / **kwargs signature. Using the builtin method type
@@ -643,6 +611,27 @@
             mock.g.assert_called_once_with(3, 4)
 
 
+    @unittest.skipIf(six.PY3, "No old style classes in Python 3")
+    def test_old_style_classes(self):
+        class Foo:
+            def f(self, a, b): pass
+
+        class Bar(Foo):
+            g = Foo()
+
+        for spec in (Foo, Foo(), Bar, Bar()):
+            mock = create_autospec(spec)
+            mock.f(1, 2)
+            mock.f.assert_called_once_with(1, 2)
+
+            self.assertRaises(AttributeError, getattr, mock, 'foo')
+            self.assertRaises(AttributeError, getattr, mock.f, 'foo')
+
+        mock.g.f(1, 2)
+        mock.g.f.assert_called_once_with(1, 2)
+        self.assertRaises(AttributeError, getattr, mock.g, 'foo')
+
+
     def test_recursive(self):
         class A(object):
             def a(self): pass
@@ -799,6 +788,21 @@
         self.assertRaises(TypeError, mock)
         mock(1)
         mock.assert_called_once_with(1)
+
+        mock(4, 5)
+        mock.assert_called_with(4, 5)
+
+
+    @unittest.skipIf(six.PY3, 'no old style classes in Python 3')
+    def test_signature_old_style_class(self):
+        class Foo:
+            def __init__(self, a, b=3): pass
+
+        mock = create_autospec(Foo)
+
+        self.assertRaises(TypeError, mock)
+        mock(1)
+        mock.assert_called_once_with(1)
         mock.assert_called_once_with(a=1)
         self.assertRaises(AssertionError, mock.assert_called_once_with, 2)
 
@@ -816,6 +820,15 @@
         create_autospec(Foo)
 
 
+    @unittest.skipIf(six.PY3, 'no old style classes in Python 3')
+    def test_old_style_class_with_no_init(self):
+        # this used to raise an exception
+        # due to Foo.__init__ raising an AttributeError
+        class Foo:
+            pass
+        create_autospec(Foo)
+
+
     def test_signature_callable(self):
         class Callable(object):
             def __init__(self, x, y): pass
@@ -886,6 +899,36 @@
         a.f.assert_called_with(self=10)
 
 
+    def test_autospec_property(self):
+        class Foo(object):
+            @property
+            def foo(self): pass
+
+        foo = create_autospec(Foo)
+        mock_property = foo.foo
+
+        # no spec on properties
+        self.assertIsInstance(mock_property, MagicMock)
+        mock_property(1, 2, 3)
+        mock_property.abc(4, 5, 6)
+        mock_property.assert_called_once_with(1, 2, 3)
+        mock_property.abc.assert_called_once_with(4, 5, 6)
+
+
+    def test_autospec_slots(self):
+        class Foo(object):
+            __slots__ = ['a']
+
+        foo = create_autospec(Foo)
+        mock_slot = foo.a
+
+        # no spec on slots
+        mock_slot(1, 2, 3)
+        mock_slot.abc(4, 5, 6)
+        mock_slot.assert_called_once_with(1, 2, 3)
+        mock_slot.abc.assert_called_once_with(4, 5, 6)
+
+
     def test_autospec_data_descriptor(self):
         class Descriptor(object):
             def __init__(self, value):
@@ -930,8 +973,10 @@
         check_data_descriptor(foo.desc)
 
 
+    @unittest.skipIf('PyPy' in sys.version and sys.version_info > (3, 0),
+                     "See https://github.com/testing-cabal/mock/issues/452")
     def test_autospec_on_bound_builtin_function(self):
-        meth = types.MethodType(time.ctime, time.time())
+        meth = six.create_bound_method(time.ctime, time.time())
         self.assertIsInstance(meth(), str)
         mocked = create_autospec(meth)
 
@@ -939,23 +984,20 @@
         mocked()
         mocked.assert_called_once_with()
         mocked.reset_mock()
-        # but pypy gets this right:
-        if IS_PYPY:
-            with self.assertRaises(TypeError):
-                mocked(4, 5, 6)
-        else:
-            mocked(4, 5, 6)
-            mocked.assert_called_once_with(4, 5, 6)
+        mocked(4, 5, 6)
+        mocked.assert_called_once_with(4, 5, 6)
+
+    def test_autospec_socket(self):
+        sock_class = create_autospec(socket.socket)
+        self.assertRaises(TypeError, sock_class, foo=1)
 
 
     def test_autospec_getattr_partial_function(self):
         # bpo-32153 : getattr returning partial functions without
         # __name__ should not create AttributeError in create_autospec
-        class Foo:
-
+        class Foo(object):
             def __getattr__(self, attribute):
                 return partial(lambda name: name, attribute)
-
         proxy = Foo()
         autospec = create_autospec(proxy)
         self.assertFalse(hasattr(autospec, '__name__'))
@@ -969,33 +1011,28 @@
         mock(1, 2)
         mock(x=1, y=2)
 
-        self.assertEqual(inspect.signature(mock), inspect.signature(myfunc))
+        if six.PY2:
+            self.assertEqual(funcsigs.signature(mock), funcsigs.signature(myfunc))
+        else:
+            self.assertEqual(inspect.getfullargspec(mock), inspect.getfullargspec(myfunc))
         self.assertEqual(mock.mock_calls, [call(1, 2), call(x=1, y=2)])
         self.assertRaises(TypeError, mock, 1)
 
 
-    def test_spec_inspect_signature_annotations(self):
-
-        def foo(a: int, b: int=10, *, c:int) -> int:
-            return a + b + c
-
-        self.assertEqual(foo(1, 2 , c=3), 6)
-        mock = create_autospec(foo)
-        mock(1, 2, c=3)
-        mock(1, c=3)
-
-        self.assertEqual(inspect.signature(mock), inspect.signature(foo))
-        self.assertEqual(mock.mock_calls, [call(1, 2, c=3), call(1, c=3)])
-        self.assertRaises(TypeError, mock, 1)
-        self.assertRaises(TypeError, mock, 1, 2, 3, c=4)
-
-
     def test_spec_function_no_name(self):
         func = lambda: 'nope'
         mock = create_autospec(func)
         self.assertEqual(mock.__name__, 'funcopy')
 
 
+    @unittest.skipIf(six.PY3, "Here to test our Py2 _isidentifier")
+    def test_spec_function_has_identifier_name(self):
+        func = lambda: 'nope'
+        func.__name__ = 'global'
+        mock = create_autospec(func)
+        self.assertEqual(mock.__name__, 'funcopy')
+
+
     def test_spec_function_assert_has_calls(self):
         def f(a): pass
         mock = create_autospec(f)
@@ -1068,6 +1105,20 @@
         self.assertEqual(str(mock.mock_calls), expected)
 
 
+    @unittest.skipIf(six.PY3, "Unicode is properly handled with Python 3")
+    def test_call_list_unicode(self):
+        # See github issue #328
+        mock = Mock()
+
+        class NonAsciiRepr(object):
+            def __repr__(self):
+                return "\xe9"
+
+        mock(**{unicode("a"): NonAsciiRepr()})
+
+        self.assertEqual(str(mock.mock_calls), "[call(a=\xe9)]")
+
+
     def test_propertymock(self):
         p = patch('%s.SomeClass.one' % __name__, new_callable=PropertyMock)
         mock = p.start()
diff --git a/mock/tests/testhelpers_py3.py b/mock/tests/testhelpers_py3.py
new file mode 100644
index 0000000..64d62f8
--- /dev/null
+++ b/mock/tests/testhelpers_py3.py
@@ -0,0 +1,23 @@
+import inspect
+import unittest
+
+from mock import call, create_autospec
+
+
+class CallTest(unittest.TestCase):
+
+
+    def test_spec_inspect_signature_annotations(self):
+
+        def foo(a: int, b: int=10, *, c:int) -> int:
+            return a + b + c
+
+        self.assertEqual(foo(1, 2, c=3), 6)
+        mock = create_autospec(foo)
+        mock(1, 2, c=3)
+        mock(1, c=3)
+
+        self.assertEqual(inspect.getfullargspec(mock), inspect.getfullargspec(foo))
+        self.assertEqual(mock.mock_calls, [call(1, 2, c=3), call(1, c=3)])
+        self.assertRaises(TypeError, mock, 1)
+        self.assertRaises(TypeError, mock, 1, 2, 3, c=4)
diff --git a/mock/tests/testmagicmethods.py b/mock/tests/testmagicmethods.py
index e1f1ee0..f6c25fb 100644
--- a/mock/tests/testmagicmethods.py
+++ b/mock/tests/testmagicmethods.py
@@ -1,11 +1,29 @@
+# Copyright (C) 2007-2012 Michael Foord & the mock team
+# E-mail: fuzzyman AT voidspace DOT org DOT uk
+# http://www.voidspace.org.uk/python/mock/
+
+from __future__ import division
+
+try:
+    unicode
+except NameError:
+    # Python 3
+    unicode = str
+    long = int
+
 import math
-import unittest
 import os
-from mock import AsyncMock, Mock, MagicMock
-from mock.backports import iscoroutinefunction
+import sys
+import textwrap
+import unittest
+
+import six
+
+from mock import Mock, MagicMock
 from mock.mock import _magics
 
 
+
 class TestMockingMagicMethods(unittest.TestCase):
 
     def test_deleting_magic_methods(self):
@@ -69,6 +87,15 @@
         self.assertEqual(str(mock), 'foo')
 
 
+    @unittest.skipIf(six.PY3, "no unicode in Python 3")
+    def test_unicode(self):
+        mock = Mock()
+        self.assertEqual(unicode(mock), unicode(str(mock)))
+
+        mock.__unicode__ = lambda s: unicode('foo')
+        self.assertEqual(unicode(mock), unicode('foo'))
+
+
     def test_dict_methods(self):
         mock = Mock()
 
@@ -140,13 +167,16 @@
         self.assertEqual(mock.value, 16)
 
         del mock.__truediv__
-        def itruediv(mock):
-            mock /= 4
-        self.assertRaises(TypeError, itruediv, mock)
-        mock.__itruediv__ = truediv
-        mock /= 8
-        self.assertEqual(mock, original)
-        self.assertEqual(mock.value, 2)
+        if six.PY3:
+            def itruediv(mock):
+                mock /= 4
+            self.assertRaises(TypeError, itruediv, mock)
+            mock.__itruediv__ = truediv
+            mock /= 8
+            self.assertEqual(mock, original)
+            self.assertEqual(mock.value, 2)
+        else:
+            mock.value = 2
 
         self.assertRaises(TypeError, lambda: 8 / mock)
         mock.__rtruediv__ = truediv
@@ -168,7 +198,12 @@
         m = Mock()
         self.assertTrue(bool(m))
 
-        m.__bool__ = lambda s: False
+        nonzero = lambda s: False
+        if six.PY2:
+            m.__nonzero__ = nonzero
+        else:
+            m.__bool__ = nonzero
+
         self.assertFalse(bool(m))
 
 
@@ -182,18 +217,25 @@
         self. assertTrue(mock <= 3)
         self. assertTrue(mock >= 3)
 
-        self.assertRaises(TypeError, lambda: MagicMock() < object())
-        self.assertRaises(TypeError, lambda: object() < MagicMock())
-        self.assertRaises(TypeError, lambda: MagicMock() < MagicMock())
-        self.assertRaises(TypeError, lambda: MagicMock() > object())
-        self.assertRaises(TypeError, lambda: object() > MagicMock())
-        self.assertRaises(TypeError, lambda: MagicMock() > MagicMock())
-        self.assertRaises(TypeError, lambda: MagicMock() <= object())
-        self.assertRaises(TypeError, lambda: object() <= MagicMock())
-        self.assertRaises(TypeError, lambda: MagicMock() <= MagicMock())
-        self.assertRaises(TypeError, lambda: MagicMock() >= object())
-        self.assertRaises(TypeError, lambda: object() >= MagicMock())
-        self.assertRaises(TypeError, lambda: MagicMock() >= MagicMock())
+        if six.PY2:
+            # incomparable in Python 3
+            self.assertEqual(Mock() < 3, object() < 3)
+            self.assertEqual(Mock() > 3, object() > 3)
+            self.assertEqual(Mock() <= 3, object() <= 3)
+            self.assertEqual(Mock() >= 3, object() >= 3)
+        else:
+            self.assertRaises(TypeError, lambda: MagicMock() < object())
+            self.assertRaises(TypeError, lambda: object() < MagicMock())
+            self.assertRaises(TypeError, lambda: MagicMock() < MagicMock())
+            self.assertRaises(TypeError, lambda: MagicMock() > object())
+            self.assertRaises(TypeError, lambda: object() > MagicMock())
+            self.assertRaises(TypeError, lambda: MagicMock() > MagicMock())
+            self.assertRaises(TypeError, lambda: MagicMock() <= object())
+            self.assertRaises(TypeError, lambda: object() <= MagicMock())
+            self.assertRaises(TypeError, lambda: MagicMock() <= MagicMock())
+            self.assertRaises(TypeError, lambda: MagicMock() >= object())
+            self.assertRaises(TypeError, lambda: object() >= MagicMock())
+            self.assertRaises(TypeError, lambda: MagicMock() >= MagicMock())
 
 
     def test_equality(self):
@@ -251,8 +293,12 @@
         mock.__iter__.return_value = iter([1, 2, 3])
         self.assertEqual(list(mock), [1, 2, 3])
 
-        getattr(mock, '__bool__').return_value = False
-        self.assertFalse(hasattr(mock, '__nonzero__'))
+        name = '__nonzero__'
+        other = '__bool__'
+        if six.PY3:
+            name, other = other, name
+        getattr(mock, name).return_value = False
+        self.assertFalse(hasattr(mock, other))
         self.assertFalse(bool(mock))
 
         for entry in _magics:
@@ -270,66 +316,61 @@
         self.assertEqual(mock == mock, True)
         self.assertEqual(mock != mock, False)
 
-    def test_asyncmock_defaults(self):
-        mock = AsyncMock()
-        self.assertEqual(int(mock), 1)
-        self.assertEqual(complex(mock), 1j)
-        self.assertEqual(float(mock), 1.0)
-        self.assertNotIn(object(), mock)
-        self.assertEqual(len(mock), 0)
-        self.assertEqual(list(mock), [])
-        self.assertEqual(hash(mock), object.__hash__(mock))
-        self.assertEqual(str(mock), object.__str__(mock))
-        self.assertTrue(bool(mock))
-        self.assertEqual(round(mock), mock.__round__())
-        self.assertEqual(math.trunc(mock), mock.__trunc__())
-        self.assertEqual(math.floor(mock), mock.__floor__())
-        self.assertEqual(math.ceil(mock), mock.__ceil__())
-        self.assertTrue(iscoroutinefunction(mock.__aexit__))
-        self.assertTrue(iscoroutinefunction(mock.__aenter__))
-        self.assertIsInstance(mock.__aenter__, AsyncMock)
-        self.assertIsInstance(mock.__aexit__, AsyncMock)
-
-        # in Python 3 oct and hex use __index__
-        # so these tests are for __index__ in py3k
-        self.assertEqual(oct(mock), '0o1')
-        self.assertEqual(hex(mock), '0x1')
-        # how to test __sizeof__ ?
 
     def test_magicmock_defaults(self):
         mock = MagicMock()
         self.assertEqual(int(mock), 1)
         self.assertEqual(complex(mock), 1j)
         self.assertEqual(float(mock), 1.0)
+        self.assertEqual(long(mock), long(1))
         self.assertNotIn(object(), mock)
         self.assertEqual(len(mock), 0)
         self.assertEqual(list(mock), [])
         self.assertEqual(hash(mock), object.__hash__(mock))
         self.assertEqual(str(mock), object.__str__(mock))
+        self.assertEqual(unicode(mock), object.__str__(mock))
+        self.assertIsInstance(unicode(mock), unicode)
         self.assertTrue(bool(mock))
-        self.assertEqual(round(mock), mock.__round__())
         self.assertEqual(math.trunc(mock), mock.__trunc__())
-        self.assertEqual(math.floor(mock), mock.__floor__())
-        self.assertEqual(math.ceil(mock), mock.__ceil__())
-        self.assertTrue(iscoroutinefunction(mock.__aexit__))
-        self.assertTrue(iscoroutinefunction(mock.__aenter__))
-        self.assertIsInstance(mock.__aenter__, AsyncMock)
-        self.assertIsInstance(mock.__aexit__, AsyncMock)
-
-        # in Python 3 oct and hex use __index__
-        # so these tests are for __index__ in py3k
-        self.assertEqual(oct(mock), '0o1')
+        if six.PY2:
+            # These fall back to __float__ in Python 2:
+            self.assertEqual(round(mock), 1.0)
+            self.assertEqual(math.floor(mock), 1.0)
+            self.assertEqual(math.ceil(mock), 1.0)
+        else:
+            self.assertEqual(round(mock), mock.__round__())
+            self.assertEqual(math.floor(mock), mock.__floor__())
+            self.assertEqual(math.ceil(mock), mock.__ceil__())
+        if six.PY2:
+            self.assertEqual(oct(mock), '1')
+        else:
+            # in Python 3 oct and hex use __index__
+            # so these tests are for __index__ in py3k
+            self.assertEqual(oct(mock), '0o1')
         self.assertEqual(hex(mock), '0x1')
         # how to test __sizeof__ ?
 
 
+    @unittest.skipIf(six.PY3, "no __cmp__ in Python 3")
+    def test_non_default_magic_methods(self):
+        mock = MagicMock()
+        self.assertRaises(AttributeError, lambda: mock.__cmp__)
+
+        mock = Mock()
+        mock.__cmp__ = lambda s, o: 0
+
+        self.assertEqual(mock, object())
+
+
     def test_magic_methods_fspath(self):
         mock = MagicMock()
-        expected_path = mock.__fspath__()
-        mock.reset_mock()
-
-        self.assertEqual(os.fspath(mock), expected_path)
-        mock.__fspath__.assert_called_once()
+        if sys.version_info < (3, 6):
+            self.assertRaises(AttributeError, lambda: mock.__fspath__)
+        else:
+            expected_path = mock.__fspath__()
+            mock.reset_mock()
+            self.assertEqual(os.fspath(mock), expected_path)
+            mock.__fspath__.assert_called_once()
 
 
     def test_magic_methods_and_spec(self):
@@ -384,7 +425,7 @@
         mock = MagicMock()
         def set_setattr():
             mock.__setattr__ = lambda self, name: None
-        self.assertRaisesRegex(AttributeError,
+        self.assertRaisesRegexp(AttributeError,
             "Attempting to set unsupported magic method '__setattr__'.",
             set_setattr
         )
@@ -418,7 +459,6 @@
         mock.reset_mock()
         self.assertFalse(mock.__str__.called)
 
-
     def test_dir(self):
         # overriding the default implementation
         for mock in Mock(), MagicMock():
@@ -428,6 +468,7 @@
             self.assertEqual(dir(mock), ['foo'])
 
 
+    @unittest.skipIf('PyPy' in sys.version, "This fails differently on pypy")
     def test_bound_methods(self):
         m = Mock()
 
@@ -463,17 +504,20 @@
         self.assertEqual(list(m), [4, 5, 6])
         self.assertEqual(list(m), [])
 
-
+    @unittest.skipIf(sys.version_info < (3, 5), "@ added in Python 3.5")
     def test_matmul(self):
-        m = MagicMock()
-        self.assertIsInstance(m @ 1, MagicMock)
-        m.__matmul__.return_value = 42
-        m.__rmatmul__.return_value = 666
-        m.__imatmul__.return_value = 24
-        self.assertEqual(m @ 1, 42)
-        self.assertEqual(1 @ m, 666)
-        m @= 24
-        self.assertEqual(m, 24)
+        src = textwrap.dedent("""\
+            m = MagicMock()
+            self.assertIsInstance(m @ 1, MagicMock)
+            m.__matmul__.return_value = 42
+            m.__rmatmul__.return_value = 666
+            m.__imatmul__.return_value = 24
+            self.assertEqual(m @ 1, 42)
+            self.assertEqual(1 @ m, 666)
+            m @= 24
+            self.assertEqual(m, 24)
+        """)
+        exec(src)
 
     def test_divmod_and_rdivmod(self):
         m = MagicMock()
diff --git a/mock/tests/testmock.py b/mock/tests/testmock.py
index 8bb8759..5f6045a 100644
--- a/mock/tests/testmock.py
+++ b/mock/tests/testmock.py
@@ -1,18 +1,30 @@
+# Copyright (C) 2007-2012 Michael Foord & the mock team
+# E-mail: fuzzyman AT voidspace DOT org DOT uk
+# http://www.voidspace.org.uk/python/mock/
+
 import copy
+import pickle
 import re
 import sys
 import tempfile
 
+import six
 import unittest
-from mock.tests.support import ALWAYS_EQ
-from mock.tests.support import is_instance
-from mock import (
+
+import mock
+from mock.mock import (
     call, DEFAULT, patch, sentinel,
     MagicMock, Mock, NonCallableMock,
-    NonCallableMagicMock, AsyncMock,
-    create_autospec, mock
+    NonCallableMagicMock, _Call, _CallList,
+    create_autospec
 )
-from mock.mock import _Call, _CallList
+from mock.tests.support import is_instance
+
+
+try:
+    unicode
+except NameError:
+    unicode = str
 
 
 class Iter(object):
@@ -38,7 +50,14 @@
     def smeth(a, b, c, d=None): pass
 
 
-def something(a): pass
+class Subclass(MagicMock):
+    pass
+
+
+class Thing(object):
+    attribute = 6
+    foo = 'bar'
+
 
 
 class MockTest(unittest.TestCase):
@@ -47,7 +66,7 @@
         # if __all__ is badly defined then import * will raise an error
         # We have to exec it because you can't import * inside a method
         # in Python 3
-        exec("from unittest.mock import *")
+        exec("from mock import *")
 
 
     def test_constructor(self):
@@ -196,8 +215,7 @@
 
         mock = create_autospec(f)
         mock.side_effect = ValueError('Bazinga!')
-        self.assertRaisesRegex(ValueError, 'Bazinga!', mock)
-
+        self.assertRaisesRegexp(ValueError, 'Bazinga!', mock)
 
     def test_reset_mock(self):
         parent = Mock()
@@ -263,7 +281,7 @@
 
         ret_val = mock(sentinel.Arg)
         self.assertTrue(mock.called, "called not set")
-        self.assertEqual(mock.call_count, 1, "call_count incorrect")
+        self.assertEqual(mock.call_count, 1, "call_count incoreect")
         self.assertEqual(mock.call_args, ((sentinel.Arg,), {}),
                          "call_args not set")
         self.assertEqual(mock.call_args.args, (sentinel.Arg,),
@@ -323,8 +341,6 @@
         self.assertFalse(mm != mock.ANY)
         self.assertTrue(mock.ANY == mm)
         self.assertFalse(mock.ANY != mm)
-        self.assertTrue(mm == ALWAYS_EQ)
-        self.assertFalse(mm != ALWAYS_EQ)
 
         call1 = mock.call(mock.MagicMock())
         call2 = mock.call(mock.ANY)
@@ -333,11 +349,6 @@
         self.assertTrue(call2 == call1)
         self.assertFalse(call2 != call1)
 
-        self.assertTrue(call1 == ALWAYS_EQ)
-        self.assertFalse(call1 != ALWAYS_EQ)
-        self.assertFalse(call1 == 1)
-        self.assertTrue(call1 != 1)
-
 
     def test_assert_called_with(self):
         mock = Mock()
@@ -373,7 +384,8 @@
         # Expected call doesn't match the spec's signature
         with self.assertRaises(AssertionError) as cm:
             mock.assert_called_with(e=8)
-        self.assertIsInstance(cm.exception.__cause__, TypeError)
+        if hasattr(cm.exception, '__cause__'):
+            self.assertIsInstance(cm.exception.__cause__, TypeError)
 
 
     def test_assert_called_with_method_spec(self):
@@ -396,14 +408,6 @@
         _check(mock)
 
 
-    def test_assert_called_exception_message(self):
-        msg = "Expected '{0}' to have been called"
-        with self.assertRaisesRegex(AssertionError, msg.format('mock')):
-            Mock().assert_called()
-        with self.assertRaisesRegex(AssertionError, msg.format('test_name')):
-            Mock(name="test_name").assert_called()
-
-
     def test_assert_called_once_with(self):
         mock = Mock()
         mock()
@@ -431,7 +435,7 @@
         m = Mock()
         m(1)
         m(2)
-        self.assertRaisesRegex(AssertionError,
+        self.assertRaisesRegexp(AssertionError,
             re.escape("Calls: [call(1), call(2)]"),
             lambda: m.assert_called_once_with(2))
 
@@ -449,7 +453,8 @@
         # Expected call doesn't match the spec's signature
         with self.assertRaises(AssertionError) as cm:
             mock.assert_called_once_with(e=8)
-        self.assertIsInstance(cm.exception.__cause__, TypeError)
+        if hasattr(cm.exception, '__cause__'):
+            self.assertIsInstance(cm.exception.__cause__, TypeError)
         # Mock called more than once => always fails
         mock(4, 5, 6)
         self.assertRaises(AssertionError, mock.assert_called_once_with,
@@ -530,7 +535,7 @@
 
                 # this should be allowed
                 mock.something
-                self.assertRaisesRegex(
+                self.assertRaisesRegexp(
                     AttributeError,
                     "Mock object has no attribute 'something_else'",
                     getattr, mock, 'something_else'
@@ -548,12 +553,12 @@
             mock.x
             mock.y
             mock.__something__
-            self.assertRaisesRegex(
+            self.assertRaisesRegexp(
                 AttributeError,
                 "Mock object has no attribute 'z'",
                 getattr, mock, 'z'
             )
-            self.assertRaisesRegex(
+            self.assertRaisesRegexp(
                 AttributeError,
                 "Mock object has no attribute '__foobar__'",
                 getattr, mock, '__foobar__'
@@ -715,53 +720,6 @@
         self.assertRaises(StopIteration, mock.method)
 
 
-    def test_magic_method_wraps_dict(self):
-        data = {'foo': 'bar'}
-
-        wrapped_dict = MagicMock(wraps=data)
-        self.assertEqual(wrapped_dict.get('foo'), 'bar')
-        self.assertEqual(wrapped_dict['foo'], 'bar')
-        self.assertTrue('foo' in wrapped_dict)
-
-        # return_value is non-sentinel and takes precedence over wrapped value.
-        wrapped_dict.get.return_value = 'return_value'
-        self.assertEqual(wrapped_dict.get('foo'), 'return_value')
-
-        # return_value is sentinel and hence wrapped value is returned.
-        wrapped_dict.get.return_value = sentinel.DEFAULT
-        self.assertEqual(wrapped_dict.get('foo'), 'bar')
-
-        self.assertEqual(wrapped_dict.get('baz'), None)
-        with self.assertRaises(KeyError):
-            wrapped_dict['baz']
-        self.assertFalse('bar' in wrapped_dict)
-
-        data['baz'] = 'spam'
-        self.assertEqual(wrapped_dict.get('baz'), 'spam')
-        self.assertEqual(wrapped_dict['baz'], 'spam')
-        self.assertTrue('baz' in wrapped_dict)
-
-        del data['baz']
-        self.assertEqual(wrapped_dict.get('baz'), None)
-
-
-    def test_magic_method_wraps_class(self):
-
-        class Foo:
-
-            def __getitem__(self, index):
-                return index
-
-            def __custom_method__(self):
-                return "foo"
-
-
-        klass = MagicMock(wraps=Foo)
-        obj = klass()
-        self.assertEqual(obj.__getitem__(2), 2)
-        self.assertEqual(obj.__custom_method__(), "foo")
-
-
     def test_exceptional_side_effect(self):
         mock = Mock(side_effect=AttributeError)
         self.assertRaises(AttributeError, mock)
@@ -780,13 +738,13 @@
 
     def test_assert_called_with_message(self):
         mock = Mock()
-        self.assertRaisesRegex(AssertionError, 'not called',
+        self.assertRaisesRegexp(AssertionError, 'not called',
                                 mock.assert_called_with)
 
 
     def test_assert_called_once_with_message(self):
         mock = Mock(name='geoffrey')
-        self.assertRaisesRegex(AssertionError,
+        self.assertRaisesRegexp(AssertionError,
                      r"Expected 'geoffrey' to be called once\.",
                      mock.assert_called_once_with)
 
@@ -836,8 +794,10 @@
         mock = Mock(spec=X)
         self.assertIsInstance(mock, X)
 
-        mock = Mock(spec=X())
-        self.assertIsInstance(mock, X)
+        if not six.PY2:
+            # This isn't true on Py2, we should fix if anyone complains:
+            mock = Mock(spec=X())
+            self.assertIsInstance(mock, X)
 
         self.assertIs(mock.__class__, X)
         self.assertEqual(Mock().__class__.__name__, 'Mock')
@@ -845,8 +805,10 @@
         mock = Mock(spec_set=X)
         self.assertIsInstance(mock, X)
 
-        mock = Mock(spec_set=X())
-        self.assertIsInstance(mock, X)
+        if not six.PY2:
+        # This isn't true on Py2, we should fix if anyone complains:
+            mock = Mock(spec_set=X())
+            self.assertIsInstance(mock, X)
 
 
     def test_setting_attribute_with_spec_set(self):
@@ -874,6 +836,42 @@
         copy.copy(Mock())
 
 
+    @unittest.skipIf(six.PY3, "no old style classes in Python 3")
+    def test_spec_old_style_classes(self):
+        class Foo:
+            bar = 7
+
+        mock = Mock(spec=Foo)
+        mock.bar = 6
+        self.assertRaises(AttributeError, lambda: mock.foo)
+
+        mock = Mock(spec=Foo())
+        mock.bar = 6
+        self.assertRaises(AttributeError, lambda: mock.foo)
+
+
+    @unittest.skipIf(six.PY3, "no old style classes in Python 3")
+    def test_spec_set_old_style_classes(self):
+        class Foo:
+            bar = 7
+
+        mock = Mock(spec_set=Foo)
+        mock.bar = 6
+        self.assertRaises(AttributeError, lambda: mock.foo)
+
+        def _set():
+            mock.foo = 3
+        self.assertRaises(AttributeError, _set)
+
+        mock = Mock(spec_set=Foo())
+        mock.bar = 6
+        self.assertRaises(AttributeError, lambda: mock.foo)
+
+        def _set():
+            mock.foo = 3
+        self.assertRaises(AttributeError, _set)
+
+
     def test_subclass_with_properties(self):
         class SubClass(Mock):
             def _get(self):
@@ -897,7 +895,6 @@
     def test_setting_call(self):
         mock = Mock()
         def __call__(self, a):
-            self._increment_mock_call(a)
             return self._mock_call(a)
 
         type(mock).__call__ = __call__
@@ -910,7 +907,7 @@
     def test_dir(self):
         mock = Mock()
         attrs = set(dir(mock))
-        type_attrs = set([m for m in dir(Mock) if not m.startswith('_')])
+        type_attrs = {m for m in dir(Mock) if not m.startswith('_')}
 
         # all public attributes from the type are included
         self.assertEqual(set(), type_attrs - attrs)
@@ -1183,7 +1180,7 @@
         m = Mock()
         m.foo = m
         repr(m.foo())
-        self.assertRegex(repr(m.foo()), r"<Mock name='mock\(\)' id='\d+'>")
+        self.assertRegexpMatches(repr(m.foo()), r"<Mock name='mock\(\)' id='\d+'>")
 
 
     def test_mock_calls_contains(self):
@@ -1283,16 +1280,6 @@
         self.assertRaises(StopIteration, mock)
 
 
-    def test_side_effect_iterator_exceptions(self):
-        for Klass in Mock, MagicMock:
-            iterable = (ValueError, 3, KeyError, 6)
-            m = Klass(side_effect=iterable)
-            self.assertRaises(ValueError, m)
-            self.assertEqual(m(), 3)
-            self.assertRaises(KeyError, m)
-            self.assertEqual(m(), 6)
-
-
     def test_side_effect_setting_iterator(self):
         mock = Mock()
         mock.side_effect = iter([1, 2, 3])
@@ -1314,6 +1301,17 @@
         self.assertRaises(StopIteration, mock)
         self.assertIs(mock.side_effect, this_iter)
 
+
+    def test_side_effect_iterator_exceptions(self):
+        for Klass in Mock, MagicMock:
+            iterable = (ValueError, 3, KeyError, 6)
+            m = Klass(side_effect=iterable)
+            self.assertRaises(ValueError, m)
+            self.assertEqual(m(), 3)
+            self.assertRaises(KeyError, m)
+            self.assertEqual(m(), 6)
+
+
     def test_side_effect_iterator_default(self):
         mock = Mock(return_value=2)
         mock.side_effect = iter([1, DEFAULT])
@@ -1403,54 +1401,6 @@
                         )
 
 
-    def test_assert_has_calls_nested_spec(self):
-        class Something:
-
-            def __init__(self): pass
-            def meth(self, a, b, c, d=None): pass
-
-            class Foo:
-
-                def __init__(self, a): pass
-                def meth1(self, a, b): pass
-
-        mock_class = create_autospec(Something)
-
-        for m in [mock_class, mock_class()]:
-            m.meth(1, 2, 3, d=1)
-            m.assert_has_calls([call.meth(1, 2, 3, d=1)])
-            m.assert_has_calls([call.meth(1, 2, 3, 1)])
-
-        mock_class.reset_mock()
-
-        for m in [mock_class, mock_class()]:
-            self.assertRaises(AssertionError, m.assert_has_calls, [call.Foo()])
-            m.Foo(1).meth1(1, 2)
-            m.assert_has_calls([call.Foo(1), call.Foo(1).meth1(1, 2)])
-            m.Foo.assert_has_calls([call(1), call().meth1(1, 2)])
-
-        mock_class.reset_mock()
-
-        invalid_calls = [call.meth(1),
-                         call.non_existent(1),
-                         call.Foo().non_existent(1),
-                         call.Foo().meth(1, 2, 3, 4)]
-
-        for kall in invalid_calls:
-            self.assertRaises(AssertionError,
-                              mock_class.assert_has_calls,
-                              [kall]
-            )
-
-
-    def test_assert_has_calls_nested_without_spec(self):
-        m = MagicMock()
-        m().foo().bar().baz()
-        m.one().two().three()
-        calls = call.one().two().three().call_list()
-        m.assert_has_calls(calls)
-
-
     def test_assert_has_calls_with_function_spec(self):
         def f(a, b, c, d=None): pass
 
@@ -1482,34 +1432,6 @@
             mock.assert_has_calls(calls[:-1])
         mock.assert_has_calls(calls[:-1], any_order=True)
 
-    def test_assert_has_calls_not_matching_spec_error(self):
-        def f(x=None): pass
-
-        mock = Mock(spec=f)
-        mock(1)
-
-        with self.assertRaisesRegex(
-                AssertionError,
-                '^{}$'.format(
-                    re.escape('Calls not found.\n'
-                              'Expected: [call()]\n'
-                              'Actual: [call(1)]'))) as cm:
-            mock.assert_has_calls([call()])
-        self.assertIsNone(cm.exception.__cause__)
-
-
-        with self.assertRaisesRegex(
-                AssertionError,
-                '^{}$'.format(
-                    re.escape(
-                        'Error processing expected calls.\n'
-                        "Errors: [None, TypeError('too many positional arguments')]\n"
-                        "Expected: [call(), call(1, 2)]\n"
-                        'Actual: [call(1)]').replace(
-                            "arguments\\'", "arguments\\',?"
-                    ))) as cm:
-            mock.assert_has_calls([call(), call(1, 2)])
-        self.assertIsInstance(cm.exception.__cause__, TypeError)
 
     def test_assert_any_call(self):
         mock = Mock()
@@ -1553,7 +1475,8 @@
         # Expected call doesn't match the spec's signature
         with self.assertRaises(AssertionError) as cm:
             mock.assert_any_call(e=8)
-        self.assertIsInstance(cm.exception.__cause__, TypeError)
+        if hasattr(cm.exception, '__cause__'):
+            self.assertIsInstance(cm.exception.__cause__, TypeError)
 
 
     def test_mock_calls_create_autospec(self):
@@ -1587,7 +1510,6 @@
             @staticmethod
             def static_method(): pass
         for method in ('class_method', 'static_method'):
-            with self.subTest(method=method):
                 mock_method = mock.create_autospec(getattr(TestClass, method))
                 mock_method()
                 mock_method.assert_called_once_with()
@@ -1596,10 +1518,9 @@
     #Issue21238
     def test_mock_unsafe(self):
         m = Mock()
-        msg = "Attributes cannot start with 'assert' or 'assret'"
-        with self.assertRaisesRegex(AttributeError, msg):
+        with self.assertRaises(AttributeError):
             m.assert_foo_call()
-        with self.assertRaisesRegex(AttributeError, msg):
+        with self.assertRaises(AttributeError):
             m.assret_foo_call()
         m = Mock(unsafe=True)
         m.assert_foo_call()
@@ -1616,7 +1537,7 @@
     def test_assert_not_called_message(self):
         m = Mock()
         m(1, 2)
-        self.assertRaisesRegex(AssertionError,
+        self.assertRaisesRegexp(AssertionError,
             re.escape("Calls: [call(1, 2)]"),
             m.assert_not_called)
 
@@ -1645,7 +1566,7 @@
         m = Mock()
         m(1, 2)
         m(3)
-        self.assertRaisesRegex(AssertionError,
+        self.assertRaisesRegexp(AssertionError,
             re.escape("Calls: [call(1, 2), call(3)]"),
             m.assert_called_once)
 
@@ -1655,11 +1576,11 @@
             m.assert_called_once()
         self.assertNotIn("Calls:", str(e.exception))
 
-    #Issue37212 printout of keyword args now preserves the original order
-    def test_ordered_call_signature(self):
+    #Issue21256 printout of keyword args should be in deterministic order
+    def test_sorted_call_signature(self):
         m = Mock()
         m.hello(name='hello', daddy='hero')
-        text = "call(name='hello', daddy='hero')"
+        text = "call(daddy='hero', name='hello')"
         self.assertEqual(repr(m.hello.call_args), text)
 
     #Issue21270 overrides tuple methods for mock.call objects
@@ -1685,23 +1606,11 @@
         self.assertNotEqual(m.side_effect, None)
 
     def test_reset_sideeffect(self):
-        m = Mock(return_value=10, side_effect=[2, 3])
+        m = Mock(return_value=10, side_effect=[2,3])
         m.reset_mock(side_effect=True)
         self.assertEqual(m.return_value, 10)
         self.assertEqual(m.side_effect, None)
 
-    def test_reset_return_with_children(self):
-        m = MagicMock(f=MagicMock(return_value=1))
-        self.assertEqual(m.f(), 1)
-        m.reset_mock(return_value=True)
-        self.assertNotEqual(m.f(), 1)
-
-    def test_reset_return_with_children_side_effect(self):
-        m = MagicMock(f=MagicMock(side_effect=[2, 3]))
-        self.assertNotEqual(m.f.side_effect, None)
-        m.reset_mock(side_effect=True)
-        self.assertEqual(m.f.side_effect, None)
-
     def test_mock_add_spec(self):
         class _One(object):
             one = 1
@@ -1773,8 +1682,7 @@
 
 
     def test_adding_child_mock(self):
-        for Klass in (NonCallableMock, Mock, MagicMock, NonCallableMagicMock,
-                      AsyncMock):
+        for Klass in NonCallableMock, Mock, MagicMock, NonCallableMagicMock:
             mock = Klass()
 
             mock.foo = Mock()
@@ -1857,24 +1765,6 @@
         self.assertEqual(lines[1], 'Norwegian Blue')
         self.assertEqual(list(f1), [])
 
-    def test_mock_open_using_next(self):
-        mocked_open = mock.mock_open(read_data='1st line\n2nd line\n3rd line')
-        f1 = mocked_open('a-name')
-        line1 = next(f1)
-        line2 = f1.__next__()
-        lines = [line for line in f1]
-        self.assertEqual(line1, '1st line\n')
-        self.assertEqual(line2, '2nd line\n')
-        self.assertEqual(lines[0], '3rd line')
-        self.assertEqual(list(f1), [])
-        with self.assertRaises(StopIteration):
-            next(f1)
-
-    def test_mock_open_next_with_readline_with_return_value(self):
-        mopen = mock.mock_open(read_data='foo\nbarn')
-        mopen.return_value.readline.return_value = 'abc'
-        self.assertEqual('abc', next(mopen()))
-
     def test_mock_open_write(self):
         # Test exception in file writing write()
         mock_namedtemp = mock.mock_open(mock.MagicMock(name='JLV'))
@@ -1894,6 +1784,7 @@
         self.assertEqual('abc', first)
         self.assertEqual('abc', second)
 
+
     def test_mock_open_after_eof(self):
         # read, readline and readlines should work after end of file.
         _open = mock.mock_open(read_data='foo')
@@ -1906,6 +1797,7 @@
         self.assertEqual([], h.readlines())
         self.assertEqual([], h.readlines())
 
+
     def test_mock_parents(self):
         for Klass in Mock, MagicMock:
             m = Klass()
@@ -1968,55 +1860,6 @@
                 self.assertEqual(m.mock_calls, call().foo().call_list())
 
 
-    def test_attach_mock_patch_autospec(self):
-        parent = Mock()
-
-        with mock.patch(f'{__name__}.something', autospec=True) as mock_func:
-            self.assertEqual(mock_func.mock._extract_mock_name(), 'something')
-            parent.attach_mock(mock_func, 'child')
-            parent.child(1)
-            something(2)
-            mock_func(3)
-
-            parent_calls = [call.child(1), call.child(2), call.child(3)]
-            child_calls = [call(1), call(2), call(3)]
-            self.assertEqual(parent.mock_calls, parent_calls)
-            self.assertEqual(parent.child.mock_calls, child_calls)
-            self.assertEqual(something.mock_calls, child_calls)
-            self.assertEqual(mock_func.mock_calls, child_calls)
-            self.assertIn('mock.child', repr(parent.child.mock))
-            self.assertEqual(mock_func.mock._extract_mock_name(), 'mock.child')
-
-
-    def test_attach_mock_patch_autospec_signature(self):
-        with mock.patch(f'{__name__}.Something.meth', autospec=True) as mocked:
-            manager = Mock()
-            manager.attach_mock(mocked, 'attach_meth')
-            obj = Something()
-            obj.meth(1, 2, 3, d=4)
-            manager.assert_has_calls([call.attach_meth(mock.ANY, 1, 2, 3, d=4)])
-            obj.meth.assert_has_calls([call(mock.ANY, 1, 2, 3, d=4)])
-            mocked.assert_has_calls([call(mock.ANY, 1, 2, 3, d=4)])
-
-        with mock.patch(f'{__name__}.something', autospec=True) as mocked:
-            manager = Mock()
-            manager.attach_mock(mocked, 'attach_func')
-            something(1)
-            manager.assert_has_calls([call.attach_func(1)])
-            something.assert_has_calls([call(1)])
-            mocked.assert_has_calls([call(1)])
-
-        with mock.patch(f'{__name__}.Something', autospec=True) as mocked:
-            manager = Mock()
-            manager.attach_mock(mocked, 'attach_obj')
-            obj = Something()
-            obj.meth(1, 2, 3, d=4)
-            manager.assert_has_calls([call.attach_obj(),
-                                      call.attach_obj().meth(1, 2, 3, d=4)])
-            obj.meth.assert_has_calls([call(1, 2, 3, d=4)])
-            mocked.assert_has_calls([call(), call().meth(1, 2, 3, d=4)])
-
-
     def test_attribute_deletion(self):
         for mock in (Mock(), MagicMock(), NonCallableMagicMock(),
                      NonCallableMock()):
@@ -2089,31 +1932,14 @@
         self.assertEqual(type(call.parent), _Call)
         self.assertEqual(type(call.parent().parent), _Call)
 
-
     def test_parent_propagation_with_create_autospec(self):
-
         def foo(a, b): pass
 
         mock = Mock()
         mock.child = create_autospec(foo)
         mock.child(1, 2)
-
         self.assertRaises(TypeError, mock.child, 1)
         self.assertEqual(mock.mock_calls, [call.child(1, 2)])
-        self.assertIn('mock.child', repr(mock.child.mock))
-
-    def test_parent_propagation_with_autospec_attach_mock(self):
-
-        def foo(a, b): pass
-
-        parent = Mock()
-        parent.attach_mock(create_autospec(foo, name='bar'), 'child')
-        parent.child(1, 2)
-
-        self.assertRaises(TypeError, parent.child, 1)
-        self.assertEqual(parent.child.mock_calls, [call.child(1, 2)])
-        self.assertIn('mock.child', repr(parent.child.mock))
-
 
     def test_isinstance_under_settrace(self):
         # bpo-36593 : __class__ is not set for a class that has __class__
@@ -2123,35 +1949,27 @@
         # dependent on unittest.mock.patch. In testpatch.PatchTest
         # test_patch_dict_test_prefix and test_patch_test_prefix not restoring
         # causes the objects patched to go out of sync
-
-        old_patch = unittest.mock.patch
-
+        old_patch = mock.patch
         # Directly using __setattr__ on unittest.mock causes current imported
         # reference to be updated. Use a lambda so that during cleanup the
         # re-imported new reference is updated.
-        self.addCleanup(lambda patch: setattr(unittest.mock, 'patch', patch),
+        self.addCleanup(lambda patch: setattr(mock, 'patch', patch),
                         old_patch)
-
         with patch.dict('sys.modules'):
-            del sys.modules['unittest.mock']
-
+            del sys.modules['mock.mock']
             # This trace will stop coverage being measured ;-)
             def trace(frame, event, arg):  # pragma: no cover
                 return trace
-
             self.addCleanup(sys.settrace, sys.gettrace())
             sys.settrace(trace)
-
-            from unittest.mock import (
+            from mock.mock import (
                 Mock, MagicMock, NonCallableMock, NonCallableMagicMock
             )
-
             mocks = [
-                Mock, MagicMock, NonCallableMock, NonCallableMagicMock, AsyncMock
+                Mock, MagicMock, NonCallableMock, NonCallableMagicMock
             ]
-
-            for mock in mocks:
-                obj = mock(spec=Something)
+            for mock_ in mocks:
+                obj = mock_(spec=Something)
                 self.assertIsInstance(obj, Something)
 
 
diff --git a/mock/tests/testpatch.py b/mock/tests/testpatch.py
index fbf4a53..bbd6d26 100644
--- a/mock/tests/testpatch.py
+++ b/mock/tests/testpatch.py
@@ -4,21 +4,24 @@
 
 import os
 import sys
-from collections import OrderedDict
 
+import six
 import unittest
-from mock.tests import support
-from mock.tests.support import SomeClass, is_instance
 
-from .support import uncache
+from mock.tests import support
+from mock.tests.support import SomeClass, is_instance, uncache
+
 from mock import (
-    NonCallableMock, sentinel,
-    MagicMock, Mock, NonCallableMagicMock, patch,
+    NonCallableMock, CallableMixin, patch, sentinel,
+    MagicMock, Mock, NonCallableMagicMock,
     DEFAULT, call
 )
-from mock.mock import CallableMixin, _patch, _get_target
+from mock.mock import _patch, _get_target
 
-builtin_string = 'builtins'
+builtin_string = '__builtin__'
+if six.PY3:
+    builtin_string = 'builtins'
+    unicode = str
 
 PTModule = sys.modules[__name__]
 MODNAME = '%s.PTModule' % __name__
@@ -106,10 +109,6 @@
         self.assertEqual(Something.attribute, sentinel.Original,
                          "patch not restored")
 
-    def test_patchobject_with_string_as_target(self):
-        msg = "'Something' must be the actual object to be patched, not a str"
-        with self.assertRaisesRegex(TypeError, msg):
-            patch.object('Something', 'do_something')
 
     def test_patchobject_with_none(self):
         class Something(object):
@@ -624,13 +623,6 @@
         self.assertEqual(foo.values, original)
 
 
-    def test_patch_dict_as_context_manager(self):
-        foo = {'a': 'b'}
-        with patch.dict(foo, a='c') as patched:
-            self.assertEqual(patched, {'a': 'c'})
-        self.assertEqual(foo, {'a': 'b'})
-
-
     def test_name_preserved(self):
         foo = {}
 
@@ -664,15 +656,21 @@
         test()
 
 
+    def test_patch_dict_with_unicode(self):
+        @patch.dict(u'os.environ', {'konrad_delong': 'some value'})
+        def test():
+            self.assertIn('konrad_delong', os.environ)
+
+        test()
+
+
     def test_patch_dict_decorator_resolution(self):
         # bpo-35512: Ensure that patch with a string target resolves to
         # the new dictionary during function call
         original = support.target.copy()
-
         @patch.dict('mock.tests.support.target', {'bar': 'BAR'})
         def test():
             self.assertEqual(support.target, {'foo': 'BAZ', 'bar': 'BAR'})
-
         try:
             support.target = {'foo': 'BAZ'}
             test()
@@ -770,14 +768,6 @@
         self.assertEqual(d, original)
 
 
-    def test_patch_dict_stop_without_start(self):
-        d = {'foo': 'bar'}
-        original = d.copy()
-        patcher = patch.dict(d, [('spam', 'eggs')], clear=True)
-        self.assertEqual(patcher.stop(), False)
-        self.assertEqual(d, original)
-
-
     def test_patch_dict_class_decorator(self):
         this = self
         d = {'spam': 'eggs'}
@@ -1339,7 +1329,7 @@
         try:
             f = result['f']
             foo = result['foo']
-            self.assertEqual(set(result), set(['f', 'foo']))
+            self.assertEqual(set(result), {'f', 'foo'})
 
             self.assertIs(Foo, original_foo)
             self.assertIs(Foo.f, f)
@@ -1543,14 +1533,15 @@
 
 
     def test_patch_multiple_string_subclasses(self):
-        Foo = type('Foo', (str,), {'fish': 'tasty'})
-        foo = Foo()
-        @patch.multiple(foo, fish='nearly gone')
-        def test():
-            self.assertEqual(foo.fish, 'nearly gone')
+        for base in (str, unicode):
+            Foo = type('Foo', (base,), {'fish': 'tasty'})
+            foo = Foo()
+            @patch.multiple(foo, fish='nearly gone')
+            def test():
+                self.assertEqual(foo.fish, 'nearly gone')
 
-        test()
-        self.assertEqual(foo.fish, 'tasty')
+            test()
+            self.assertEqual(foo.fish, 'tasty')
 
 
     @patch('mock.patch.TEST_PREFIX', 'foo')
@@ -1614,12 +1605,15 @@
 
 
     def test_patch_nested_autospec_repr(self):
-        with patch('mock.tests.support', autospec=True) as m:
+        p = patch('mock.tests.support', autospec=True)
+        m = p.start()
+        try:
             self.assertIn(" name='support.SomeClass.wibble()'",
                           repr(m.SomeClass.wibble()))
             self.assertIn(" name='support.SomeClass().wibble()'",
                           repr(m.SomeClass().wibble()))
-
+        finally:
+            p.stop()
 
 
     def test_mock_calls_with_patch(self):
@@ -1664,7 +1658,7 @@
             p1.stop()
         self.assertEqual(squizz.squozz, 3)
 
-    def test_patch_propagates_exc_on_exit(self):
+    def test_patch_propogrates_exc_on_exit(self):
         class holder:
             exc_info = None, None, None
 
@@ -1693,9 +1687,9 @@
 
         self.assertIs(holder.exc_info[0], RuntimeError)
         self.assertIsNotNone(holder.exc_info[1],
-                            'exception value not propagated')
+                            'exception value not propgated')
         self.assertIsNotNone(holder.exc_info[2],
-                            'exception traceback not propagated')
+                            'exception traceback not propgated')
 
 
     def test_create_and_specs(self):
@@ -1799,6 +1793,32 @@
         patched()
         self.assertIs(os.path, path)
 
+
+    def test_wrapped_patch(self):
+        decorated = patch('sys.modules')(function)
+        self.assertIs(decorated.__wrapped__, function)
+
+
+    def test_wrapped_several_times_patch(self):
+        decorated = patch('sys.modules')(function)
+        decorated = patch('sys.modules')(decorated)
+        self.assertIs(decorated.__wrapped__, function)
+
+
+    def test_wrapped_patch_object(self):
+        decorated = patch.object(sys, 'modules')(function)
+        self.assertIs(decorated.__wrapped__, function)
+
+
+    def test_wrapped_patch_dict(self):
+        decorated = patch.dict('sys.modules')(function)
+        self.assertIs(decorated.__wrapped__, function)
+
+
+    def test_wrapped_patch_multiple(self):
+        decorated = patch.multiple('sys', modules={})(function)
+        self.assertIs(decorated.__wrapped__, function)
+
     def test_stopall_lifo(self):
         stopped = []
         class thing(object):
@@ -1816,56 +1836,6 @@
 
         self.assertEqual(stopped, ["three", "two", "one"])
 
-    def test_patch_dict_stopall(self):
-        dic1 = {}
-        dic2 = {1: 'a'}
-        dic3 = {1: 'A', 2: 'B'}
-        origdic1 = dic1.copy()
-        origdic2 = dic2.copy()
-        origdic3 = dic3.copy()
-        patch.dict(dic1, {1: 'I', 2: 'II'}).start()
-        patch.dict(dic2, {2: 'b'}).start()
-
-        @patch.dict(dic3)
-        def patched():
-            del dic3[1]
-
-        patched()
-        self.assertNotEqual(dic1, origdic1)
-        self.assertNotEqual(dic2, origdic2)
-        self.assertEqual(dic3, origdic3)
-
-        patch.stopall()
-
-        self.assertEqual(dic1, origdic1)
-        self.assertEqual(dic2, origdic2)
-        self.assertEqual(dic3, origdic3)
-
-
-    def test_patch_and_patch_dict_stopall(self):
-        original_unlink = os.unlink
-        original_chdir = os.chdir
-        dic1 = {}
-        dic2 = {1: 'A', 2: 'B'}
-        origdic1 = dic1.copy()
-        origdic2 = dic2.copy()
-
-        patch('os.unlink', something).start()
-        patch('os.chdir', something_else).start()
-        patch.dict(dic1, {1: 'I', 2: 'II'}).start()
-        patch.dict(dic2).start()
-        del dic2[1]
-
-        self.assertIsNot(os.unlink, original_unlink)
-        self.assertIsNot(os.chdir, original_chdir)
-        self.assertNotEqual(dic1, origdic1)
-        self.assertNotEqual(dic2, origdic2)
-        patch.stopall()
-        self.assertIs(os.unlink, original_unlink)
-        self.assertIs(os.chdir, original_chdir)
-        self.assertEqual(dic1, origdic1)
-        self.assertEqual(dic2, origdic2)
-
 
     def test_special_attrs(self):
         def foo(x=0):
@@ -1881,40 +1851,22 @@
 
         with patch.object(foo, '__module__', "testpatch2"):
             self.assertEqual(foo.__module__, "testpatch2")
-        self.assertEqual(foo.__module__, 'mock.tests.testpatch')
+        self.assertEqual(foo.__module__, __name__)
 
-        with patch.object(foo, '__annotations__', dict([('s', 1, )])):
-            self.assertEqual(foo.__annotations__, dict([('s', 1, )]))
-        self.assertEqual(foo.__annotations__, dict())
+        if hasattr(self.test_special_attrs, '__annotations__'):
+            with patch.object(foo, '__annotations__', dict([('s', 1, )])):
+                self.assertEqual(foo.__annotations__, dict([('s', 1, )]))
+            self.assertEqual(foo.__annotations__, dict())
 
-        def foo(*a, x=0):
-            return x
-        with patch.object(foo, '__kwdefaults__', dict([('x', 1, )])):
-            self.assertEqual(foo(), 1)
-        self.assertEqual(foo(), 0)
+        if hasattr(self.test_special_attrs, '__kwdefaults__'):
+            foo = eval("lambda *a, x=0: x")
+            with patch.object(foo, '__kwdefaults__', dict([('x', 1, )])):
+                self.assertEqual(foo(), 1)
+            self.assertEqual(foo(), 0)
 
-    def test_patch_orderdict(self):
-        foo = OrderedDict()
-        foo['a'] = object()
-        foo['b'] = 'python'
-
-        original = foo.copy()
-        update_values = list(zip('cdefghijklmnopqrstuvwxyz', range(26)))
-        patched_values = list(foo.items()) + update_values
-
-        with patch.dict(foo, OrderedDict(update_values)):
-            self.assertEqual(list(foo.items()), patched_values)
-
-        self.assertEqual(foo, original)
-
-        with patch.dict(foo, update_values):
-            self.assertEqual(list(foo.items()), patched_values)
-
-        self.assertEqual(foo, original)
 
     def test_dotted_but_module_not_loaded(self):
         # This exercises the AttributeError branch of _dot_lookup.
-
         # make sure it's there
         import mock.tests.support
         # now make sure it's not:
@@ -1923,7 +1875,6 @@
             del sys.modules['mock.tests']
             del sys.modules['mock.mock']
             del sys.modules['mock']
-
             # now make sure we can patch based on a dotted path:
             @patch('mock.tests.support.X')
             def test(mock):
diff --git a/mock/tests/testsentinel.py b/mock/tests/testsentinel.py
index 5666434..1411445 100644
--- a/mock/tests/testsentinel.py
+++ b/mock/tests/testsentinel.py
@@ -1,3 +1,7 @@
+# Copyright (C) 2007-2012 Michael Foord & the mock team
+# E-mail: fuzzyman AT voidspace DOT org DOT uk
+# http://www.voidspace.org.uk/python/mock/
+
 import unittest
 import copy
 import pickle
@@ -27,7 +31,6 @@
 
     def testPickle(self):
         for proto in range(pickle.HIGHEST_PROTOCOL+1):
-            with self.subTest(protocol=proto):
                 pickled = pickle.dumps(sentinel.whatever, proto)
                 unpickled = pickle.loads(pickled)
                 self.assertIs(unpickled, sentinel.whatever)
diff --git a/mock/tests/testsupport.py b/mock/tests/testsupport.py
new file mode 100644
index 0000000..4882572
--- /dev/null
+++ b/mock/tests/testsupport.py
@@ -0,0 +1,14 @@
+# Tests to make sure helpers we backport are actually working!
+from unittest import TestCase
+
+from .support import uncache
+
+
+class TestUncache(TestCase):
+
+    def test_cant_uncache_sys(self):
+        with self.assertRaises(ValueError):
+            with uncache('sys'): pass
+
+    def test_uncache_non_existent(self):
+        with uncache('mock.tests.support.bad'): pass
diff --git a/mock/tests/testwith.py b/mock/tests/testwith.py
index 825387b..587fde9 100644
--- a/mock/tests/testwith.py
+++ b/mock/tests/testwith.py
@@ -1,11 +1,15 @@
-import unittest
+# Copyright (C) 2007-2012 Michael Foord & the mock team
+# E-mail: fuzzyman AT voidspace DOT org DOT uk
+# http://www.voidspace.org.uk/python/mock/
+
 from warnings import catch_warnings
 
+import unittest
+
 from mock.tests.support import is_instance
 from mock import MagicMock, Mock, patch, sentinel, mock_open, call
 
 
-
 something  = sentinel.Something
 something_else  = sentinel.SomethingElse
 
@@ -48,10 +52,11 @@
 
     def test_with_statement_nested(self):
         with catch_warnings(record=True):
-            with patch('%s.something' % __name__) as mock_something, patch('%s.something_else' % __name__) as mock_something_else:
-                self.assertEqual(something, mock_something, "unpatched")
-                self.assertEqual(something_else, mock_something_else,
-                                 "unpatched")
+            with patch('%s.something' % __name__) as mock_something:
+                with patch('%s.something_else' % __name__) as mock_something_else:
+                    self.assertEqual(something, mock_something, "unpatched")
+                    self.assertEqual(something_else, mock_something_else,
+                                     "unpatched")
 
         self.assertEqual(something, sentinel.Something)
         self.assertEqual(something_else, sentinel.SomethingElse)
@@ -230,22 +235,7 @@
         self.assertEqual(lines[1], 'bar\n')
         self.assertEqual(lines[2], 'baz\n')
         self.assertEqual(h.readline(), '')
-        with self.assertRaises(StopIteration):
-            next(h)
 
-    def test_next_data(self):
-        # Check that next will correctly return the next available
-        # line and plays well with the dunder_iter part.
-        mock = mock_open(read_data='foo\nbar\nbaz\n')
-        with patch('%s.open' % __name__, mock, create=True):
-            h = open('bar')
-            line1 = next(h)
-            line2 = next(h)
-            lines = [l for l in h]
-        self.assertEqual(line1, 'foo\n')
-        self.assertEqual(line2, 'bar\n')
-        self.assertEqual(lines[0], 'baz\n')
-        self.assertEqual(h.readline(), '')
 
     def test_readlines_data(self):
         # Test that emulating a file that ends in a newline character works
diff --git a/release.py b/release.py
index 3fa9406..2556d50 100644
--- a/release.py
+++ b/release.py
@@ -12,7 +12,7 @@
 
 def incremented_version(version_info, type_):
     type_index = VERSION_TYPES.index(type_)
-    version_info = tuple(0 if i>type_index else (e+(1 if i==type_index else 0))
+    version_info = tuple(e+(1 if i==type_index else 0)
                          for i, e in enumerate(version_info))
     return '.'.join(str(p) for p in version_info)
 
@@ -50,7 +50,7 @@
 
 
 def update_version(new_version):
-    path = join('mock', '__init__.py')
+    path = join('mock', 'mock.py')
     with open(path) as source:
         text = source.read()
 
@@ -69,7 +69,7 @@
 def git_commit(new_version):
     git('rm NEWS.d/*')
     git('add CHANGELOG.rst')
-    git('add mock/__init__.py')
+    git('add mock/mock.py')
     git(f'commit -m "Preparing for {new_version} release."')
 
 
diff --git a/setup.cfg b/setup.cfg
index e25e6cc..7283b79 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -5,16 +5,21 @@
 description-file = README.rst
 author = Testing Cabal
 author-email = testing-in-python@lists.idyll.org
-classifiers =
+license = OSI Approved :: BSD License
+classifier =
     Development Status :: 5 - Production/Stable
     Environment :: Console
     Intended Audience :: Developers
     License :: OSI Approved :: BSD License
     Operating System :: OS Independent
     Programming Language :: Python
+    Programming Language :: Python :: 2
+    Programming Language :: Python :: 2.7
+    Programming Language :: Python :: 3
+    Programming Language :: Python :: 3.4
+    Programming Language :: Python :: 3.5
     Programming Language :: Python :: 3.6
     Programming Language :: Python :: 3.7
-    Programming Language :: Python :: 3.8
     Programming Language :: Python :: Implementation :: CPython
     Programming Language :: Python :: Implementation :: PyPy
     Topic :: Software Development :: Libraries
@@ -24,7 +29,10 @@
     testing, test, mock, mocking, unittest, patching, stubs, fakes, doubles
 
 [options]
-python_requires=>=3.6
+install_requires =
+  six
+  funcsigs>=1;python_version<"3.3"
+python_requires=>=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*
 packages = mock
 
 [options.extras_require]
@@ -38,8 +46,10 @@
   wheel
   blurb
 
+[bdist_wheel]
+universal = 1
+
 [tool:pytest]
 python_files=test*.py
 filterwarnings =
-    error::RuntimeWarning
     ignore::DeprecationWarning
diff --git a/setup.py b/setup.py
index 6f5ff41..d47345f 100755
--- a/setup.py
+++ b/setup.py
@@ -5,6 +5,6 @@
 
 setuptools.setup(
     version=re.search("__version__ = '([^']+)'",
-                      open(join('mock', '__init__.py')).read()).group(1),
+                      open(join('mock', 'mock.py')).read()).group(1),
     long_description=open('README.rst').read(),
 )
diff --git a/tox.ini b/tox.ini
index 14eb4f4..90ca455 100644
--- a/tox.ini
+++ b/tox.ini
@@ -1,5 +1,5 @@
 [tox]
-envlist = py36,py37,py38,docs
+envlist = py27,pypy,py34,py35,py36,py37,docs
 
 [testenv]
 commands =