diff --git a/lib/mock/__init__.py b/lib/mock/__init__.py
index 180dee55..8f383f0e 100644
--- a/lib/mock/__init__.py
+++ b/lib/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/lib/mock/backports.py b/lib/mock/backports.py
deleted file mode 100644
index 6f20494c..00000000
--- a/lib/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/lib/mock/mock.py b/lib/mock/mock.py
index 47666723..2d39253e 100644
--- a/lib/mock/mock.py
+++ b/lib/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 @@ __all__ = (
     'ANY',
     'call',
     'create_autospec',
-    'AsyncMock',
     'FILTER_DIR',
+    'CallableMixin',
     'NonCallableMock',
     'NonCallableMagicMock',
     'mock_open',
@@ -23,44 +54,79 @@ __all__ = (
 )
 
 
-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_instance_mock(obj):
 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 @@ def _get_signature_object(func, as_instance, eat_self):
     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 @@ def _get_signature_object(func, as_instance, eat_self):
         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 @@ def _copy_func_details(func, funcopy):
             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 _is_list(obj):
 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 @@ def _set_signature(mock, original, instance=False):
     # 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 @@ def _set_signature(mock, original, instance=False):
     _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 _set_signature(mock, original, instance=False):
 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 @@ def _setup_func(funcopy, mock, sig):
     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 @@ class _SentinelObject(object):
         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 @@ class _Sentinel(object):
             raise AttributeError
         return self._sentinels.setdefault(name, _SentinelObject(name))
 
-    def __reduce__(self):
-        return 'sentinel'
-
 
 sentinel = _Sentinel()
 
@@ -309,6 +371,15 @@ _missing = sentinel.MISSING
 _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 @@ class _CallList(list):
 
 
 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 @@ class NonCallableMock(Base):
         # 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 @@ class NonCallableMock(Base):
         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 @@ class NonCallableMock(Base):
                        _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 @@ class NonCallableMock(Base):
         __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 @@ class NonCallableMock(Base):
     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 @@ class NonCallableMock(Base):
         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 @@ class NonCallableMock(Base):
 
 
     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 @@ class NonCallableMock(Base):
             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 @@ class NonCallableMock(Base):
             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 @@ class NonCallableMock(Base):
 
     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 @@ class NonCallableMock(Base):
             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 @@ class NonCallableMock(Base):
                 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 @@ class NonCallableMock(Base):
         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 @@ class NonCallableMock(Base):
         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 @@ class NonCallableMock(Base):
             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 @@ class NonCallableMock(Base):
         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 @@ class NonCallableMock(Base):
             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 @@ class NonCallableMock(Base):
             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 @@ class NonCallableMock(Base):
         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 @@ class NonCallableMock(Base):
             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 @@ class NonCallableMock(Base):
         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 @@ class NonCallableMock(Base):
 
         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 @@ class NonCallableMock(Base):
         """
         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 @@ def _try_iter(obj):
         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 @@ class CallableMixin(Base):
         # 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 @@ class CallableMixin(Base):
             # 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 @@ class Mock(CallableMixin, NonCallableMock):
       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 @@ class Mock(CallableMixin, NonCallableMock):
     """
 
 
+
 def _dot_lookup(thing, comp, import_path):
     try:
         return getattr(thing, comp)
@@ -1301,10 +1287,8 @@ class _patch(object):
 
 
     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 @@ class _patch(object):
         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 @@ class _patch(object):
 
         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 @@ class _patch(object):
             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 @@ class _patch(object):
                 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 @@ def _patch_object(
     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 @@ def _patch_multiple(target, spec=None, create=False, spec_set=None,
     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 @@ def patch(
     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 @@ def patch(
     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 @@ def patch(
     "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 @@ class _patch_dict(object):
 
 
     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 @@ class _patch_dict(object):
     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 @@ class _patch_dict(object):
 
     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 @@ magic_methods = (
     "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 @@ def _get_method(name, func):
 
 _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 @@ _calculate_return_value = {
     '__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 @@ _return_values = {
     '__complex__': 1j,
     '__float__': 1.0,
     '__bool__': True,
+    '__nonzero__': True,
+    '__oct__': '1',
+    '__hex__': '0x1',
+    '__long__': long(1),
     '__index__': 1,
-    '__aexit__': False,
 }
 
 
@@ -2029,38 +1959,29 @@ def _get_iter(self):
         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 @@ def _set_return_value(mock, method, name):
 
 
 
-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 @@ class MagicMixin(Base):
 
 
     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 @@ class NonCallableMagicMock(MagicMixin, NonCallableMock):
         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 MagicMock(MagicMixin, Mock):
 
 
 
-class MagicProxy(Base):
+class MagicProxy(object):
     def __init__(self, name, parent):
         self.name = name
         self.parent = parent
@@ -2160,239 +2074,6 @@ class MagicProxy(Base):
         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 @@ class _ANY(object):
     def __repr__(self):
         return '<ANY>'
 
+    __hash__ = None
+
 ANY = _ANY()
 
 
@@ -2414,8 +2097,15 @@ def _format_call_signature(name, args, kwargs):
     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 @@ class _Call(tuple):
             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 @@ class _Call(tuple):
                 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 @@ class _Call(tuple):
 
 
     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 @@ class _Call(tuple):
             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 @@ class _Call(tuple):
         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 @@ class _Call(tuple):
         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 @@ class _Call(tuple):
     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 @@ class _Call(tuple):
 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 @@ def create_autospec(spec, spec_set=False, instance=False, _parent=None,
         # 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 @@ def create_autospec(spec, spec_set=False, instance=False, _parent=None,
         # 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 @@ def create_autospec(spec, spec_set=False, instance=False, _parent=None,
         # 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 @@ def create_autospec(spec, spec_set=False, instance=False, _parent=None,
                                             _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 @@ def create_autospec(spec, spec_set=False, instance=False, _parent=None,
 
             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 @@ def _must_skip(spec, entry, is_type):
     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 @@ def _must_skip(spec, entry, is_type):
             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 @@ FunctionTypes = (
     type(ANY.__eq__),
 )
 
+MethodWrapperTypes = (
+    type(ANY.__eq__.__get__),
+)
+
 
 file_spec = None
 
@@ -2830,8 +2527,9 @@ def mock_open(mock=None, read_data=''):
             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 @@ def mock_open(mock=None, read_data=''):
         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 @@ def mock_open(mock=None, read_data=''):
     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 @@ class PropertyMock(Mock):
     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 @@ def seal(mock):
             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/lib/mock/tests/__init__.py b/lib/mock/tests/__init__.py
deleted file mode 100644
index e69de29b..00000000
diff --git a/lib/mock/tests/support.py b/lib/mock/tests/support.py
deleted file mode 100644
index 85fd0a31..00000000
--- a/lib/mock/tests/support.py
+++ /dev/null
@@ -1,52 +0,0 @@
-import contextlib
-import sys
-
-target = {'foo': 'FOO'}
-
-
-def is_instance(obj, klass):
-    """Version of is_instance that doesn't access __class__"""
-    return issubclass(type(obj), klass)
-
-
-class SomeClass(object):
-    class_attribute = None
-
-    def wibble(self): pass
-
-
-class X(object):
-    pass
-
-
-@contextlib.contextmanager
-def uncache(*names):
-    """Uncache a module from sys.modules.
-
-    A basic sanity check is performed to prevent uncaching modules that either
-    cannot/shouldn't be uncached.
-
-    """
-    for name in names:
-        assert name not in ('sys', 'marshal', 'imp')
-        try:
-            del sys.modules[name]
-        except KeyError:
-            pass
-    try:
-        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()
diff --git a/lib/mock/tests/testasync.py b/lib/mock/tests/testasync.py
deleted file mode 100644
index 9fd2b656..00000000
--- a/lib/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/lib/mock/tests/testcallable.py b/lib/mock/tests/testcallable.py
deleted file mode 100644
index 41715ed1..00000000
--- a/lib/mock/tests/testcallable.py
+++ /dev/null
@@ -1,149 +0,0 @@
-# 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
-from mock.tests.support import is_instance, X, SomeClass
-
-from mock import (
-    Mock, MagicMock, NonCallableMagicMock,
-    NonCallableMock, patch, create_autospec,
-)
-from mock.mock import CallableMixin
-
-
-class TestCallable(unittest.TestCase):
-
-    def assertNotCallable(self, mock):
-        self.assertTrue(is_instance(mock, NonCallableMagicMock))
-        self.assertFalse(is_instance(mock, CallableMixin))
-
-
-    def test_non_callable(self):
-        for mock in NonCallableMagicMock(), NonCallableMock():
-            self.assertRaises(TypeError, mock)
-            self.assertFalse(hasattr(mock, '__call__'))
-            self.assertIn(mock.__class__.__name__, repr(mock))
-
-
-    def test_hierarchy(self):
-        self.assertTrue(issubclass(MagicMock, Mock))
-        self.assertTrue(issubclass(NonCallableMagicMock, NonCallableMock))
-
-
-    def test_attributes(self):
-        one = NonCallableMock()
-        self.assertTrue(issubclass(type(one.one), Mock))
-
-        two = NonCallableMagicMock()
-        self.assertTrue(issubclass(type(two.two), MagicMock))
-
-
-    def test_subclasses(self):
-        class MockSub(Mock):
-            pass
-
-        one = MockSub()
-        self.assertTrue(issubclass(type(one.one), MockSub))
-
-        class MagicSub(MagicMock):
-            pass
-
-        two = MagicSub()
-        self.assertTrue(issubclass(type(two.two), MagicSub))
-
-
-    def test_patch_spec(self):
-        patcher = patch('%s.X' % __name__, spec=True)
-        mock = patcher.start()
-        self.addCleanup(patcher.stop)
-
-        instance = mock()
-        mock.assert_called_once_with()
-
-        self.assertNotCallable(instance)
-        self.assertRaises(TypeError, instance)
-
-
-    def test_patch_spec_set(self):
-        patcher = patch('%s.X' % __name__, spec_set=True)
-        mock = patcher.start()
-        self.addCleanup(patcher.stop)
-
-        instance = mock()
-        mock.assert_called_once_with()
-
-        self.assertNotCallable(instance)
-        self.assertRaises(TypeError, instance)
-
-
-    def test_patch_spec_instance(self):
-        patcher = patch('%s.X' % __name__, spec=X())
-        mock = patcher.start()
-        self.addCleanup(patcher.stop)
-
-        self.assertNotCallable(mock)
-        self.assertRaises(TypeError, mock)
-
-
-    def test_patch_spec_set_instance(self):
-        patcher = patch('%s.X' % __name__, spec_set=X())
-        mock = patcher.start()
-        self.addCleanup(patcher.stop)
-
-        self.assertNotCallable(mock)
-        self.assertRaises(TypeError, mock)
-
-
-    def test_patch_spec_callable_class(self):
-        class CallableX(X):
-            def __call__(self): pass
-
-        class Sub(CallableX):
-            pass
-
-        class Multi(SomeClass, Sub):
-            pass
-
-        for arg in 'spec', 'spec_set':
-            for Klass in CallableX, Sub, Multi:
-                with patch('%s.X' % __name__, **{arg: Klass}) as mock:
-                    instance = mock()
-                    mock.assert_called_once_with()
-
-                    self.assertTrue(is_instance(instance, MagicMock))
-                    # inherited spec
-                    self.assertRaises(AttributeError, getattr, instance,
-                                      'foobarbaz')
-
-                    result = instance()
-                    # instance is callable, result has no spec
-                    instance.assert_called_once_with()
-
-                    result(3, 2, 1)
-                    result.assert_called_once_with(3, 2, 1)
-                    result.foo(3, 2, 1)
-                    result.foo.assert_called_once_with(3, 2, 1)
-
-
-    def test_create_autospec(self):
-        mock = create_autospec(X)
-        instance = mock()
-        self.assertRaises(TypeError, instance)
-
-        mock = create_autospec(X())
-        self.assertRaises(TypeError, mock)
-
-
-    def test_create_autospec_instance(self):
-        mock = create_autospec(SomeClass, instance=True)
-
-        self.assertRaises(TypeError, mock)
-        mock.wibble()
-        mock.wibble.assert_called_once_with()
-
-        self.assertRaises(TypeError, mock.wibble, 'some',  'args')
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/lib/mock/tests/testhelpers.py b/lib/mock/tests/testhelpers.py
deleted file mode 100644
index 2a28796f..00000000
--- a/lib/mock/tests/testhelpers.py
+++ /dev/null
@@ -1,1136 +0,0 @@
-import inspect
-import time
-import types
-import unittest
-
-from mock import (
-    call, create_autospec, MagicMock,
-    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
-
-
-class SomeClass(object):
-    def one(self, a, b): pass
-    def two(self): pass
-    def three(self, a=None): pass
-
-
-class AnyTest(unittest.TestCase):
-
-    def test_any(self):
-        self.assertEqual(ANY, object())
-
-        mock = Mock()
-        mock(ANY)
-        mock.assert_called_with(ANY)
-
-        mock = Mock()
-        mock(foo=ANY)
-        mock.assert_called_with(foo=ANY)
-
-    def test_repr(self):
-        self.assertEqual(repr(ANY), '<ANY>')
-        self.assertEqual(str(ANY), '<ANY>')
-
-
-    def test_any_and_datetime(self):
-        mock = Mock()
-        mock(datetime.now(), foo=datetime.now())
-
-        mock.assert_called_with(ANY, foo=ANY)
-
-
-    def test_any_mock_calls_comparison_order(self):
-        mock = Mock()
-        class Foo(object):
-            def __eq__(self, other): pass
-            def __ne__(self, other): pass
-
-        for d in datetime.now(), Foo():
-            mock.reset_mock()
-
-            mock(d, foo=d, bar=d)
-            mock.method(d, zinga=d, alpha=d)
-            mock().method(a1=d, z99=d)
-
-            expected = [
-                call(ANY, foo=ANY, bar=ANY),
-                call.method(ANY, zinga=ANY, alpha=ANY),
-                call(), call().method(a1=ANY, z99=ANY)
-            ]
-            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):
-
-    def test_call_with_call(self):
-        kall = _Call()
-        self.assertEqual(kall, _Call())
-        self.assertEqual(kall, _Call(('',)))
-        self.assertEqual(kall, _Call(((),)))
-        self.assertEqual(kall, _Call(({},)))
-        self.assertEqual(kall, _Call(('', ())))
-        self.assertEqual(kall, _Call(('', {})))
-        self.assertEqual(kall, _Call(('', (), {})))
-        self.assertEqual(kall, _Call(('foo',)))
-        self.assertEqual(kall, _Call(('bar', ())))
-        self.assertEqual(kall, _Call(('baz', {})))
-        self.assertEqual(kall, _Call(('spam', (), {})))
-
-        kall = _Call(((1, 2, 3),))
-        self.assertEqual(kall, _Call(((1, 2, 3),)))
-        self.assertEqual(kall, _Call(('', (1, 2, 3))))
-        self.assertEqual(kall, _Call(((1, 2, 3), {})))
-        self.assertEqual(kall, _Call(('', (1, 2, 3), {})))
-
-        kall = _Call(((1, 2, 4),))
-        self.assertNotEqual(kall, _Call(('', (1, 2, 3))))
-        self.assertNotEqual(kall, _Call(('', (1, 2, 3), {})))
-
-        kall = _Call(('foo', (1, 2, 4),))
-        self.assertNotEqual(kall, _Call(('', (1, 2, 4))))
-        self.assertNotEqual(kall, _Call(('', (1, 2, 4), {})))
-        self.assertNotEqual(kall, _Call(('bar', (1, 2, 4))))
-        self.assertNotEqual(kall, _Call(('bar', (1, 2, 4), {})))
-
-        kall = _Call(({'a': 3},))
-        self.assertEqual(kall, _Call(('', (), {'a': 3})))
-        self.assertEqual(kall, _Call(('', {'a': 3})))
-        self.assertEqual(kall, _Call(((), {'a': 3})))
-        self.assertEqual(kall, _Call(({'a': 3},)))
-
-
-    def test_empty__Call(self):
-        args = _Call()
-
-        self.assertEqual(args, ())
-        self.assertEqual(args, ('foo',))
-        self.assertEqual(args, ((),))
-        self.assertEqual(args, ('foo', ()))
-        self.assertEqual(args, ('foo',(), {}))
-        self.assertEqual(args, ('foo', {}))
-        self.assertEqual(args, ({},))
-
-
-    def test_named_empty_call(self):
-        args = _Call(('foo', (), {}))
-
-        self.assertEqual(args, ('foo',))
-        self.assertEqual(args, ('foo', ()))
-        self.assertEqual(args, ('foo',(), {}))
-        self.assertEqual(args, ('foo', {}))
-
-        self.assertNotEqual(args, ((),))
-        self.assertNotEqual(args, ())
-        self.assertNotEqual(args, ({},))
-        self.assertNotEqual(args, ('bar',))
-        self.assertNotEqual(args, ('bar', ()))
-        self.assertNotEqual(args, ('bar', {}))
-
-
-    def test_call_with_args(self):
-        args = _Call(((1, 2, 3), {}))
-
-        self.assertEqual(args, ((1, 2, 3),))
-        self.assertEqual(args, ('foo', (1, 2, 3)))
-        self.assertEqual(args, ('foo', (1, 2, 3), {}))
-        self.assertEqual(args, ((1, 2, 3), {}))
-        self.assertEqual(args.args, (1, 2, 3))
-        self.assertEqual(args.kwargs, {})
-
-
-    def test_named_call_with_args(self):
-        args = _Call(('foo', (1, 2, 3), {}))
-
-        self.assertEqual(args, ('foo', (1, 2, 3)))
-        self.assertEqual(args, ('foo', (1, 2, 3), {}))
-        self.assertEqual(args.args, (1, 2, 3))
-        self.assertEqual(args.kwargs, {})
-
-        self.assertNotEqual(args, ((1, 2, 3),))
-        self.assertNotEqual(args, ((1, 2, 3), {}))
-
-
-    def test_call_with_kwargs(self):
-        args = _Call(((), dict(a=3, b=4)))
-
-        self.assertEqual(args, (dict(a=3, b=4),))
-        self.assertEqual(args, ('foo', dict(a=3, b=4)))
-        self.assertEqual(args, ('foo', (), dict(a=3, b=4)))
-        self.assertEqual(args, ((), dict(a=3, b=4)))
-        self.assertEqual(args.args, ())
-        self.assertEqual(args.kwargs, dict(a=3, b=4))
-
-
-    def test_named_call_with_kwargs(self):
-        args = _Call(('foo', (), dict(a=3, b=4)))
-
-        self.assertEqual(args, ('foo', dict(a=3, b=4)))
-        self.assertEqual(args, ('foo', (), dict(a=3, b=4)))
-        self.assertEqual(args.args, ())
-        self.assertEqual(args.kwargs, dict(a=3, b=4))
-
-        self.assertNotEqual(args, (dict(a=3, b=4),))
-        self.assertNotEqual(args, ((), dict(a=3, b=4)))
-
-
-    def test_call_with_args_call_empty_name(self):
-        args = _Call(((1, 2, 3), {}))
-
-        self.assertEqual(args, call(1, 2, 3))
-        self.assertEqual(call(1, 2, 3), args)
-        self.assertIn(call(1, 2, 3), [args])
-
-
-    def test_call_ne(self):
-        self.assertNotEqual(_Call(((1, 2, 3),)), call(1, 2))
-        self.assertFalse(_Call(((1, 2, 3),)) != call(1, 2, 3))
-        self.assertTrue(_Call(((1, 2), {})) != call(1, 2, 3))
-
-
-    def test_call_non_tuples(self):
-        kall = _Call(((1, 2, 3),))
-        for value in 1, None, self, int:
-            self.assertNotEqual(kall, value)
-            self.assertFalse(kall == value)
-
-
-    def test_repr(self):
-        self.assertEqual(repr(_Call()), 'call()')
-        self.assertEqual(repr(_Call(('foo',))), 'call.foo()')
-
-        self.assertEqual(repr(_Call(((1, 2, 3), {'a': 'b'}))),
-                         "call(1, 2, 3, a='b')")
-        self.assertEqual(repr(_Call(('bar', (1, 2, 3), {'a': 'b'}))),
-                         "call.bar(1, 2, 3, a='b')")
-
-        self.assertEqual(repr(call), 'call')
-        self.assertEqual(str(call), 'call')
-
-        self.assertEqual(repr(call()), 'call()')
-        self.assertEqual(repr(call(1)), 'call(1)')
-        self.assertEqual(repr(call(zz='thing')), "call(zz='thing')")
-
-        self.assertEqual(repr(call().foo), 'call().foo')
-        self.assertEqual(repr(call(1).foo.bar(a=3).bing),
-                         'call().foo.bar().bing')
-        self.assertEqual(
-            repr(call().foo(1, 2, a=3)),
-            "call().foo(1, 2, a=3)"
-        )
-        self.assertEqual(repr(call()()), "call()()")
-        self.assertEqual(repr(call(1)(2)), "call()(2)")
-        self.assertEqual(
-            repr(call()().bar().baz.beep(1)),
-            "call()().bar().baz.beep(1)"
-        )
-
-
-    def test_call(self):
-        self.assertEqual(call(), ('', (), {}))
-        self.assertEqual(call('foo', 'bar', one=3, two=4),
-                         ('', ('foo', 'bar'), {'one': 3, 'two': 4}))
-
-        mock = Mock()
-        mock(1, 2, 3)
-        mock(a=3, b=6)
-        self.assertEqual(mock.call_args_list,
-                         [call(1, 2, 3), call(a=3, b=6)])
-
-    def test_attribute_call(self):
-        self.assertEqual(call.foo(1), ('foo', (1,), {}))
-        self.assertEqual(call.bar.baz(fish='eggs'),
-                         ('bar.baz', (), {'fish': 'eggs'}))
-
-        mock = Mock()
-        mock.foo(1, 2 ,3)
-        mock.bar.baz(a=3, b=6)
-        self.assertEqual(mock.method_calls,
-                         [call.foo(1, 2, 3), call.bar.baz(a=3, b=6)])
-
-
-    def test_extended_call(self):
-        result = call(1).foo(2).bar(3, a=4)
-        self.assertEqual(result, ('().foo().bar', (3,), dict(a=4)))
-
-        mock = MagicMock()
-        mock(1, 2, a=3, b=4)
-        self.assertEqual(mock.call_args, call(1, 2, a=3, b=4))
-        self.assertNotEqual(mock.call_args, call(1, 2, 3))
-
-        self.assertEqual(mock.call_args_list, [call(1, 2, a=3, b=4)])
-        self.assertEqual(mock.mock_calls, [call(1, 2, a=3, b=4)])
-
-        mock = MagicMock()
-        mock.foo(1).bar()().baz.beep(a=6)
-
-        last_call = call.foo(1).bar()().baz.beep(a=6)
-        self.assertEqual(mock.mock_calls[-1], last_call)
-        self.assertEqual(mock.mock_calls, last_call.call_list())
-
-
-    def test_extended_not_equal(self):
-        a = call(x=1).foo
-        b = call(x=2).foo
-        self.assertEqual(a, a)
-        self.assertEqual(b, b)
-        self.assertNotEqual(a, b)
-
-
-    def test_nested_calls_not_equal(self):
-        a = call(x=1).foo().bar
-        b = call(x=2).foo().bar
-        self.assertEqual(a, a)
-        self.assertEqual(b, b)
-        self.assertNotEqual(a, b)
-
-
-    def test_call_list(self):
-        mock = MagicMock()
-        mock(1)
-        self.assertEqual(call(1).call_list(), mock.mock_calls)
-
-        mock = MagicMock()
-        mock(1).method(2)
-        self.assertEqual(call(1).method(2).call_list(),
-                         mock.mock_calls)
-
-        mock = MagicMock()
-        mock(1).method(2)(3)
-        self.assertEqual(call(1).method(2)(3).call_list(),
-                         mock.mock_calls)
-
-        mock = MagicMock()
-        int(mock(1).method(2)(3).foo.bar.baz(4)(5))
-        kall = call(1).method(2)(3).foo.bar.baz(4)(5).__int__()
-        self.assertEqual(kall.call_list(), mock.mock_calls)
-
-
-    def test_call_any(self):
-        self.assertEqual(call, ANY)
-
-        m = MagicMock()
-        int(m)
-        self.assertEqual(m.mock_calls, [ANY])
-        self.assertEqual([ANY], m.mock_calls)
-
-
-    def test_two_args_call(self):
-        args = _Call(((1, 2), {'a': 3}), two=True)
-        self.assertEqual(len(args), 2)
-        self.assertEqual(args[0], (1, 2))
-        self.assertEqual(args[1], {'a': 3})
-
-        other_args = _Call(((1, 2), {'a': 3}))
-        self.assertEqual(args, other_args)
-
-    def test_call_with_name(self):
-        self.assertEqual(_Call((), 'foo')[0], 'foo')
-        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):
-
-    def _check_someclass_mock(self, mock):
-        self.assertRaises(AttributeError, getattr, mock, 'foo')
-        mock.one(1, 2)
-        mock.one.assert_called_with(1, 2)
-        self.assertRaises(AssertionError,
-                          mock.one.assert_called_with, 3, 4)
-        self.assertRaises(TypeError, mock.one, 1)
-
-        mock.two()
-        mock.two.assert_called_with()
-        self.assertRaises(AssertionError,
-                          mock.two.assert_called_with, 3)
-        self.assertRaises(TypeError, mock.two, 1)
-
-        mock.three()
-        mock.three.assert_called_with()
-        self.assertRaises(AssertionError,
-                          mock.three.assert_called_with, 3)
-        self.assertRaises(TypeError, mock.three, 3, 2)
-
-        mock.three(1)
-        mock.three.assert_called_with(1)
-
-        mock.three(a=1)
-        mock.three.assert_called_with(a=1)
-
-
-    def test_basic(self):
-        mock = create_autospec(SomeClass)
-        self._check_someclass_mock(mock)
-        mock = create_autospec(SomeClass())
-        self._check_someclass_mock(mock)
-
-
-    def test_create_autospec_return_value(self):
-        def f(): pass
-        mock = create_autospec(f, return_value='foo')
-        self.assertEqual(mock(), 'foo')
-
-        class Foo(object):
-            pass
-
-        mock = create_autospec(Foo, return_value='foo')
-        self.assertEqual(mock(), 'foo')
-
-
-    def test_autospec_reset_mock(self):
-        m = create_autospec(int)
-        int(m)
-        m.reset_mock()
-        self.assertEqual(m.__int__.call_count, 0)
-
-
-    def test_mocking_unbound_methods(self):
-        class Foo(object):
-            def foo(self, foo): pass
-        p = patch.object(Foo, 'foo')
-        mock_foo = p.start()
-        Foo().foo(1)
-
-        mock_foo.assert_called_with(1)
-
-
-    def test_create_autospec_keyword_arguments(self):
-        class Foo(object):
-            a = 3
-        m = create_autospec(Foo, a='3')
-        self.assertEqual(m.a, '3')
-
-
-    def test_create_autospec_keyword_only_arguments(self):
-        def foo(a, *, b=None): pass
-
-        m = create_autospec(foo)
-        m(1)
-        m.assert_called_with(1)
-        self.assertRaises(TypeError, m, 1, 2)
-
-        m(2, b=3)
-        m.assert_called_with(2, b=3)
-
-
-    def test_function_as_instance_attribute(self):
-        obj = SomeClass()
-        def f(a): pass
-        obj.f = f
-
-        mock = create_autospec(obj)
-        mock.f('bing')
-        mock.f.assert_called_with('bing')
-
-
-    def test_spec_as_list(self):
-        # because spec as a list of strings in the mock constructor means
-        # something very different we treat a list instance as the type.
-        mock = create_autospec([])
-        mock.append('foo')
-        mock.append.assert_called_with('foo')
-
-        self.assertRaises(AttributeError, getattr, mock, 'foo')
-
-        class Foo(object):
-            foo = []
-
-        mock = create_autospec(Foo)
-        mock.foo.append(3)
-        mock.foo.append.assert_called_with(3)
-        self.assertRaises(AttributeError, getattr, mock.foo, 'foo')
-
-
-    def test_attributes(self):
-        class Sub(SomeClass):
-            attr = SomeClass()
-
-        sub_mock = create_autospec(Sub)
-
-        for mock in (sub_mock, sub_mock.attr):
-            self._check_someclass_mock(mock)
-
-
-    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)
-        mock.some_attr(1)
-        with self.assertRaises(TypeError):
-            mock.some_attr()
-        with self.assertRaises(TypeError):
-            mock.some_attr(1, 2)
-
-
-    def test_spec_has_function_not_in_bases(self):
-
-        class CrazyClass(object):
-
-            def __dir__(self):
-                return super(CrazyClass, self).__dir__()+['crazy']
-
-            def __getattr__(self, item):
-                if item == 'crazy':
-                    return lambda x: x
-                raise AttributeError(item)
-
-        inst = CrazyClass()
-        with self.assertRaises(AttributeError):
-            inst.other
-        self.assertEqual(inst.crazy(42), 42)
-
-        mock = create_autospec(inst)
-        mock.crazy(42)
-        with self.assertRaises(TypeError):
-            mock.crazy()
-        with self.assertRaises(TypeError):
-            mock.crazy(1, 2)
-
-
-    def test_builtin_functions_types(self):
-        # we could replace builtin functions / methods with a function
-        # with *args / **kwargs signature. Using the builtin method type
-        # as a spec seems to work fairly well though.
-        class BuiltinSubclass(list):
-            def bar(self, arg): pass
-            sorted = sorted
-            attr = {}
-
-        mock = create_autospec(BuiltinSubclass)
-        mock.append(3)
-        mock.append.assert_called_with(3)
-        self.assertRaises(AttributeError, getattr, mock.append, 'foo')
-
-        mock.bar('foo')
-        mock.bar.assert_called_with('foo')
-        self.assertRaises(TypeError, mock.bar, 'foo', 'bar')
-        self.assertRaises(AttributeError, getattr, mock.bar, 'foo')
-
-        mock.sorted([1, 2])
-        mock.sorted.assert_called_with([1, 2])
-        self.assertRaises(AttributeError, getattr, mock.sorted, 'foo')
-
-        mock.attr.pop(3)
-        mock.attr.pop.assert_called_with(3)
-        self.assertRaises(AttributeError, getattr, mock.attr, 'foo')
-
-
-    def test_method_calls(self):
-        class Sub(SomeClass):
-            attr = SomeClass()
-
-        mock = create_autospec(Sub)
-        mock.one(1, 2)
-        mock.two()
-        mock.three(3)
-
-        expected = [call.one(1, 2), call.two(), call.three(3)]
-        self.assertEqual(mock.method_calls, expected)
-
-        mock.attr.one(1, 2)
-        mock.attr.two()
-        mock.attr.three(3)
-
-        expected.extend(
-            [call.attr.one(1, 2), call.attr.two(), call.attr.three(3)]
-        )
-        self.assertEqual(mock.method_calls, expected)
-
-
-    def test_magic_methods(self):
-        class BuiltinSubclass(list):
-            attr = {}
-
-        mock = create_autospec(BuiltinSubclass)
-        self.assertEqual(list(mock), [])
-        self.assertRaises(TypeError, int, mock)
-        self.assertRaises(TypeError, int, mock.attr)
-        self.assertEqual(list(mock), [])
-
-        self.assertIsInstance(mock['foo'], MagicMock)
-        self.assertIsInstance(mock.attr['foo'], MagicMock)
-
-
-    def test_spec_set(self):
-        class Sub(SomeClass):
-            attr = SomeClass()
-
-        for spec in (Sub, Sub()):
-            mock = create_autospec(spec, spec_set=True)
-            self._check_someclass_mock(mock)
-
-            self.assertRaises(AttributeError, setattr, mock, 'foo', 'bar')
-            self.assertRaises(AttributeError, setattr, mock.attr, 'foo', 'bar')
-
-
-    def test_descriptors(self):
-        class Foo(object):
-            @classmethod
-            def f(cls, a, b): pass
-            @staticmethod
-            def g(a, b): pass
-
-        class Bar(Foo): pass
-
-        class Baz(SomeClass, Bar): pass
-
-        for spec in (Foo, Foo(), Bar, Bar(), Baz, Baz()):
-            mock = create_autospec(spec)
-            mock.f(1, 2)
-            mock.f.assert_called_once_with(1, 2)
-
-            mock.g(3, 4)
-            mock.g.assert_called_once_with(3, 4)
-
-
-    def test_recursive(self):
-        class A(object):
-            def a(self): pass
-            foo = 'foo bar baz'
-            bar = foo
-
-        A.B = A
-        mock = create_autospec(A)
-
-        mock()
-        self.assertFalse(mock.B.called)
-
-        mock.a()
-        mock.B.a()
-        self.assertEqual(mock.method_calls, [call.a(), call.B.a()])
-
-        self.assertIs(A.foo, A.bar)
-        self.assertIsNot(mock.foo, mock.bar)
-        mock.foo.lower()
-        self.assertRaises(AssertionError, mock.bar.lower.assert_called_with)
-
-
-    def test_spec_inheritance_for_classes(self):
-        class Foo(object):
-            def a(self, x): pass
-            class Bar(object):
-                def f(self, y): pass
-
-        class_mock = create_autospec(Foo)
-
-        self.assertIsNot(class_mock, class_mock())
-
-        for this_mock in class_mock, class_mock():
-            this_mock.a(x=5)
-            this_mock.a.assert_called_with(x=5)
-            this_mock.a.assert_called_with(5)
-            self.assertRaises(TypeError, this_mock.a, 'foo', 'bar')
-            self.assertRaises(AttributeError, getattr, this_mock, 'b')
-
-        instance_mock = create_autospec(Foo())
-        instance_mock.a(5)
-        instance_mock.a.assert_called_with(5)
-        instance_mock.a.assert_called_with(x=5)
-        self.assertRaises(TypeError, instance_mock.a, 'foo', 'bar')
-        self.assertRaises(AttributeError, getattr, instance_mock, 'b')
-
-        # The return value isn't isn't callable
-        self.assertRaises(TypeError, instance_mock)
-
-        instance_mock.Bar.f(6)
-        instance_mock.Bar.f.assert_called_with(6)
-        instance_mock.Bar.f.assert_called_with(y=6)
-        self.assertRaises(AttributeError, getattr, instance_mock.Bar, 'g')
-
-        instance_mock.Bar().f(6)
-        instance_mock.Bar().f.assert_called_with(6)
-        instance_mock.Bar().f.assert_called_with(y=6)
-        self.assertRaises(AttributeError, getattr, instance_mock.Bar(), 'g')
-
-
-    def test_inherit(self):
-        class Foo(object):
-            a = 3
-
-        Foo.Foo = Foo
-
-        # class
-        mock = create_autospec(Foo)
-        instance = mock()
-        self.assertRaises(AttributeError, getattr, instance, 'b')
-
-        attr_instance = mock.Foo()
-        self.assertRaises(AttributeError, getattr, attr_instance, 'b')
-
-        # instance
-        mock = create_autospec(Foo())
-        self.assertRaises(AttributeError, getattr, mock, 'b')
-        self.assertRaises(TypeError, mock)
-
-        # attribute instance
-        call_result = mock.Foo()
-        self.assertRaises(AttributeError, getattr, call_result, 'b')
-
-
-    def test_builtins(self):
-        # used to fail with infinite recursion
-        create_autospec(1)
-
-        create_autospec(int)
-        create_autospec('foo')
-        create_autospec(str)
-        create_autospec({})
-        create_autospec(dict)
-        create_autospec([])
-        create_autospec(list)
-        create_autospec(set())
-        create_autospec(set)
-        create_autospec(1.0)
-        create_autospec(float)
-        create_autospec(1j)
-        create_autospec(complex)
-        create_autospec(False)
-        create_autospec(True)
-
-
-    def test_function(self):
-        def f(a, b): pass
-
-        mock = create_autospec(f)
-        self.assertRaises(TypeError, mock)
-        mock(1, 2)
-        mock.assert_called_with(1, 2)
-        mock.assert_called_with(1, b=2)
-        mock.assert_called_with(a=1, b=2)
-
-        f.f = f
-        mock = create_autospec(f)
-        self.assertRaises(TypeError, mock.f)
-        mock.f(3, 4)
-        mock.f.assert_called_with(3, 4)
-        mock.f.assert_called_with(a=3, b=4)
-
-
-    def test_skip_attributeerrors(self):
-        class Raiser(object):
-            def __get__(self, obj, type=None):
-                if obj is None:
-                    raise AttributeError('Can only be accessed via an instance')
-
-        class RaiserClass(object):
-            raiser = Raiser()
-
-            @staticmethod
-            def existing(a, b):
-                return a + b
-
-        self.assertEqual(RaiserClass.existing(1, 2), 3)
-        s = create_autospec(RaiserClass)
-        self.assertRaises(TypeError, lambda x: s.existing(1, 2, 3))
-        self.assertEqual(s.existing(1, 2), s.existing.return_value)
-        self.assertRaises(AttributeError, lambda: s.nonexisting)
-
-        # check we can fetch the raiser attribute and it has no spec
-        obj = s.raiser
-        obj.foo, obj.bar
-
-
-    def test_signature_class(self):
-        class Foo(object):
-            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)
-
-        mock(4, 5)
-        mock.assert_called_with(4, 5)
-        mock.assert_called_with(a=4, b=5)
-        self.assertRaises(AssertionError, mock.assert_called_with, a=5, b=4)
-
-
-    def test_class_with_no_init(self):
-        # this used to raise an exception
-        # due to trying to get a signature from object.__init__
-        class Foo(object):
-            pass
-        create_autospec(Foo)
-
-
-    def test_signature_callable(self):
-        class Callable(object):
-            def __init__(self, x, y): pass
-            def __call__(self, a): pass
-
-        mock = create_autospec(Callable)
-        mock(1, 2)
-        mock.assert_called_once_with(1, 2)
-        mock.assert_called_once_with(x=1, y=2)
-        self.assertRaises(TypeError, mock, 'a')
-
-        instance = mock(1, 2)
-        self.assertRaises(TypeError, instance)
-        instance(a='a')
-        instance.assert_called_once_with('a')
-        instance.assert_called_once_with(a='a')
-        instance('a')
-        instance.assert_called_with('a')
-        instance.assert_called_with(a='a')
-
-        mock = create_autospec(Callable(1, 2))
-        mock(a='a')
-        mock.assert_called_once_with(a='a')
-        self.assertRaises(TypeError, mock)
-        mock('a')
-        mock.assert_called_with('a')
-
-
-    def test_signature_noncallable(self):
-        class NonCallable(object):
-            def __init__(self):
-                pass
-
-        mock = create_autospec(NonCallable)
-        instance = mock()
-        mock.assert_called_once_with()
-        self.assertRaises(TypeError, mock, 'a')
-        self.assertRaises(TypeError, instance)
-        self.assertRaises(TypeError, instance, 'a')
-
-        mock = create_autospec(NonCallable())
-        self.assertRaises(TypeError, mock)
-        self.assertRaises(TypeError, mock, 'a')
-
-
-    def test_create_autospec_none(self):
-        class Foo(object):
-            bar = None
-
-        mock = create_autospec(Foo)
-        none = mock.bar
-        self.assertNotIsInstance(none, type(None))
-
-        none.foo()
-        none.foo.assert_called_once_with()
-
-
-    def test_autospec_functions_with_self_in_odd_place(self):
-        class Foo(object):
-            def f(a, self): pass
-
-        a = create_autospec(Foo)
-        a.f(10)
-        a.f.assert_called_with(10)
-        a.f.assert_called_with(self=10)
-        a.f(self=10)
-        a.f.assert_called_with(10)
-        a.f.assert_called_with(self=10)
-
-
-    def test_autospec_data_descriptor(self):
-        class Descriptor(object):
-            def __init__(self, value):
-                self.value = value
-
-            def __get__(self, obj, cls=None):
-                return self
-
-            def __set__(self, obj, value): pass
-
-        class MyProperty(property):
-            pass
-
-        class Foo(object):
-            __slots__ = ['slot']
-
-            @property
-            def prop(self): pass
-
-            @MyProperty
-            def subprop(self): pass
-
-            desc = Descriptor(42)
-
-        foo = create_autospec(Foo)
-
-        def check_data_descriptor(mock_attr):
-            # Data descriptors don't have a spec.
-            self.assertIsInstance(mock_attr, MagicMock)
-            mock_attr(1, 2, 3)
-            mock_attr.abc(4, 5, 6)
-            mock_attr.assert_called_once_with(1, 2, 3)
-            mock_attr.abc.assert_called_once_with(4, 5, 6)
-
-        # property
-        check_data_descriptor(foo.prop)
-        # property subclass
-        check_data_descriptor(foo.subprop)
-        # class __slot__
-        check_data_descriptor(foo.slot)
-        # plain data descriptor
-        check_data_descriptor(foo.desc)
-
-
-    def test_autospec_on_bound_builtin_function(self):
-        meth = types.MethodType(time.ctime, time.time())
-        self.assertIsInstance(meth(), str)
-        mocked = create_autospec(meth)
-
-        # no signature, so no spec to check against
-        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)
-
-
-    def test_autospec_getattr_partial_function(self):
-        # bpo-32153 : getattr returning partial functions without
-        # __name__ should not create AttributeError in create_autospec
-        class Foo:
-
-            def __getattr__(self, attribute):
-                return partial(lambda name: name, attribute)
-
-        proxy = Foo()
-        autospec = create_autospec(proxy)
-        self.assertFalse(hasattr(autospec, '__name__'))
-
-
-    def test_spec_inspect_signature(self):
-
-        def myfunc(x, y): pass
-
-        mock = create_autospec(myfunc)
-        mock(1, 2)
-        mock(x=1, y=2)
-
-        self.assertEqual(inspect.signature(mock), inspect.signature(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')
-
-
-    def test_spec_function_assert_has_calls(self):
-        def f(a): pass
-        mock = create_autospec(f)
-        mock(1)
-        mock.assert_has_calls([call(1)])
-        with self.assertRaises(AssertionError):
-            mock.assert_has_calls([call(2)])
-
-
-    def test_spec_function_assert_any_call(self):
-        def f(a): pass
-        mock = create_autospec(f)
-        mock(1)
-        mock.assert_any_call(1)
-        with self.assertRaises(AssertionError):
-            mock.assert_any_call(2)
-
-
-    def test_spec_function_reset_mock(self):
-        def f(a): pass
-        rv = Mock()
-        mock = create_autospec(f, return_value=rv)
-        mock(1)(2)
-        self.assertEqual(mock.mock_calls, [call(1)])
-        self.assertEqual(rv.mock_calls, [call(2)])
-        mock.reset_mock()
-        self.assertEqual(mock.mock_calls, [])
-        self.assertEqual(rv.mock_calls, [])
-
-
-class TestCallList(unittest.TestCase):
-
-    def test_args_list_contains_call_list(self):
-        mock = Mock()
-        self.assertIsInstance(mock.call_args_list, _CallList)
-
-        mock(1, 2)
-        mock(a=3)
-        mock(3, 4)
-        mock(b=6)
-
-        for kall in call(1, 2), call(a=3), call(3, 4), call(b=6):
-            self.assertIn(kall, mock.call_args_list)
-
-        calls = [call(a=3), call(3, 4)]
-        self.assertIn(calls, mock.call_args_list)
-        calls = [call(1, 2), call(a=3)]
-        self.assertIn(calls, mock.call_args_list)
-        calls = [call(3, 4), call(b=6)]
-        self.assertIn(calls, mock.call_args_list)
-        calls = [call(3, 4)]
-        self.assertIn(calls, mock.call_args_list)
-
-        self.assertNotIn(call('fish'), mock.call_args_list)
-        self.assertNotIn([call('fish')], mock.call_args_list)
-
-
-    def test_call_list_str(self):
-        mock = Mock()
-        mock(1, 2)
-        mock.foo(a=3)
-        mock.foo.bar().baz('fish', cat='dog')
-
-        expected = (
-            "[call(1, 2),\n"
-            " call.foo(a=3),\n"
-            " call.foo.bar(),\n"
-            " call.foo.bar().baz('fish', cat='dog')]"
-        )
-        self.assertEqual(str(mock.mock_calls), expected)
-
-
-    def test_propertymock(self):
-        p = patch('%s.SomeClass.one' % __name__, new_callable=PropertyMock)
-        mock = p.start()
-        try:
-            SomeClass.one
-            mock.assert_called_once_with()
-
-            s = SomeClass()
-            s.one
-            mock.assert_called_with()
-            self.assertEqual(mock.mock_calls, [call(), call()])
-
-            s.one = 3
-            self.assertEqual(mock.mock_calls, [call(), call(), call(3)])
-        finally:
-            p.stop()
-
-
-    def test_propertymock_returnvalue(self):
-        m = MagicMock()
-        p = PropertyMock()
-        type(m).foo = p
-
-        returned = m.foo
-        p.assert_called_once_with()
-        self.assertIsInstance(returned, MagicMock)
-        self.assertNotIsInstance(returned, PropertyMock)
-
-
-class TestCallablePredicate(unittest.TestCase):
-
-    def test_type(self):
-        for obj in [str, bytes, int, list, tuple, SomeClass]:
-            self.assertTrue(_callable(obj))
-
-    def test_call_magic_method(self):
-        class Callable:
-            def __call__(self): pass
-        instance = Callable()
-        self.assertTrue(_callable(instance))
-
-    def test_staticmethod(self):
-        class WithStaticMethod:
-            @staticmethod
-            def staticfunc(): pass
-        self.assertTrue(_callable(WithStaticMethod.staticfunc))
-
-    def test_non_callable_staticmethod(self):
-        class BadStaticMethod:
-            not_callable = staticmethod(None)
-        self.assertFalse(_callable(BadStaticMethod.not_callable))
-
-    def test_classmethod(self):
-        class WithClassMethod:
-            @classmethod
-            def classfunc(cls): pass
-        self.assertTrue(_callable(WithClassMethod.classfunc))
-
-    def test_non_callable_classmethod(self):
-        class BadClassMethod:
-            not_callable = classmethod(None)
-        self.assertFalse(_callable(BadClassMethod.not_callable))
-
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/lib/mock/tests/testmagicmethods.py b/lib/mock/tests/testmagicmethods.py
deleted file mode 100644
index e1f1ee0e..00000000
--- a/lib/mock/tests/testmagicmethods.py
+++ /dev/null
@@ -1,509 +0,0 @@
-import math
-import unittest
-import os
-from mock import AsyncMock, Mock, MagicMock
-from mock.backports import iscoroutinefunction
-from mock.mock import _magics
-
-
-class TestMockingMagicMethods(unittest.TestCase):
-
-    def test_deleting_magic_methods(self):
-        mock = Mock()
-        self.assertFalse(hasattr(mock, '__getitem__'))
-
-        mock.__getitem__ = Mock()
-        self.assertTrue(hasattr(mock, '__getitem__'))
-
-        del mock.__getitem__
-        self.assertFalse(hasattr(mock, '__getitem__'))
-
-
-    def test_magicmock_del(self):
-        mock = MagicMock()
-        # before using getitem
-        del mock.__getitem__
-        self.assertRaises(TypeError, lambda: mock['foo'])
-
-        mock = MagicMock()
-        # this time use it first
-        mock['foo']
-        del mock.__getitem__
-        self.assertRaises(TypeError, lambda: mock['foo'])
-
-
-    def test_magic_method_wrapping(self):
-        mock = Mock()
-        def f(self, name):
-            return self, 'fish'
-
-        mock.__getitem__ = f
-        self.assertIsNot(mock.__getitem__, f)
-        self.assertEqual(mock['foo'], (mock, 'fish'))
-        self.assertEqual(mock.__getitem__('foo'), (mock, 'fish'))
-
-        mock.__getitem__ = mock
-        self.assertIs(mock.__getitem__, mock)
-
-
-    def test_magic_methods_isolated_between_mocks(self):
-        mock1 = Mock()
-        mock2 = Mock()
-
-        mock1.__iter__ = Mock(return_value=iter([]))
-        self.assertEqual(list(mock1), [])
-        self.assertRaises(TypeError, lambda: list(mock2))
-
-
-    def test_repr(self):
-        mock = Mock()
-        self.assertEqual(repr(mock), "<Mock id='%s'>" % id(mock))
-        mock.__repr__ = lambda s: 'foo'
-        self.assertEqual(repr(mock), 'foo')
-
-
-    def test_str(self):
-        mock = Mock()
-        self.assertEqual(str(mock), object.__str__(mock))
-        mock.__str__ = lambda s: 'foo'
-        self.assertEqual(str(mock), 'foo')
-
-
-    def test_dict_methods(self):
-        mock = Mock()
-
-        self.assertRaises(TypeError, lambda: mock['foo'])
-        def _del():
-            del mock['foo']
-        def _set():
-            mock['foo'] = 3
-        self.assertRaises(TypeError, _del)
-        self.assertRaises(TypeError, _set)
-
-        _dict = {}
-        def getitem(s, name):
-            return _dict[name]
-        def setitem(s, name, value):
-            _dict[name] = value
-        def delitem(s, name):
-            del _dict[name]
-
-        mock.__setitem__ = setitem
-        mock.__getitem__ = getitem
-        mock.__delitem__ = delitem
-
-        self.assertRaises(KeyError, lambda: mock['foo'])
-        mock['foo'] = 'bar'
-        self.assertEqual(_dict, {'foo': 'bar'})
-        self.assertEqual(mock['foo'], 'bar')
-        del mock['foo']
-        self.assertEqual(_dict, {})
-
-
-    def test_numeric(self):
-        original = mock = Mock()
-        mock.value = 0
-
-        self.assertRaises(TypeError, lambda: mock + 3)
-
-        def add(self, other):
-            mock.value += other
-            return self
-        mock.__add__ = add
-        self.assertEqual(mock + 3, mock)
-        self.assertEqual(mock.value, 3)
-
-        del mock.__add__
-        def iadd(mock):
-            mock += 3
-        self.assertRaises(TypeError, iadd, mock)
-        mock.__iadd__ = add
-        mock += 6
-        self.assertEqual(mock, original)
-        self.assertEqual(mock.value, 9)
-
-        self.assertRaises(TypeError, lambda: 3 + mock)
-        mock.__radd__ = add
-        self.assertEqual(7 + mock, mock)
-        self.assertEqual(mock.value, 16)
-
-    def test_division(self):
-        original = mock = Mock()
-        mock.value = 32
-        self.assertRaises(TypeError, lambda: mock / 2)
-
-        def truediv(self, other):
-            mock.value /= other
-            return self
-        mock.__truediv__ = truediv
-        self.assertEqual(mock / 2, mock)
-        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)
-
-        self.assertRaises(TypeError, lambda: 8 / mock)
-        mock.__rtruediv__ = truediv
-        self.assertEqual(0.5 / mock, mock)
-        self.assertEqual(mock.value, 4)
-
-    def test_hash(self):
-        mock = Mock()
-        # test delegation
-        self.assertEqual(hash(mock), Mock.__hash__(mock))
-
-        def _hash(s):
-            return 3
-        mock.__hash__ = _hash
-        self.assertEqual(hash(mock), 3)
-
-
-    def test_nonzero(self):
-        m = Mock()
-        self.assertTrue(bool(m))
-
-        m.__bool__ = lambda s: False
-        self.assertFalse(bool(m))
-
-
-    def test_comparison(self):
-        mock = Mock()
-        def comp(s, o):
-            return True
-        mock.__lt__ = mock.__gt__ = mock.__le__ = mock.__ge__ = comp
-        self. assertTrue(mock < 3)
-        self. assertTrue(mock > 3)
-        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())
-
-
-    def test_equality(self):
-        for mock in Mock(), MagicMock():
-            self.assertEqual(mock == mock, True)
-            self.assertIsInstance(mock == mock, bool)
-            self.assertEqual(mock != mock, False)
-            self.assertIsInstance(mock != mock, bool)
-            self.assertEqual(mock == object(), False)
-            self.assertEqual(mock != object(), True)
-
-            def eq(self, other):
-                return other == 3
-            mock.__eq__ = eq
-            self.assertTrue(mock == 3)
-            self.assertFalse(mock == 4)
-
-            def ne(self, other):
-                return other == 3
-            mock.__ne__ = ne
-            self.assertTrue(mock != 3)
-            self.assertFalse(mock != 4)
-
-        mock = MagicMock()
-        mock.__eq__.return_value = True
-        self.assertIsInstance(mock == 3, bool)
-        self.assertEqual(mock == 3, True)
-
-        mock.__ne__.return_value = False
-        self.assertIsInstance(mock != 3, bool)
-        self.assertEqual(mock != 3, False)
-
-
-    def test_len_contains_iter(self):
-        mock = Mock()
-
-        self.assertRaises(TypeError, len, mock)
-        self.assertRaises(TypeError, iter, mock)
-        self.assertRaises(TypeError, lambda: 'foo' in mock)
-
-        mock.__len__ = lambda s: 6
-        self.assertEqual(len(mock), 6)
-
-        mock.__contains__ = lambda s, o: o == 3
-        self.assertIn(3, mock)
-        self.assertNotIn(6, mock)
-
-        mock.__iter__ = lambda s: iter('foobarbaz')
-        self.assertEqual(list(mock), list('foobarbaz'))
-
-
-    def test_magicmock(self):
-        mock = MagicMock()
-
-        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__'))
-        self.assertFalse(bool(mock))
-
-        for entry in _magics:
-            self.assertTrue(hasattr(mock, entry))
-        self.assertFalse(hasattr(mock, '__imaginary__'))
-
-
-    def test_magic_mock_equality(self):
-        mock = MagicMock()
-        self.assertIsInstance(mock == object(), bool)
-        self.assertIsInstance(mock != object(), bool)
-
-        self.assertEqual(mock == object(), False)
-        self.assertEqual(mock != object(), True)
-        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.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_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()
-
-
-    def test_magic_methods_and_spec(self):
-        class Iterable(object):
-            def __iter__(self): pass
-
-        mock = Mock(spec=Iterable)
-        self.assertRaises(AttributeError, lambda: mock.__iter__)
-
-        mock.__iter__ = Mock(return_value=iter([]))
-        self.assertEqual(list(mock), [])
-
-        class NonIterable(object):
-            pass
-        mock = Mock(spec=NonIterable)
-        self.assertRaises(AttributeError, lambda: mock.__iter__)
-
-        def set_int():
-            mock.__int__ = Mock(return_value=iter([]))
-        self.assertRaises(AttributeError, set_int)
-
-        mock = MagicMock(spec=Iterable)
-        self.assertEqual(list(mock), [])
-        self.assertRaises(AttributeError, set_int)
-
-
-    def test_magic_methods_and_spec_set(self):
-        class Iterable(object):
-            def __iter__(self): pass
-
-        mock = Mock(spec_set=Iterable)
-        self.assertRaises(AttributeError, lambda: mock.__iter__)
-
-        mock.__iter__ = Mock(return_value=iter([]))
-        self.assertEqual(list(mock), [])
-
-        class NonIterable(object):
-            pass
-        mock = Mock(spec_set=NonIterable)
-        self.assertRaises(AttributeError, lambda: mock.__iter__)
-
-        def set_int():
-            mock.__int__ = Mock(return_value=iter([]))
-        self.assertRaises(AttributeError, set_int)
-
-        mock = MagicMock(spec_set=Iterable)
-        self.assertEqual(list(mock), [])
-        self.assertRaises(AttributeError, set_int)
-
-
-    def test_setting_unsupported_magic_method(self):
-        mock = MagicMock()
-        def set_setattr():
-            mock.__setattr__ = lambda self, name: None
-        self.assertRaisesRegex(AttributeError,
-            "Attempting to set unsupported magic method '__setattr__'.",
-            set_setattr
-        )
-
-
-    def test_attributes_and_return_value(self):
-        mock = MagicMock()
-        attr = mock.foo
-        def _get_type(obj):
-            # the type of every mock (or magicmock) is a custom subclass
-            # so the real type is the second in the mro
-            return type(obj).__mro__[1]
-        self.assertEqual(_get_type(attr), MagicMock)
-
-        returned = mock()
-        self.assertEqual(_get_type(returned), MagicMock)
-
-
-    def test_magic_methods_are_magic_mocks(self):
-        mock = MagicMock()
-        self.assertIsInstance(mock.__getitem__, MagicMock)
-
-        mock[1][2].__getitem__.return_value = 3
-        self.assertEqual(mock[1][2][3], 3)
-
-
-    def test_magic_method_reset_mock(self):
-        mock = MagicMock()
-        str(mock)
-        self.assertTrue(mock.__str__.called)
-        mock.reset_mock()
-        self.assertFalse(mock.__str__.called)
-
-
-    def test_dir(self):
-        # overriding the default implementation
-        for mock in Mock(), MagicMock():
-            def _dir(self):
-                return ['foo']
-            mock.__dir__ = _dir
-            self.assertEqual(dir(mock), ['foo'])
-
-
-    def test_bound_methods(self):
-        m = Mock()
-
-        # XXXX should this be an expected failure instead?
-
-        # this seems like it should work, but is hard to do without introducing
-        # other api inconsistencies. Failure message could be better though.
-        m.__iter__ = [3].__iter__
-        self.assertRaises(TypeError, iter, m)
-
-
-    def test_magic_method_type(self):
-        class Foo(MagicMock):
-            pass
-
-        foo = Foo()
-        self.assertIsInstance(foo.__int__, Foo)
-
-
-    def test_descriptor_from_class(self):
-        m = MagicMock()
-        type(m).__str__.return_value = 'foo'
-        self.assertEqual(str(m), 'foo')
-
-
-    def test_iterable_as_iter_return_value(self):
-        m = MagicMock()
-        m.__iter__.return_value = [1, 2, 3]
-        self.assertEqual(list(m), [1, 2, 3])
-        self.assertEqual(list(m), [1, 2, 3])
-
-        m.__iter__.return_value = iter([4, 5, 6])
-        self.assertEqual(list(m), [4, 5, 6])
-        self.assertEqual(list(m), [])
-
-
-    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)
-
-    def test_divmod_and_rdivmod(self):
-        m = MagicMock()
-        self.assertIsInstance(divmod(5, m), MagicMock)
-        m.__divmod__.return_value = (2, 1)
-        self.assertEqual(divmod(m, 2), (2, 1))
-        m = MagicMock()
-        foo = divmod(2, m)
-        self.assertIsInstance(foo, MagicMock)
-        foo_direct = m.__divmod__(2)
-        self.assertIsInstance(foo_direct, MagicMock)
-        bar = divmod(m, 2)
-        self.assertIsInstance(bar, MagicMock)
-        bar_direct = m.__rdivmod__(2)
-        self.assertIsInstance(bar_direct, MagicMock)
-
-    # http://bugs.python.org/issue23310
-    # Check if you can change behaviour of magic methods in MagicMock init
-    def test_magic_in_initialization(self):
-        m = MagicMock(**{'__str__.return_value': "12"})
-        self.assertEqual(str(m), "12")
-
-    def test_changing_magic_set_in_initialization(self):
-        m = MagicMock(**{'__str__.return_value': "12"})
-        m.__str__.return_value = "13"
-        self.assertEqual(str(m), "13")
-        m = MagicMock(**{'__str__.return_value': "12"})
-        m.configure_mock(**{'__str__.return_value': "14"})
-        self.assertEqual(str(m), "14")
-
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/lib/mock/tests/testmock.py b/lib/mock/tests/testmock.py
deleted file mode 100644
index 8bb87594..00000000
--- a/lib/mock/tests/testmock.py
+++ /dev/null
@@ -1,2159 +0,0 @@
-import copy
-import re
-import sys
-import tempfile
-
-import unittest
-from mock.tests.support import ALWAYS_EQ
-from mock.tests.support import is_instance
-from mock import (
-    call, DEFAULT, patch, sentinel,
-    MagicMock, Mock, NonCallableMock,
-    NonCallableMagicMock, AsyncMock,
-    create_autospec, mock
-)
-from mock.mock import _Call, _CallList
-
-
-class Iter(object):
-    def __init__(self):
-        self.thing = iter(['this', 'is', 'an', 'iter'])
-
-    def __iter__(self):
-        return self
-
-    def next(self):
-        return next(self.thing)
-
-    __next__ = next
-
-
-class Something(object):
-    def meth(self, a, b, c, d=None): pass
-
-    @classmethod
-    def cmeth(cls, a, b, c, d=None): pass
-
-    @staticmethod
-    def smeth(a, b, c, d=None): pass
-
-
-def something(a): pass
-
-
-class MockTest(unittest.TestCase):
-
-    def test_all(self):
-        # 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 *")
-
-
-    def test_constructor(self):
-        mock = Mock()
-
-        self.assertFalse(mock.called, "called not initialised correctly")
-        self.assertEqual(mock.call_count, 0,
-                         "call_count not initialised correctly")
-        self.assertTrue(is_instance(mock.return_value, Mock),
-                        "return_value not initialised correctly")
-
-        self.assertEqual(mock.call_args, None,
-                         "call_args not initialised correctly")
-        self.assertEqual(mock.call_args_list, [],
-                         "call_args_list not initialised correctly")
-        self.assertEqual(mock.method_calls, [],
-                          "method_calls not initialised correctly")
-
-        # Can't use hasattr for this test as it always returns True on a mock
-        self.assertNotIn('_items', mock.__dict__,
-                         "default mock should not have '_items' attribute")
-
-        self.assertIsNone(mock._mock_parent,
-                          "parent not initialised correctly")
-        self.assertIsNone(mock._mock_methods,
-                          "methods not initialised correctly")
-        self.assertEqual(mock._mock_children, {},
-                         "children not initialised incorrectly")
-
-
-    def test_return_value_in_constructor(self):
-        mock = Mock(return_value=None)
-        self.assertIsNone(mock.return_value,
-                          "return value in constructor not honoured")
-
-
-    def test_change_return_value_via_delegate(self):
-        def f(): pass
-        mock = create_autospec(f)
-        mock.mock.return_value = 1
-        self.assertEqual(mock(), 1)
-
-
-    def test_change_side_effect_via_delegate(self):
-        def f(): pass
-        mock = create_autospec(f)
-        mock.mock.side_effect = TypeError()
-        with self.assertRaises(TypeError):
-            mock()
-
-
-    def test_repr(self):
-        mock = Mock(name='foo')
-        self.assertIn('foo', repr(mock))
-        self.assertIn("'%s'" % id(mock), repr(mock))
-
-        mocks = [(Mock(), 'mock'), (Mock(name='bar'), 'bar')]
-        for mock, name in mocks:
-            self.assertIn('%s.bar' % name, repr(mock.bar))
-            self.assertIn('%s.foo()' % name, repr(mock.foo()))
-            self.assertIn('%s.foo().bing' % name, repr(mock.foo().bing))
-            self.assertIn('%s()' % name, repr(mock()))
-            self.assertIn('%s()()' % name, repr(mock()()))
-            self.assertIn('%s()().foo.bar.baz().bing' % name,
-                          repr(mock()().foo.bar.baz().bing))
-
-
-    def test_repr_with_spec(self):
-        class X(object):
-            pass
-
-        mock = Mock(spec=X)
-        self.assertIn(" spec='X' ", repr(mock))
-
-        mock = Mock(spec=X())
-        self.assertIn(" spec='X' ", repr(mock))
-
-        mock = Mock(spec_set=X)
-        self.assertIn(" spec_set='X' ", repr(mock))
-
-        mock = Mock(spec_set=X())
-        self.assertIn(" spec_set='X' ", repr(mock))
-
-        mock = Mock(spec=X, name='foo')
-        self.assertIn(" spec='X' ", repr(mock))
-        self.assertIn(" name='foo' ", repr(mock))
-
-        mock = Mock(name='foo')
-        self.assertNotIn("spec", repr(mock))
-
-        mock = Mock()
-        self.assertNotIn("spec", repr(mock))
-
-        mock = Mock(spec=['foo'])
-        self.assertNotIn("spec", repr(mock))
-
-
-    def test_side_effect(self):
-        mock = Mock()
-
-        def effect(*args, **kwargs):
-            raise SystemError('kablooie')
-
-        mock.side_effect = effect
-        self.assertRaises(SystemError, mock, 1, 2, fish=3)
-        mock.assert_called_with(1, 2, fish=3)
-
-        results = [1, 2, 3]
-        def effect():
-            return results.pop()
-        mock.side_effect = effect
-
-        self.assertEqual([mock(), mock(), mock()], [3, 2, 1],
-                          "side effect not used correctly")
-
-        mock = Mock(side_effect=sentinel.SideEffect)
-        self.assertEqual(mock.side_effect, sentinel.SideEffect,
-                          "side effect in constructor not used")
-
-        def side_effect():
-            return DEFAULT
-        mock = Mock(side_effect=side_effect, return_value=sentinel.RETURN)
-        self.assertEqual(mock(), sentinel.RETURN)
-
-    def test_autospec_side_effect(self):
-        # Test for issue17826
-        results = [1, 2, 3]
-        def effect():
-            return results.pop()
-        def f(): pass
-
-        mock = create_autospec(f)
-        mock.side_effect = [1, 2, 3]
-        self.assertEqual([mock(), mock(), mock()], [1, 2, 3],
-                          "side effect not used correctly in create_autospec")
-        # Test where side effect is a callable
-        results = [1, 2, 3]
-        mock = create_autospec(f)
-        mock.side_effect = effect
-        self.assertEqual([mock(), mock(), mock()], [3, 2, 1],
-                          "callable side effect not used correctly")
-
-    def test_autospec_side_effect_exception(self):
-        # Test for issue 23661
-        def f(): pass
-
-        mock = create_autospec(f)
-        mock.side_effect = ValueError('Bazinga!')
-        self.assertRaisesRegex(ValueError, 'Bazinga!', mock)
-
-
-    def test_reset_mock(self):
-        parent = Mock()
-        spec = ["something"]
-        mock = Mock(name="child", parent=parent, spec=spec)
-        mock(sentinel.Something, something=sentinel.SomethingElse)
-        something = mock.something
-        mock.something()
-        mock.side_effect = sentinel.SideEffect
-        return_value = mock.return_value
-        return_value()
-
-        mock.reset_mock()
-
-        self.assertEqual(mock._mock_name, "child",
-                         "name incorrectly reset")
-        self.assertEqual(mock._mock_parent, parent,
-                         "parent incorrectly reset")
-        self.assertEqual(mock._mock_methods, spec,
-                         "methods incorrectly reset")
-
-        self.assertFalse(mock.called, "called not reset")
-        self.assertEqual(mock.call_count, 0, "call_count not reset")
-        self.assertEqual(mock.call_args, None, "call_args not reset")
-        self.assertEqual(mock.call_args_list, [], "call_args_list not reset")
-        self.assertEqual(mock.method_calls, [],
-                        "method_calls not initialised correctly: %r != %r" %
-                        (mock.method_calls, []))
-        self.assertEqual(mock.mock_calls, [])
-
-        self.assertEqual(mock.side_effect, sentinel.SideEffect,
-                          "side_effect incorrectly reset")
-        self.assertEqual(mock.return_value, return_value,
-                          "return_value incorrectly reset")
-        self.assertFalse(return_value.called, "return value mock not reset")
-        self.assertEqual(mock._mock_children, {'something': something},
-                          "children reset incorrectly")
-        self.assertEqual(mock.something, something,
-                          "children incorrectly cleared")
-        self.assertFalse(mock.something.called, "child not reset")
-
-
-    def test_reset_mock_recursion(self):
-        mock = Mock()
-        mock.return_value = mock
-
-        # used to cause recursion
-        mock.reset_mock()
-
-    def test_reset_mock_on_mock_open_issue_18622(self):
-        a = mock.mock_open()
-        a.reset_mock()
-
-    def test_call(self):
-        mock = Mock()
-        self.assertTrue(is_instance(mock.return_value, Mock),
-                        "Default return_value should be a Mock")
-
-        result = mock()
-        self.assertEqual(mock(), result,
-                         "different result from consecutive calls")
-        mock.reset_mock()
-
-        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_args, ((sentinel.Arg,), {}),
-                         "call_args not set")
-        self.assertEqual(mock.call_args.args, (sentinel.Arg,),
-                         "call_args not set")
-        self.assertEqual(mock.call_args.kwargs, {},
-                         "call_args not set")
-        self.assertEqual(mock.call_args_list, [((sentinel.Arg,), {})],
-                         "call_args_list not initialised correctly")
-
-        mock.return_value = sentinel.ReturnValue
-        ret_val = mock(sentinel.Arg, key=sentinel.KeyArg)
-        self.assertEqual(ret_val, sentinel.ReturnValue,
-                         "incorrect return value")
-
-        self.assertEqual(mock.call_count, 2, "call_count incorrect")
-        self.assertEqual(mock.call_args,
-                         ((sentinel.Arg,), {'key': sentinel.KeyArg}),
-                         "call_args not set")
-        self.assertEqual(mock.call_args_list, [
-            ((sentinel.Arg,), {}),
-            ((sentinel.Arg,), {'key': sentinel.KeyArg})
-        ],
-            "call_args_list not set")
-
-
-    def test_call_args_comparison(self):
-        mock = Mock()
-        mock()
-        mock(sentinel.Arg)
-        mock(kw=sentinel.Kwarg)
-        mock(sentinel.Arg, kw=sentinel.Kwarg)
-        self.assertEqual(mock.call_args_list, [
-            (),
-            ((sentinel.Arg,),),
-            ({"kw": sentinel.Kwarg},),
-            ((sentinel.Arg,), {"kw": sentinel.Kwarg})
-        ])
-        self.assertEqual(mock.call_args,
-                         ((sentinel.Arg,), {"kw": sentinel.Kwarg}))
-        self.assertEqual(mock.call_args.args, (sentinel.Arg,))
-        self.assertEqual(mock.call_args.kwargs, {"kw": sentinel.Kwarg})
-
-        # Comparing call_args to a long sequence should not raise
-        # an exception. See issue 24857.
-        self.assertFalse(mock.call_args == "a long sequence")
-
-
-    def test_calls_equal_with_any(self):
-        # Check that equality and non-equality is consistent even when
-        # comparing with mock.ANY
-        mm = mock.MagicMock()
-        self.assertTrue(mm == mm)
-        self.assertFalse(mm != mm)
-        self.assertFalse(mm == mock.MagicMock())
-        self.assertTrue(mm != mock.MagicMock())
-        self.assertTrue(mm == mock.ANY)
-        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)
-        self.assertTrue(call1 == call2)
-        self.assertFalse(call1 != call2)
-        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()
-        mock()
-
-        # Will raise an exception if it fails
-        mock.assert_called_with()
-        self.assertRaises(AssertionError, mock.assert_called_with, 1)
-
-        mock.reset_mock()
-        self.assertRaises(AssertionError, mock.assert_called_with)
-
-        mock(1, 2, 3, a='fish', b='nothing')
-        mock.assert_called_with(1, 2, 3, a='fish', b='nothing')
-
-
-    def test_assert_called_with_any(self):
-        m = MagicMock()
-        m(MagicMock())
-        m.assert_called_with(mock.ANY)
-
-
-    def test_assert_called_with_function_spec(self):
-        def f(a, b, c, d=None): pass
-
-        mock = Mock(spec=f)
-
-        mock(1, b=2, c=3)
-        mock.assert_called_with(1, 2, 3)
-        mock.assert_called_with(a=1, b=2, c=3)
-        self.assertRaises(AssertionError, mock.assert_called_with,
-                          1, b=3, c=2)
-        # 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)
-
-
-    def test_assert_called_with_method_spec(self):
-        def _check(mock):
-            mock(1, b=2, c=3)
-            mock.assert_called_with(1, 2, 3)
-            mock.assert_called_with(a=1, b=2, c=3)
-            self.assertRaises(AssertionError, mock.assert_called_with,
-                              1, b=3, c=2)
-
-        mock = Mock(spec=Something().meth)
-        _check(mock)
-        mock = Mock(spec=Something.cmeth)
-        _check(mock)
-        mock = Mock(spec=Something().cmeth)
-        _check(mock)
-        mock = Mock(spec=Something.smeth)
-        _check(mock)
-        mock = Mock(spec=Something().smeth)
-        _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()
-
-        # Will raise an exception if it fails
-        mock.assert_called_once_with()
-
-        mock()
-        self.assertRaises(AssertionError, mock.assert_called_once_with)
-
-        mock.reset_mock()
-        self.assertRaises(AssertionError, mock.assert_called_once_with)
-
-        mock('foo', 'bar', baz=2)
-        mock.assert_called_once_with('foo', 'bar', baz=2)
-
-        mock.reset_mock()
-        mock('foo', 'bar', baz=2)
-        self.assertRaises(
-            AssertionError,
-            lambda: mock.assert_called_once_with('bob', 'bar', baz=2)
-        )
-
-    def test_assert_called_once_with_call_list(self):
-        m = Mock()
-        m(1)
-        m(2)
-        self.assertRaisesRegex(AssertionError,
-            re.escape("Calls: [call(1), call(2)]"),
-            lambda: m.assert_called_once_with(2))
-
-
-    def test_assert_called_once_with_function_spec(self):
-        def f(a, b, c, d=None): pass
-
-        mock = Mock(spec=f)
-
-        mock(1, b=2, c=3)
-        mock.assert_called_once_with(1, 2, 3)
-        mock.assert_called_once_with(a=1, b=2, c=3)
-        self.assertRaises(AssertionError, mock.assert_called_once_with,
-                          1, b=3, c=2)
-        # 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)
-        # Mock called more than once => always fails
-        mock(4, 5, 6)
-        self.assertRaises(AssertionError, mock.assert_called_once_with,
-                          1, 2, 3)
-        self.assertRaises(AssertionError, mock.assert_called_once_with,
-                          4, 5, 6)
-
-
-    def test_attribute_access_returns_mocks(self):
-        mock = Mock()
-        something = mock.something
-        self.assertTrue(is_instance(something, Mock), "attribute isn't a mock")
-        self.assertEqual(mock.something, something,
-                         "different attributes returned for same name")
-
-        # Usage example
-        mock = Mock()
-        mock.something.return_value = 3
-
-        self.assertEqual(mock.something(), 3, "method returned wrong value")
-        self.assertTrue(mock.something.called,
-                        "method didn't record being called")
-
-
-    def test_attributes_have_name_and_parent_set(self):
-        mock = Mock()
-        something = mock.something
-
-        self.assertEqual(something._mock_name, "something",
-                         "attribute name not set correctly")
-        self.assertEqual(something._mock_parent, mock,
-                         "attribute parent not set correctly")
-
-
-    def test_method_calls_recorded(self):
-        mock = Mock()
-        mock.something(3, fish=None)
-        mock.something_else.something(6, cake=sentinel.Cake)
-
-        self.assertEqual(mock.something_else.method_calls,
-                          [("something", (6,), {'cake': sentinel.Cake})],
-                          "method calls not recorded correctly")
-        self.assertEqual(mock.method_calls, [
-            ("something", (3,), {'fish': None}),
-            ("something_else.something", (6,), {'cake': sentinel.Cake})
-        ],
-            "method calls not recorded correctly")
-
-
-    def test_method_calls_compare_easily(self):
-        mock = Mock()
-        mock.something()
-        self.assertEqual(mock.method_calls, [('something',)])
-        self.assertEqual(mock.method_calls, [('something', (), {})])
-
-        mock = Mock()
-        mock.something('different')
-        self.assertEqual(mock.method_calls, [('something', ('different',))])
-        self.assertEqual(mock.method_calls,
-                         [('something', ('different',), {})])
-
-        mock = Mock()
-        mock.something(x=1)
-        self.assertEqual(mock.method_calls, [('something', {'x': 1})])
-        self.assertEqual(mock.method_calls, [('something', (), {'x': 1})])
-
-        mock = Mock()
-        mock.something('different', some='more')
-        self.assertEqual(mock.method_calls, [
-            ('something', ('different',), {'some': 'more'})
-        ])
-
-
-    def test_only_allowed_methods_exist(self):
-        for spec in ['something'], ('something',):
-            for arg in 'spec', 'spec_set':
-                mock = Mock(**{arg: spec})
-
-                # this should be allowed
-                mock.something
-                self.assertRaisesRegex(
-                    AttributeError,
-                    "Mock object has no attribute 'something_else'",
-                    getattr, mock, 'something_else'
-                )
-
-
-    def test_from_spec(self):
-        class Something(object):
-            x = 3
-            __something__ = None
-            def y(self): pass
-
-        def test_attributes(mock):
-            # should work
-            mock.x
-            mock.y
-            mock.__something__
-            self.assertRaisesRegex(
-                AttributeError,
-                "Mock object has no attribute 'z'",
-                getattr, mock, 'z'
-            )
-            self.assertRaisesRegex(
-                AttributeError,
-                "Mock object has no attribute '__foobar__'",
-                getattr, mock, '__foobar__'
-            )
-
-        test_attributes(Mock(spec=Something))
-        test_attributes(Mock(spec=Something()))
-
-
-    def test_wraps_calls(self):
-        real = Mock()
-
-        mock = Mock(wraps=real)
-        self.assertEqual(mock(), real())
-
-        real.reset_mock()
-
-        mock(1, 2, fish=3)
-        real.assert_called_with(1, 2, fish=3)
-
-
-    def test_wraps_prevents_automatic_creation_of_mocks(self):
-        class Real(object):
-            pass
-
-        real = Real()
-        mock = Mock(wraps=real)
-
-        self.assertRaises(AttributeError, lambda: mock.new_attr())
-
-
-    def test_wraps_call_with_nondefault_return_value(self):
-        real = Mock()
-
-        mock = Mock(wraps=real)
-        mock.return_value = 3
-
-        self.assertEqual(mock(), 3)
-        self.assertFalse(real.called)
-
-
-    def test_wraps_attributes(self):
-        class Real(object):
-            attribute = Mock()
-
-        real = Real()
-
-        mock = Mock(wraps=real)
-        self.assertEqual(mock.attribute(), real.attribute())
-        self.assertRaises(AttributeError, lambda: mock.fish)
-
-        self.assertNotEqual(mock.attribute, real.attribute)
-        result = mock.attribute.frog(1, 2, fish=3)
-        Real.attribute.frog.assert_called_with(1, 2, fish=3)
-        self.assertEqual(result, Real.attribute.frog())
-
-
-    def test_customize_wrapped_object_with_side_effect_iterable_with_default(self):
-        class Real(object):
-            def method(self):
-                return sentinel.ORIGINAL_VALUE
-
-        real = Real()
-        mock = Mock(wraps=real)
-        mock.method.side_effect = [sentinel.VALUE1, DEFAULT]
-
-        self.assertEqual(mock.method(), sentinel.VALUE1)
-        self.assertEqual(mock.method(), sentinel.ORIGINAL_VALUE)
-        self.assertRaises(StopIteration, mock.method)
-
-
-    def test_customize_wrapped_object_with_side_effect_iterable(self):
-        class Real(object):
-            def method(self): pass
-
-        real = Real()
-        mock = Mock(wraps=real)
-        mock.method.side_effect = [sentinel.VALUE1, sentinel.VALUE2]
-
-        self.assertEqual(mock.method(), sentinel.VALUE1)
-        self.assertEqual(mock.method(), sentinel.VALUE2)
-        self.assertRaises(StopIteration, mock.method)
-
-
-    def test_customize_wrapped_object_with_side_effect_exception(self):
-        class Real(object):
-            def method(self): pass
-
-        real = Real()
-        mock = Mock(wraps=real)
-        mock.method.side_effect = RuntimeError
-
-        self.assertRaises(RuntimeError, mock.method)
-
-
-    def test_customize_wrapped_object_with_side_effect_function(self):
-        class Real(object):
-            def method(self): pass
-        def side_effect():
-            return sentinel.VALUE
-
-        real = Real()
-        mock = Mock(wraps=real)
-        mock.method.side_effect = side_effect
-
-        self.assertEqual(mock.method(), sentinel.VALUE)
-
-
-    def test_customize_wrapped_object_with_return_value(self):
-        class Real(object):
-            def method(self): pass
-
-        real = Real()
-        mock = Mock(wraps=real)
-        mock.method.return_value = sentinel.VALUE
-
-        self.assertEqual(mock.method(), sentinel.VALUE)
-
-
-    def test_customize_wrapped_object_with_return_value_and_side_effect(self):
-        # side_effect should always take precedence over return_value.
-        class Real(object):
-            def method(self): pass
-
-        real = Real()
-        mock = Mock(wraps=real)
-        mock.method.side_effect = [sentinel.VALUE1, sentinel.VALUE2]
-        mock.method.return_value = sentinel.WRONG_VALUE
-
-        self.assertEqual(mock.method(), sentinel.VALUE1)
-        self.assertEqual(mock.method(), sentinel.VALUE2)
-        self.assertRaises(StopIteration, mock.method)
-
-
-    def test_customize_wrapped_object_with_return_value_and_side_effect2(self):
-        # side_effect can return DEFAULT to default to return_value
-        class Real(object):
-            def method(self): pass
-
-        real = Real()
-        mock = Mock(wraps=real)
-        mock.method.side_effect = lambda: DEFAULT
-        mock.method.return_value = sentinel.VALUE
-
-        self.assertEqual(mock.method(), sentinel.VALUE)
-
-
-    def test_customize_wrapped_object_with_return_value_and_side_effect_default(self):
-        class Real(object):
-            def method(self): pass
-
-        real = Real()
-        mock = Mock(wraps=real)
-        mock.method.side_effect = [sentinel.VALUE1, DEFAULT]
-        mock.method.return_value = sentinel.RETURN
-
-        self.assertEqual(mock.method(), sentinel.VALUE1)
-        self.assertEqual(mock.method(), sentinel.RETURN)
-        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)
-
-        mock = Mock(side_effect=AttributeError('foo'))
-        self.assertRaises(AttributeError, mock)
-
-
-    def test_baseexceptional_side_effect(self):
-        mock = Mock(side_effect=KeyboardInterrupt)
-        self.assertRaises(KeyboardInterrupt, mock)
-
-        mock = Mock(side_effect=KeyboardInterrupt('foo'))
-        self.assertRaises(KeyboardInterrupt, mock)
-
-
-    def test_assert_called_with_message(self):
-        mock = Mock()
-        self.assertRaisesRegex(AssertionError, 'not called',
-                                mock.assert_called_with)
-
-
-    def test_assert_called_once_with_message(self):
-        mock = Mock(name='geoffrey')
-        self.assertRaisesRegex(AssertionError,
-                     r"Expected 'geoffrey' to be called once\.",
-                     mock.assert_called_once_with)
-
-
-    def test__name__(self):
-        mock = Mock()
-        self.assertRaises(AttributeError, lambda: mock.__name__)
-
-        mock.__name__ = 'foo'
-        self.assertEqual(mock.__name__, 'foo')
-
-
-    def test_spec_list_subclass(self):
-        class Sub(list):
-            pass
-        mock = Mock(spec=Sub(['foo']))
-
-        mock.append(3)
-        mock.append.assert_called_with(3)
-        self.assertRaises(AttributeError, getattr, mock, 'foo')
-
-
-    def test_spec_class(self):
-        class X(object):
-            pass
-
-        mock = Mock(spec=X)
-        self.assertIsInstance(mock, X)
-
-        mock = Mock(spec=X())
-        self.assertIsInstance(mock, X)
-
-        self.assertIs(mock.__class__, X)
-        self.assertEqual(Mock().__class__.__name__, 'Mock')
-
-        mock = Mock(spec_set=X)
-        self.assertIsInstance(mock, X)
-
-        mock = Mock(spec_set=X())
-        self.assertIsInstance(mock, X)
-
-
-    def test_spec_class_no_object_base(self):
-        class X:
-            pass
-
-        mock = Mock(spec=X)
-        self.assertIsInstance(mock, X)
-
-        mock = Mock(spec=X())
-        self.assertIsInstance(mock, X)
-
-        self.assertIs(mock.__class__, X)
-        self.assertEqual(Mock().__class__.__name__, 'Mock')
-
-        mock = Mock(spec_set=X)
-        self.assertIsInstance(mock, X)
-
-        mock = Mock(spec_set=X())
-        self.assertIsInstance(mock, X)
-
-
-    def test_setting_attribute_with_spec_set(self):
-        class X(object):
-            y = 3
-
-        mock = Mock(spec=X)
-        mock.x = 'foo'
-
-        mock = Mock(spec_set=X)
-        def set_attr():
-            mock.x = 'foo'
-
-        mock.y = 'foo'
-        self.assertRaises(AttributeError, set_attr)
-
-
-    def test_copy(self):
-        current = sys.getrecursionlimit()
-        self.addCleanup(sys.setrecursionlimit, current)
-
-        # can't use sys.maxint as this doesn't exist in Python 3
-        sys.setrecursionlimit(int(10e8))
-        # this segfaults without the fix in place
-        copy.copy(Mock())
-
-
-    def test_subclass_with_properties(self):
-        class SubClass(Mock):
-            def _get(self):
-                return 3
-            def _set(self, value):
-                raise NameError('strange error')
-            some_attribute = property(_get, _set)
-
-        s = SubClass(spec_set=SubClass)
-        self.assertEqual(s.some_attribute, 3)
-
-        def test():
-            s.some_attribute = 3
-        self.assertRaises(NameError, test)
-
-        def test():
-            s.foo = 'bar'
-        self.assertRaises(AttributeError, test)
-
-
-    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__
-        mock('one')
-        mock.assert_called_with('one')
-
-        self.assertRaises(TypeError, mock, 'one', 'two')
-
-
-    def test_dir(self):
-        mock = Mock()
-        attrs = set(dir(mock))
-        type_attrs = set([m for m in dir(Mock) if not m.startswith('_')])
-
-        # all public attributes from the type are included
-        self.assertEqual(set(), type_attrs - attrs)
-
-        # creates these attributes
-        mock.a, mock.b
-        self.assertIn('a', dir(mock))
-        self.assertIn('b', dir(mock))
-
-        # instance attributes
-        mock.c = mock.d = None
-        self.assertIn('c', dir(mock))
-        self.assertIn('d', dir(mock))
-
-        # magic methods
-        mock.__iter__ = lambda s: iter([])
-        self.assertIn('__iter__', dir(mock))
-
-
-    def test_dir_from_spec(self):
-        mock = Mock(spec=unittest.TestCase)
-        testcase_attrs = set(dir(unittest.TestCase))
-        attrs = set(dir(mock))
-
-        # all attributes from the spec are included
-        self.assertEqual(set(), testcase_attrs - attrs)
-
-        # shadow a sys attribute
-        mock.version = 3
-        self.assertEqual(dir(mock).count('version'), 1)
-
-
-    def test_filter_dir(self):
-        patcher = patch.object(mock, 'FILTER_DIR', False)
-        patcher.start()
-        try:
-            attrs = set(dir(Mock()))
-            type_attrs = set(dir(Mock))
-
-            # ALL attributes from the type are included
-            self.assertEqual(set(), type_attrs - attrs)
-        finally:
-            patcher.stop()
-
-
-    def test_dir_does_not_include_deleted_attributes(self):
-        mock = Mock()
-        mock.child.return_value = 1
-
-        self.assertIn('child', dir(mock))
-        del mock.child
-        self.assertNotIn('child', dir(mock))
-
-
-    def test_configure_mock(self):
-        mock = Mock(foo='bar')
-        self.assertEqual(mock.foo, 'bar')
-
-        mock = MagicMock(foo='bar')
-        self.assertEqual(mock.foo, 'bar')
-
-        kwargs = {'side_effect': KeyError, 'foo.bar.return_value': 33,
-                  'foo': MagicMock()}
-        mock = Mock(**kwargs)
-        self.assertRaises(KeyError, mock)
-        self.assertEqual(mock.foo.bar(), 33)
-        self.assertIsInstance(mock.foo, MagicMock)
-
-        mock = Mock()
-        mock.configure_mock(**kwargs)
-        self.assertRaises(KeyError, mock)
-        self.assertEqual(mock.foo.bar(), 33)
-        self.assertIsInstance(mock.foo, MagicMock)
-
-
-    def assertRaisesWithMsg(self, exception, message, func, *args, **kwargs):
-        # needed because assertRaisesRegex doesn't work easily with newlines
-        with self.assertRaises(exception) as context:
-            func(*args, **kwargs)
-        msg = str(context.exception)
-        self.assertEqual(msg, message)
-
-
-    def test_assert_called_with_failure_message(self):
-        mock = NonCallableMock()
-
-        actual = 'not called.'
-        expected = "mock(1, '2', 3, bar='foo')"
-        message = 'expected call not found.\nExpected: %s\nActual: %s'
-        self.assertRaisesWithMsg(
-            AssertionError, message % (expected, actual),
-            mock.assert_called_with, 1, '2', 3, bar='foo'
-        )
-
-        mock.foo(1, '2', 3, foo='foo')
-
-
-        asserters = [
-            mock.foo.assert_called_with, mock.foo.assert_called_once_with
-        ]
-        for meth in asserters:
-            actual = "foo(1, '2', 3, foo='foo')"
-            expected = "foo(1, '2', 3, bar='foo')"
-            message = 'expected call not found.\nExpected: %s\nActual: %s'
-            self.assertRaisesWithMsg(
-                AssertionError, message % (expected, actual),
-                meth, 1, '2', 3, bar='foo'
-            )
-
-        # just kwargs
-        for meth in asserters:
-            actual = "foo(1, '2', 3, foo='foo')"
-            expected = "foo(bar='foo')"
-            message = 'expected call not found.\nExpected: %s\nActual: %s'
-            self.assertRaisesWithMsg(
-                AssertionError, message % (expected, actual),
-                meth, bar='foo'
-            )
-
-        # just args
-        for meth in asserters:
-            actual = "foo(1, '2', 3, foo='foo')"
-            expected = "foo(1, 2, 3)"
-            message = 'expected call not found.\nExpected: %s\nActual: %s'
-            self.assertRaisesWithMsg(
-                AssertionError, message % (expected, actual),
-                meth, 1, 2, 3
-            )
-
-        # empty
-        for meth in asserters:
-            actual = "foo(1, '2', 3, foo='foo')"
-            expected = "foo()"
-            message = 'expected call not found.\nExpected: %s\nActual: %s'
-            self.assertRaisesWithMsg(
-                AssertionError, message % (expected, actual), meth
-            )
-
-
-    def test_mock_calls(self):
-        mock = MagicMock()
-
-        # need to do this because MagicMock.mock_calls used to just return
-        # a MagicMock which also returned a MagicMock when __eq__ was called
-        self.assertIs(mock.mock_calls == [], True)
-
-        mock = MagicMock()
-        mock()
-        expected = [('', (), {})]
-        self.assertEqual(mock.mock_calls, expected)
-
-        mock.foo()
-        expected.append(call.foo())
-        self.assertEqual(mock.mock_calls, expected)
-        # intermediate mock_calls work too
-        self.assertEqual(mock.foo.mock_calls, [('', (), {})])
-
-        mock = MagicMock()
-        mock().foo(1, 2, 3, a=4, b=5)
-        expected = [
-            ('', (), {}), ('().foo', (1, 2, 3), dict(a=4, b=5))
-        ]
-        self.assertEqual(mock.mock_calls, expected)
-        self.assertEqual(mock.return_value.foo.mock_calls,
-                         [('', (1, 2, 3), dict(a=4, b=5))])
-        self.assertEqual(mock.return_value.mock_calls,
-                         [('foo', (1, 2, 3), dict(a=4, b=5))])
-
-        mock = MagicMock()
-        mock().foo.bar().baz()
-        expected = [
-            ('', (), {}), ('().foo.bar', (), {}),
-            ('().foo.bar().baz', (), {})
-        ]
-        self.assertEqual(mock.mock_calls, expected)
-        self.assertEqual(mock().mock_calls,
-                         call.foo.bar().baz().call_list())
-
-        for kwargs in dict(), dict(name='bar'):
-            mock = MagicMock(**kwargs)
-            int(mock.foo)
-            expected = [('foo.__int__', (), {})]
-            self.assertEqual(mock.mock_calls, expected)
-
-            mock = MagicMock(**kwargs)
-            mock.a()()
-            expected = [('a', (), {}), ('a()', (), {})]
-            self.assertEqual(mock.mock_calls, expected)
-            self.assertEqual(mock.a().mock_calls, [call()])
-
-            mock = MagicMock(**kwargs)
-            mock(1)(2)(3)
-            self.assertEqual(mock.mock_calls, call(1)(2)(3).call_list())
-            self.assertEqual(mock().mock_calls, call(2)(3).call_list())
-            self.assertEqual(mock()().mock_calls, call(3).call_list())
-
-            mock = MagicMock(**kwargs)
-            mock(1)(2)(3).a.b.c(4)
-            self.assertEqual(mock.mock_calls,
-                             call(1)(2)(3).a.b.c(4).call_list())
-            self.assertEqual(mock().mock_calls,
-                             call(2)(3).a.b.c(4).call_list())
-            self.assertEqual(mock()().mock_calls,
-                             call(3).a.b.c(4).call_list())
-
-            mock = MagicMock(**kwargs)
-            int(mock().foo.bar().baz())
-            last_call = ('().foo.bar().baz().__int__', (), {})
-            self.assertEqual(mock.mock_calls[-1], last_call)
-            self.assertEqual(mock().mock_calls,
-                             call.foo.bar().baz().__int__().call_list())
-            self.assertEqual(mock().foo.bar().mock_calls,
-                             call.baz().__int__().call_list())
-            self.assertEqual(mock().foo.bar().baz.mock_calls,
-                             call().__int__().call_list())
-
-
-    def test_child_mock_call_equal(self):
-        m = Mock()
-        result = m()
-        result.wibble()
-        # parent looks like this:
-        self.assertEqual(m.mock_calls, [call(), call().wibble()])
-        # but child should look like this:
-        self.assertEqual(result.mock_calls, [call.wibble()])
-
-
-    def test_mock_call_not_equal_leaf(self):
-        m = Mock()
-        m.foo().something()
-        self.assertNotEqual(m.mock_calls[1], call.foo().different())
-        self.assertEqual(m.mock_calls[0], call.foo())
-
-
-    def test_mock_call_not_equal_non_leaf(self):
-        m = Mock()
-        m.foo().bar()
-        self.assertNotEqual(m.mock_calls[1], call.baz().bar())
-        self.assertNotEqual(m.mock_calls[0], call.baz())
-
-
-    def test_mock_call_not_equal_non_leaf_params_different(self):
-        m = Mock()
-        m.foo(x=1).bar()
-        # This isn't ideal, but there's no way to fix it without breaking backwards compatibility:
-        self.assertEqual(m.mock_calls[1], call.foo(x=2).bar())
-
-
-    def test_mock_call_not_equal_non_leaf_attr(self):
-        m = Mock()
-        m.foo.bar()
-        self.assertNotEqual(m.mock_calls[0], call.baz.bar())
-
-
-    def test_mock_call_not_equal_non_leaf_call_versus_attr(self):
-        m = Mock()
-        m.foo.bar()
-        self.assertNotEqual(m.mock_calls[0], call.foo().bar())
-
-
-    def test_mock_call_repr(self):
-        m = Mock()
-        m.foo().bar().baz.bob()
-        self.assertEqual(repr(m.mock_calls[0]), 'call.foo()')
-        self.assertEqual(repr(m.mock_calls[1]), 'call.foo().bar()')
-        self.assertEqual(repr(m.mock_calls[2]), 'call.foo().bar().baz.bob()')
-
-
-    def test_mock_call_repr_loop(self):
-        m = Mock()
-        m.foo = m
-        repr(m.foo())
-        self.assertRegex(repr(m.foo()), r"<Mock name='mock\(\)' id='\d+'>")
-
-
-    def test_mock_calls_contains(self):
-        m = Mock()
-        self.assertFalse([call()] in m.mock_calls)
-
-
-    def test_subclassing(self):
-        class Subclass(Mock):
-            pass
-
-        mock = Subclass()
-        self.assertIsInstance(mock.foo, Subclass)
-        self.assertIsInstance(mock(), Subclass)
-
-        class Subclass(Mock):
-            def _get_child_mock(self, **kwargs):
-                return Mock(**kwargs)
-
-        mock = Subclass()
-        self.assertNotIsInstance(mock.foo, Subclass)
-        self.assertNotIsInstance(mock(), Subclass)
-
-
-    def test_arg_lists(self):
-        mocks = [
-            Mock(),
-            MagicMock(),
-            NonCallableMock(),
-            NonCallableMagicMock()
-        ]
-
-        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, [])
-
-        for mock in mocks:
-            assert_attrs(mock)
-
-            if callable(mock):
-                mock()
-                mock(1, 2)
-                mock(a=3)
-
-                mock.reset_mock()
-                assert_attrs(mock)
-
-            mock.foo()
-            mock.foo.bar(1, a=3)
-            mock.foo(1).bar().baz(3)
-
-            mock.reset_mock()
-            assert_attrs(mock)
-
-
-    def test_call_args_two_tuple(self):
-        mock = Mock()
-        mock(1, a=3)
-        mock(2, b=4)
-
-        self.assertEqual(len(mock.call_args), 2)
-        self.assertEqual(mock.call_args.args, (2,))
-        self.assertEqual(mock.call_args.kwargs, dict(b=4))
-
-        expected_list = [((1,), dict(a=3)), ((2,), dict(b=4))]
-        for expected, call_args in zip(expected_list, mock.call_args_list):
-            self.assertEqual(len(call_args), 2)
-            self.assertEqual(expected[0], call_args[0])
-            self.assertEqual(expected[1], call_args[1])
-
-
-    def test_side_effect_iterator(self):
-        mock = Mock(side_effect=iter([1, 2, 3]))
-        self.assertEqual([mock(), mock(), mock()], [1, 2, 3])
-        self.assertRaises(StopIteration, mock)
-
-        mock = MagicMock(side_effect=['a', 'b', 'c'])
-        self.assertEqual([mock(), mock(), mock()], ['a', 'b', 'c'])
-        self.assertRaises(StopIteration, mock)
-
-        mock = Mock(side_effect='ghi')
-        self.assertEqual([mock(), mock(), mock()], ['g', 'h', 'i'])
-        self.assertRaises(StopIteration, mock)
-
-        class Foo(object):
-            pass
-        mock = MagicMock(side_effect=Foo)
-        self.assertIsInstance(mock(), Foo)
-
-        mock = Mock(side_effect=Iter())
-        self.assertEqual([mock(), mock(), mock(), mock()],
-                         ['this', 'is', 'an', 'iter'])
-        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])
-        self.assertEqual([mock(), mock(), mock()], [1, 2, 3])
-        self.assertRaises(StopIteration, mock)
-        side_effect = mock.side_effect
-        self.assertIsInstance(side_effect, type(iter([])))
-
-        mock.side_effect = ['a', 'b', 'c']
-        self.assertEqual([mock(), mock(), mock()], ['a', 'b', 'c'])
-        self.assertRaises(StopIteration, mock)
-        side_effect = mock.side_effect
-        self.assertIsInstance(side_effect, type(iter([])))
-
-        this_iter = Iter()
-        mock.side_effect = this_iter
-        self.assertEqual([mock(), mock(), mock(), mock()],
-                         ['this', 'is', 'an', 'iter'])
-        self.assertRaises(StopIteration, mock)
-        self.assertIs(mock.side_effect, this_iter)
-
-    def test_side_effect_iterator_default(self):
-        mock = Mock(return_value=2)
-        mock.side_effect = iter([1, DEFAULT])
-        self.assertEqual([mock(), mock()], [1, 2])
-
-    def test_assert_has_calls_any_order(self):
-        mock = Mock()
-        mock(1, 2)
-        mock(a=3)
-        mock(3, 4)
-        mock(b=6)
-        mock(b=6)
-
-        kalls = [
-            call(1, 2), ({'a': 3},),
-            ((3, 4),), ((), {'a': 3}),
-            ('', (1, 2)), ('', {'a': 3}),
-            ('', (1, 2), {}), ('', (), {'a': 3})
-        ]
-        for kall in kalls:
-            mock.assert_has_calls([kall], any_order=True)
-
-        for kall in call(1, '2'), call(b=3), call(), 3, None, 'foo':
-            self.assertRaises(
-                AssertionError, mock.assert_has_calls,
-                [kall], any_order=True
-            )
-
-        kall_lists = [
-            [call(1, 2), call(b=6)],
-            [call(3, 4), call(1, 2)],
-            [call(b=6), call(b=6)],
-        ]
-
-        for kall_list in kall_lists:
-            mock.assert_has_calls(kall_list, any_order=True)
-
-        kall_lists = [
-            [call(b=6), call(b=6), call(b=6)],
-            [call(1, 2), call(1, 2)],
-            [call(3, 4), call(1, 2), call(5, 7)],
-            [call(b=6), call(3, 4), call(b=6), call(1, 2), call(b=6)],
-        ]
-        for kall_list in kall_lists:
-            self.assertRaises(
-                AssertionError, mock.assert_has_calls,
-                kall_list, any_order=True
-            )
-
-    def test_assert_has_calls(self):
-        kalls1 = [
-                call(1, 2), ({'a': 3},),
-                ((3, 4),), call(b=6),
-                ('', (1,), {'b': 6}),
-        ]
-        kalls2 = [call.foo(), call.bar(1)]
-        kalls2.extend(call.spam().baz(a=3).call_list())
-        kalls2.extend(call.bam(set(), foo={}).fish([1]).call_list())
-
-        mocks = []
-        for mock in Mock(), MagicMock():
-            mock(1, 2)
-            mock(a=3)
-            mock(3, 4)
-            mock(b=6)
-            mock(1, b=6)
-            mocks.append((mock, kalls1))
-
-        mock = Mock()
-        mock.foo()
-        mock.bar(1)
-        mock.spam().baz(a=3)
-        mock.bam(set(), foo={}).fish([1])
-        mocks.append((mock, kalls2))
-
-        for mock, kalls in mocks:
-            for i in range(len(kalls)):
-                for step in 1, 2, 3:
-                    these = kalls[i:i+step]
-                    mock.assert_has_calls(these)
-
-                    if len(these) > 1:
-                        self.assertRaises(
-                            AssertionError,
-                            mock.assert_has_calls,
-                            list(reversed(these))
-                        )
-
-
-    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
-
-        mock = Mock(spec=f)
-
-        mock(1, b=2, c=3)
-        mock(4, 5, c=6, d=7)
-        mock(10, 11, c=12)
-        calls = [
-            ('', (1, 2, 3), {}),
-            ('', (4, 5, 6), {'d': 7}),
-            ((10, 11, 12), {}),
-            ]
-        mock.assert_has_calls(calls)
-        mock.assert_has_calls(calls, any_order=True)
-        mock.assert_has_calls(calls[1:])
-        mock.assert_has_calls(calls[1:], any_order=True)
-        mock.assert_has_calls(calls[:-1])
-        mock.assert_has_calls(calls[:-1], any_order=True)
-        # Reversed order
-        calls = list(reversed(calls))
-        with self.assertRaises(AssertionError):
-            mock.assert_has_calls(calls)
-        mock.assert_has_calls(calls, any_order=True)
-        with self.assertRaises(AssertionError):
-            mock.assert_has_calls(calls[1:])
-        mock.assert_has_calls(calls[1:], any_order=True)
-        with self.assertRaises(AssertionError):
-            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()
-        mock(1, 2)
-        mock(a=3)
-        mock(1, b=6)
-
-        mock.assert_any_call(1, 2)
-        mock.assert_any_call(a=3)
-        mock.assert_any_call(1, b=6)
-
-        self.assertRaises(
-            AssertionError,
-            mock.assert_any_call
-        )
-        self.assertRaises(
-            AssertionError,
-            mock.assert_any_call,
-            1, 3
-        )
-        self.assertRaises(
-            AssertionError,
-            mock.assert_any_call,
-            a=4
-        )
-
-
-    def test_assert_any_call_with_function_spec(self):
-        def f(a, b, c, d=None): pass
-
-        mock = Mock(spec=f)
-
-        mock(1, b=2, c=3)
-        mock(4, 5, c=6, d=7)
-        mock.assert_any_call(1, 2, 3)
-        mock.assert_any_call(a=1, b=2, c=3)
-        mock.assert_any_call(4, 5, 6, 7)
-        mock.assert_any_call(a=4, b=5, c=6, d=7)
-        self.assertRaises(AssertionError, mock.assert_any_call,
-                          1, b=3, c=2)
-        # 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)
-
-
-    def test_mock_calls_create_autospec(self):
-        def f(a, b): pass
-        obj = Iter()
-        obj.f = f
-
-        funcs = [
-            create_autospec(f),
-            create_autospec(obj).f
-        ]
-        for func in funcs:
-            func(1, 2)
-            func(3, 4)
-
-            self.assertEqual(
-                func.mock_calls, [call(1, 2), call(3, 4)]
-            )
-
-    #Issue21222
-    def test_create_autospec_with_name(self):
-        m = mock.create_autospec(object(), name='sweet_func')
-        self.assertIn('sweet_func', repr(m))
-
-    #Issue23078
-    def test_create_autospec_classmethod_and_staticmethod(self):
-        class TestClass:
-            @classmethod
-            def class_method(cls): pass
-
-            @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()
-                self.assertRaises(TypeError, mock_method, 'extra_arg')
-
-    #Issue21238
-    def test_mock_unsafe(self):
-        m = Mock()
-        msg = "Attributes cannot start with 'assert' or 'assret'"
-        with self.assertRaisesRegex(AttributeError, msg):
-            m.assert_foo_call()
-        with self.assertRaisesRegex(AttributeError, msg):
-            m.assret_foo_call()
-        m = Mock(unsafe=True)
-        m.assert_foo_call()
-        m.assret_foo_call()
-
-    #Issue21262
-    def test_assert_not_called(self):
-        m = Mock()
-        m.hello.assert_not_called()
-        m.hello()
-        with self.assertRaises(AssertionError):
-            m.hello.assert_not_called()
-
-    def test_assert_not_called_message(self):
-        m = Mock()
-        m(1, 2)
-        self.assertRaisesRegex(AssertionError,
-            re.escape("Calls: [call(1, 2)]"),
-            m.assert_not_called)
-
-    def test_assert_called(self):
-        m = Mock()
-        with self.assertRaises(AssertionError):
-            m.hello.assert_called()
-        m.hello()
-        m.hello.assert_called()
-
-        m.hello()
-        m.hello.assert_called()
-
-    def test_assert_called_once(self):
-        m = Mock()
-        with self.assertRaises(AssertionError):
-            m.hello.assert_called_once()
-        m.hello()
-        m.hello.assert_called_once()
-
-        m.hello()
-        with self.assertRaises(AssertionError):
-            m.hello.assert_called_once()
-
-    def test_assert_called_once_message(self):
-        m = Mock()
-        m(1, 2)
-        m(3)
-        self.assertRaisesRegex(AssertionError,
-            re.escape("Calls: [call(1, 2), call(3)]"),
-            m.assert_called_once)
-
-    def test_assert_called_once_message_not_called(self):
-        m = Mock()
-        with self.assertRaises(AssertionError) as e:
-            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):
-        m = Mock()
-        m.hello(name='hello', daddy='hero')
-        text = "call(name='hello', daddy='hero')"
-        self.assertEqual(repr(m.hello.call_args), text)
-
-    #Issue21270 overrides tuple methods for mock.call objects
-    def test_override_tuple_methods(self):
-        c = call.count()
-        i = call.index(132,'hello')
-        m = Mock()
-        m.count()
-        m.index(132,"hello")
-        self.assertEqual(m.method_calls[0], c)
-        self.assertEqual(m.method_calls[1], i)
-
-    def test_reset_return_sideeffect(self):
-        m = Mock(return_value=10, side_effect=[2,3])
-        m.reset_mock(return_value=True, side_effect=True)
-        self.assertIsInstance(m.return_value, Mock)
-        self.assertEqual(m.side_effect, None)
-
-    def test_reset_return(self):
-        m = Mock(return_value=10, side_effect=[2,3])
-        m.reset_mock(return_value=True)
-        self.assertIsInstance(m.return_value, Mock)
-        self.assertNotEqual(m.side_effect, None)
-
-    def test_reset_sideeffect(self):
-        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
-        class _Two(object):
-            two = 2
-        class Anything(object):
-            one = two = three = 'four'
-
-        klasses = [
-            Mock, MagicMock, NonCallableMock, NonCallableMagicMock
-        ]
-        for Klass in list(klasses):
-            klasses.append(lambda K=Klass: K(spec=Anything))
-            klasses.append(lambda K=Klass: K(spec_set=Anything))
-
-        for Klass in klasses:
-            for kwargs in dict(), dict(spec_set=True):
-                mock = Klass()
-                #no error
-                mock.one, mock.two, mock.three
-
-                for One, Two in [(_One, _Two), (['one'], ['two'])]:
-                    for kwargs in dict(), dict(spec_set=True):
-                        mock.mock_add_spec(One, **kwargs)
-
-                        mock.one
-                        self.assertRaises(
-                            AttributeError, getattr, mock, 'two'
-                        )
-                        self.assertRaises(
-                            AttributeError, getattr, mock, 'three'
-                        )
-                        if 'spec_set' in kwargs:
-                            self.assertRaises(
-                                AttributeError, setattr, mock, 'three', None
-                            )
-
-                        mock.mock_add_spec(Two, **kwargs)
-                        self.assertRaises(
-                            AttributeError, getattr, mock, 'one'
-                        )
-                        mock.two
-                        self.assertRaises(
-                            AttributeError, getattr, mock, 'three'
-                        )
-                        if 'spec_set' in kwargs:
-                            self.assertRaises(
-                                AttributeError, setattr, mock, 'three', None
-                            )
-            # note that creating a mock, setting an instance attribute, and
-            # *then* setting a spec doesn't work. Not the intended use case
-
-
-    def test_mock_add_spec_magic_methods(self):
-        for Klass in MagicMock, NonCallableMagicMock:
-            mock = Klass()
-            int(mock)
-
-            mock.mock_add_spec(object)
-            self.assertRaises(TypeError, int, mock)
-
-            mock = Klass()
-            mock['foo']
-            mock.__int__.return_value =4
-
-            mock.mock_add_spec(int)
-            self.assertEqual(int(mock), 4)
-            self.assertRaises(TypeError, lambda: mock['foo'])
-
-
-    def test_adding_child_mock(self):
-        for Klass in (NonCallableMock, Mock, MagicMock, NonCallableMagicMock,
-                      AsyncMock):
-            mock = Klass()
-
-            mock.foo = Mock()
-            mock.foo()
-
-            self.assertEqual(mock.method_calls, [call.foo()])
-            self.assertEqual(mock.mock_calls, [call.foo()])
-
-            mock = Klass()
-            mock.bar = Mock(name='name')
-            mock.bar()
-            self.assertEqual(mock.method_calls, [])
-            self.assertEqual(mock.mock_calls, [])
-
-            # mock with an existing _new_parent but no name
-            mock = Klass()
-            mock.baz = MagicMock()()
-            mock.baz()
-            self.assertEqual(mock.method_calls, [])
-            self.assertEqual(mock.mock_calls, [])
-
-
-    def test_adding_return_value_mock(self):
-        for Klass in Mock, MagicMock:
-            mock = Klass()
-            mock.return_value = MagicMock()
-
-            mock()()
-            self.assertEqual(mock.mock_calls, [call(), call()()])
-
-
-    def test_manager_mock(self):
-        class Foo(object):
-            one = 'one'
-            two = 'two'
-        manager = Mock()
-        p1 = patch.object(Foo, 'one')
-        p2 = patch.object(Foo, 'two')
-
-        mock_one = p1.start()
-        self.addCleanup(p1.stop)
-        mock_two = p2.start()
-        self.addCleanup(p2.stop)
-
-        manager.attach_mock(mock_one, 'one')
-        manager.attach_mock(mock_two, 'two')
-
-        Foo.two()
-        Foo.one()
-
-        self.assertEqual(manager.mock_calls, [call.two(), call.one()])
-
-
-    def test_magic_methods_mock_calls(self):
-        for Klass in Mock, MagicMock:
-            m = Klass()
-            m.__int__ = Mock(return_value=3)
-            m.__float__ = MagicMock(return_value=3.0)
-            int(m)
-            float(m)
-
-            self.assertEqual(m.mock_calls, [call.__int__(), call.__float__()])
-            self.assertEqual(m.method_calls, [])
-
-    def test_mock_open_reuse_issue_21750(self):
-        mocked_open = mock.mock_open(read_data='data')
-        f1 = mocked_open('a-name')
-        f1_data = f1.read()
-        f2 = mocked_open('another-name')
-        f2_data = f2.read()
-        self.assertEqual(f1_data, f2_data)
-
-    def test_mock_open_dunder_iter_issue(self):
-        # Test dunder_iter method generates the expected result and
-        # consumes the iterator.
-        mocked_open = mock.mock_open(read_data='Remarkable\nNorwegian Blue')
-        f1 = mocked_open('a-name')
-        lines = [line for line in f1]
-        self.assertEqual(lines[0], 'Remarkable\n')
-        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'))
-        with mock.patch('tempfile.NamedTemporaryFile', mock_namedtemp):
-            mock_filehandle = mock_namedtemp.return_value
-            mock_write = mock_filehandle.write
-            mock_write.side_effect = OSError('Test 2 Error')
-            def attempt():
-                tempfile.NamedTemporaryFile().write('asd')
-            self.assertRaises(OSError, attempt)
-
-    def test_mock_open_alter_readline(self):
-        mopen = mock.mock_open(read_data='foo\nbarn')
-        mopen.return_value.readline.side_effect = lambda *args:'abc'
-        first = mopen().readline()
-        second = mopen().readline()
-        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')
-        h = _open('bar')
-        h.read()
-        self.assertEqual('', h.read())
-        self.assertEqual('', h.read())
-        self.assertEqual('', h.readline())
-        self.assertEqual('', h.readline())
-        self.assertEqual([], h.readlines())
-        self.assertEqual([], h.readlines())
-
-    def test_mock_parents(self):
-        for Klass in Mock, MagicMock:
-            m = Klass()
-            original_repr = repr(m)
-            m.return_value = m
-            self.assertIs(m(), m)
-            self.assertEqual(repr(m), original_repr)
-
-            m.reset_mock()
-            self.assertIs(m(), m)
-            self.assertEqual(repr(m), original_repr)
-
-            m = Klass()
-            m.b = m.a
-            self.assertIn("name='mock.a'", repr(m.b))
-            self.assertIn("name='mock.a'", repr(m.a))
-            m.reset_mock()
-            self.assertIn("name='mock.a'", repr(m.b))
-            self.assertIn("name='mock.a'", repr(m.a))
-
-            m = Klass()
-            original_repr = repr(m)
-            m.a = m()
-            m.a.return_value = m
-
-            self.assertEqual(repr(m), original_repr)
-            self.assertEqual(repr(m.a()), original_repr)
-
-
-    def test_attach_mock(self):
-        classes = Mock, MagicMock, NonCallableMagicMock, NonCallableMock
-        for Klass in classes:
-            for Klass2 in classes:
-                m = Klass()
-
-                m2 = Klass2(name='foo')
-                m.attach_mock(m2, 'bar')
-
-                self.assertIs(m.bar, m2)
-                self.assertIn("name='mock.bar'", repr(m2))
-
-                m.bar.baz(1)
-                self.assertEqual(m.mock_calls, [call.bar.baz(1)])
-                self.assertEqual(m.method_calls, [call.bar.baz(1)])
-
-
-    def test_attach_mock_return_value(self):
-        classes = Mock, MagicMock, NonCallableMagicMock, NonCallableMock
-        for Klass in Mock, MagicMock:
-            for Klass2 in classes:
-                m = Klass()
-
-                m2 = Klass2(name='foo')
-                m.attach_mock(m2, 'return_value')
-
-                self.assertIs(m(), m2)
-                self.assertIn("name='mock()'", repr(m2))
-
-                m2.foo()
-                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()):
-            self.assertTrue(hasattr(mock, 'm'))
-
-            del mock.m
-            self.assertFalse(hasattr(mock, 'm'))
-
-            del mock.f
-            self.assertFalse(hasattr(mock, 'f'))
-            self.assertRaises(AttributeError, getattr, mock, 'f')
-
-
-    def test_mock_does_not_raise_on_repeated_attribute_deletion(self):
-        # bpo-20239: Assigning and deleting twice an attribute raises.
-        for mock in (Mock(), MagicMock(), NonCallableMagicMock(),
-                     NonCallableMock()):
-            mock.foo = 3
-            self.assertTrue(hasattr(mock, 'foo'))
-            self.assertEqual(mock.foo, 3)
-
-            del mock.foo
-            self.assertFalse(hasattr(mock, 'foo'))
-
-            mock.foo = 4
-            self.assertTrue(hasattr(mock, 'foo'))
-            self.assertEqual(mock.foo, 4)
-
-            del mock.foo
-            self.assertFalse(hasattr(mock, 'foo'))
-
-
-    def test_mock_raises_when_deleting_nonexistent_attribute(self):
-        for mock in (Mock(), MagicMock(), NonCallableMagicMock(),
-                     NonCallableMock()):
-            del mock.foo
-            with self.assertRaises(AttributeError):
-                del mock.foo
-
-
-    def test_reset_mock_does_not_raise_on_attr_deletion(self):
-        # bpo-31177: reset_mock should not raise AttributeError when attributes
-        # were deleted in a mock instance
-        mock = Mock()
-        mock.child = True
-        del mock.child
-        mock.reset_mock()
-        self.assertFalse(hasattr(mock, 'child'))
-
-
-    def test_class_assignable(self):
-        for mock in Mock(), MagicMock():
-            self.assertNotIsInstance(mock, int)
-
-            mock.__class__ = int
-            self.assertIsInstance(mock, int)
-            mock.foo
-
-    def test_name_attribute_of_call(self):
-        # bpo-35357: _Call should not disclose any attributes whose names
-        # may clash with popular ones (such as ".name")
-        self.assertIsNotNone(call.name)
-        self.assertEqual(type(call.name), _Call)
-        self.assertEqual(type(call.name().name), _Call)
-
-    def test_parent_attribute_of_call(self):
-        # bpo-35357: _Call should not disclose any attributes whose names
-        # may clash with popular ones (such as ".parent")
-        self.assertIsNotNone(call.parent)
-        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__
-        # property defined when it's used with sys.settrace(trace) set.
-        # Delete the module to force reimport with tracing function set
-        # restore the old reference later since there are other tests that are
-        # 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
-
-        # 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),
-                        old_patch)
-
-        with patch.dict('sys.modules'):
-            del sys.modules['unittest.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 (
-                Mock, MagicMock, NonCallableMock, NonCallableMagicMock
-            )
-
-            mocks = [
-                Mock, MagicMock, NonCallableMock, NonCallableMagicMock, AsyncMock
-            ]
-
-            for mock in mocks:
-                obj = mock(spec=Something)
-                self.assertIsInstance(obj, Something)
-
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/lib/mock/tests/testpatch.py b/lib/mock/tests/testpatch.py
deleted file mode 100644
index fbf4a537..00000000
--- a/lib/mock/tests/testpatch.py
+++ /dev/null
@@ -1,1947 +0,0 @@
-# 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 os
-import sys
-from collections import OrderedDict
-
-import unittest
-from mock.tests import support
-from mock.tests.support import SomeClass, is_instance
-
-from .support import uncache
-from mock import (
-    NonCallableMock, sentinel,
-    MagicMock, Mock, NonCallableMagicMock, patch,
-    DEFAULT, call
-)
-from mock.mock import CallableMixin, _patch, _get_target
-
-builtin_string = 'builtins'
-
-PTModule = sys.modules[__name__]
-MODNAME = '%s.PTModule' % __name__
-
-
-def _get_proxy(obj, get_only=True):
-    class Proxy(object):
-        def __getattr__(self, name):
-            return getattr(obj, name)
-    if not get_only:
-        def __setattr__(self, name, value):
-            setattr(obj, name, value)
-        def __delattr__(self, name):
-            delattr(obj, name)
-        Proxy.__setattr__ = __setattr__
-        Proxy.__delattr__ = __delattr__
-    return Proxy()
-
-
-# for use in the test
-something  = sentinel.Something
-something_else  = sentinel.SomethingElse
-
-
-class Foo(object):
-    def __init__(self, a): pass
-    def f(self, a): pass
-    def g(self): pass
-    foo = 'bar'
-
-    @staticmethod
-    def static_method(): pass
-
-    @classmethod
-    def class_method(cls): pass
-
-    class Bar(object):
-        def a(self): pass
-
-foo_name = '%s.Foo' % __name__
-
-
-def function(a, b=Foo): pass
-
-
-class Container(object):
-    def __init__(self):
-        self.values = {}
-
-    def __getitem__(self, name):
-        return self.values[name]
-
-    def __setitem__(self, name, value):
-        self.values[name] = value
-
-    def __delitem__(self, name):
-        del self.values[name]
-
-    def __iter__(self):
-        return iter(self.values)
-
-
-
-class PatchTest(unittest.TestCase):
-
-    def assertNotCallable(self, obj, magic=True):
-        MockClass = NonCallableMagicMock
-        if not magic:
-            MockClass = NonCallableMock
-
-        self.assertRaises(TypeError, obj)
-        self.assertTrue(is_instance(obj, MockClass))
-        self.assertFalse(is_instance(obj, CallableMixin))
-
-
-    def test_single_patchobject(self):
-        class Something(object):
-            attribute = sentinel.Original
-
-        @patch.object(Something, 'attribute', sentinel.Patched)
-        def test():
-            self.assertEqual(Something.attribute, sentinel.Patched, "unpatched")
-
-        test()
-        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):
-            attribute = sentinel.Original
-
-        @patch.object(Something, 'attribute', None)
-        def test():
-            self.assertIsNone(Something.attribute, "unpatched")
-
-        test()
-        self.assertEqual(Something.attribute, sentinel.Original,
-                         "patch not restored")
-
-
-    def test_multiple_patchobject(self):
-        class Something(object):
-            attribute = sentinel.Original
-            next_attribute = sentinel.Original2
-
-        @patch.object(Something, 'attribute', sentinel.Patched)
-        @patch.object(Something, 'next_attribute', sentinel.Patched2)
-        def test():
-            self.assertEqual(Something.attribute, sentinel.Patched,
-                             "unpatched")
-            self.assertEqual(Something.next_attribute, sentinel.Patched2,
-                             "unpatched")
-
-        test()
-        self.assertEqual(Something.attribute, sentinel.Original,
-                         "patch not restored")
-        self.assertEqual(Something.next_attribute, sentinel.Original2,
-                         "patch not restored")
-
-
-    def test_object_lookup_is_quite_lazy(self):
-        global something
-        original = something
-        @patch('%s.something' % __name__, sentinel.Something2)
-        def test():
-            pass
-
-        try:
-            something = sentinel.replacement_value
-            test()
-            self.assertEqual(something, sentinel.replacement_value)
-        finally:
-            something = original
-
-
-    def test_patch(self):
-        @patch('%s.something' % __name__, sentinel.Something2)
-        def test():
-            self.assertEqual(PTModule.something, sentinel.Something2,
-                             "unpatched")
-
-        test()
-        self.assertEqual(PTModule.something, sentinel.Something,
-                         "patch not restored")
-
-        @patch('%s.something' % __name__, sentinel.Something2)
-        @patch('%s.something_else' % __name__, sentinel.SomethingElse)
-        def test():
-            self.assertEqual(PTModule.something, sentinel.Something2,
-                             "unpatched")
-            self.assertEqual(PTModule.something_else, sentinel.SomethingElse,
-                             "unpatched")
-
-        self.assertEqual(PTModule.something, sentinel.Something,
-                         "patch not restored")
-        self.assertEqual(PTModule.something_else, sentinel.SomethingElse,
-                         "patch not restored")
-
-        # Test the patching and restoring works a second time
-        test()
-
-        self.assertEqual(PTModule.something, sentinel.Something,
-                         "patch not restored")
-        self.assertEqual(PTModule.something_else, sentinel.SomethingElse,
-                         "patch not restored")
-
-        mock = Mock()
-        mock.return_value = sentinel.Handle
-        @patch('%s.open' % builtin_string, mock)
-        def test():
-            self.assertEqual(open('filename', 'r'), sentinel.Handle,
-                             "open not patched")
-        test()
-        test()
-
-        self.assertNotEqual(open, mock, "patch not restored")
-
-
-    def test_patch_class_attribute(self):
-        @patch('%s.SomeClass.class_attribute' % __name__,
-               sentinel.ClassAttribute)
-        def test():
-            self.assertEqual(PTModule.SomeClass.class_attribute,
-                             sentinel.ClassAttribute, "unpatched")
-        test()
-
-        self.assertIsNone(PTModule.SomeClass.class_attribute,
-                          "patch not restored")
-
-
-    def test_patchobject_with_default_mock(self):
-        class Test(object):
-            something = sentinel.Original
-            something2 = sentinel.Original2
-
-        @patch.object(Test, 'something')
-        def test(mock):
-            self.assertEqual(mock, Test.something,
-                             "Mock not passed into test function")
-            self.assertIsInstance(mock, MagicMock,
-                            "patch with two arguments did not create a mock")
-
-        test()
-
-        @patch.object(Test, 'something')
-        @patch.object(Test, 'something2')
-        def test(this1, this2, mock1, mock2):
-            self.assertEqual(this1, sentinel.this1,
-                             "Patched function didn't receive initial argument")
-            self.assertEqual(this2, sentinel.this2,
-                             "Patched function didn't receive second argument")
-            self.assertEqual(mock1, Test.something2,
-                             "Mock not passed into test function")
-            self.assertEqual(mock2, Test.something,
-                             "Second Mock not passed into test function")
-            self.assertIsInstance(mock2, MagicMock,
-                            "patch with two arguments did not create a mock")
-            self.assertIsInstance(mock2, MagicMock,
-                            "patch with two arguments did not create a mock")
-
-            # A hack to test that new mocks are passed the second time
-            self.assertNotEqual(outerMock1, mock1, "unexpected value for mock1")
-            self.assertNotEqual(outerMock2, mock2, "unexpected value for mock1")
-            return mock1, mock2
-
-        outerMock1 = outerMock2 = None
-        outerMock1, outerMock2 = test(sentinel.this1, sentinel.this2)
-
-        # Test that executing a second time creates new mocks
-        test(sentinel.this1, sentinel.this2)
-
-
-    def test_patch_with_spec(self):
-        @patch('%s.SomeClass' % __name__, spec=SomeClass)
-        def test(MockSomeClass):
-            self.assertEqual(SomeClass, MockSomeClass)
-            self.assertTrue(is_instance(SomeClass.wibble, MagicMock))
-            self.assertRaises(AttributeError, lambda: SomeClass.not_wibble)
-
-        test()
-
-
-    def test_patchobject_with_spec(self):
-        @patch.object(SomeClass, 'class_attribute', spec=SomeClass)
-        def test(MockAttribute):
-            self.assertEqual(SomeClass.class_attribute, MockAttribute)
-            self.assertTrue(is_instance(SomeClass.class_attribute.wibble,
-                                       MagicMock))
-            self.assertRaises(AttributeError,
-                              lambda: SomeClass.class_attribute.not_wibble)
-
-        test()
-
-
-    def test_patch_with_spec_as_list(self):
-        @patch('%s.SomeClass' % __name__, spec=['wibble'])
-        def test(MockSomeClass):
-            self.assertEqual(SomeClass, MockSomeClass)
-            self.assertTrue(is_instance(SomeClass.wibble, MagicMock))
-            self.assertRaises(AttributeError, lambda: SomeClass.not_wibble)
-
-        test()
-
-
-    def test_patchobject_with_spec_as_list(self):
-        @patch.object(SomeClass, 'class_attribute', spec=['wibble'])
-        def test(MockAttribute):
-            self.assertEqual(SomeClass.class_attribute, MockAttribute)
-            self.assertTrue(is_instance(SomeClass.class_attribute.wibble,
-                                       MagicMock))
-            self.assertRaises(AttributeError,
-                              lambda: SomeClass.class_attribute.not_wibble)
-
-        test()
-
-
-    def test_nested_patch_with_spec_as_list(self):
-        # regression test for nested decorators
-        @patch('%s.open' % builtin_string)
-        @patch('%s.SomeClass' % __name__, spec=['wibble'])
-        def test(MockSomeClass, MockOpen):
-            self.assertEqual(SomeClass, MockSomeClass)
-            self.assertTrue(is_instance(SomeClass.wibble, MagicMock))
-            self.assertRaises(AttributeError, lambda: SomeClass.not_wibble)
-        test()
-
-
-    def test_patch_with_spec_as_boolean(self):
-        @patch('%s.SomeClass' % __name__, spec=True)
-        def test(MockSomeClass):
-            self.assertEqual(SomeClass, MockSomeClass)
-            # Should not raise attribute error
-            MockSomeClass.wibble
-
-            self.assertRaises(AttributeError, lambda: MockSomeClass.not_wibble)
-
-        test()
-
-
-    def test_patch_object_with_spec_as_boolean(self):
-        @patch.object(PTModule, 'SomeClass', spec=True)
-        def test(MockSomeClass):
-            self.assertEqual(SomeClass, MockSomeClass)
-            # Should not raise attribute error
-            MockSomeClass.wibble
-
-            self.assertRaises(AttributeError, lambda: MockSomeClass.not_wibble)
-
-        test()
-
-
-    def test_patch_class_acts_with_spec_is_inherited(self):
-        @patch('%s.SomeClass' % __name__, spec=True)
-        def test(MockSomeClass):
-            self.assertTrue(is_instance(MockSomeClass, MagicMock))
-            instance = MockSomeClass()
-            self.assertNotCallable(instance)
-            # Should not raise attribute error
-            instance.wibble
-
-            self.assertRaises(AttributeError, lambda: instance.not_wibble)
-
-        test()
-
-
-    def test_patch_with_create_mocks_non_existent_attributes(self):
-        @patch('%s.frooble' % builtin_string, sentinel.Frooble, create=True)
-        def test():
-            self.assertEqual(frooble, sentinel.Frooble)
-
-        test()
-        self.assertRaises(NameError, lambda: frooble)
-
-
-    def test_patchobject_with_create_mocks_non_existent_attributes(self):
-        @patch.object(SomeClass, 'frooble', sentinel.Frooble, create=True)
-        def test():
-            self.assertEqual(SomeClass.frooble, sentinel.Frooble)
-
-        test()
-        self.assertFalse(hasattr(SomeClass, 'frooble'))
-
-
-    def test_patch_wont_create_by_default(self):
-        with self.assertRaises(AttributeError):
-            @patch('%s.frooble' % builtin_string, sentinel.Frooble)
-            def test(): pass
-
-            test()
-        self.assertRaises(NameError, lambda: frooble)
-
-
-    def test_patchobject_wont_create_by_default(self):
-        with self.assertRaises(AttributeError):
-            @patch.object(SomeClass, 'ord', sentinel.Frooble)
-            def test(): pass
-            test()
-        self.assertFalse(hasattr(SomeClass, 'ord'))
-
-
-    def test_patch_builtins_without_create(self):
-        @patch(__name__+'.ord')
-        def test_ord(mock_ord):
-            mock_ord.return_value = 101
-            return ord('c')
-
-        @patch(__name__+'.open')
-        def test_open(mock_open):
-            m = mock_open.return_value
-            m.read.return_value = 'abcd'
-
-            fobj = open('doesnotexists.txt')
-            data = fobj.read()
-            fobj.close()
-            return data
-
-        self.assertEqual(test_ord(), 101)
-        self.assertEqual(test_open(), 'abcd')
-
-
-    def test_patch_with_static_methods(self):
-        class Foo(object):
-            @staticmethod
-            def woot():
-                return sentinel.Static
-
-        @patch.object(Foo, 'woot', staticmethod(lambda: sentinel.Patched))
-        def anonymous():
-            self.assertEqual(Foo.woot(), sentinel.Patched)
-        anonymous()
-
-        self.assertEqual(Foo.woot(), sentinel.Static)
-
-
-    def test_patch_local(self):
-        foo = sentinel.Foo
-        @patch.object(sentinel, 'Foo', 'Foo')
-        def anonymous():
-            self.assertEqual(sentinel.Foo, 'Foo')
-        anonymous()
-
-        self.assertEqual(sentinel.Foo, foo)
-
-
-    def test_patch_slots(self):
-        class Foo(object):
-            __slots__ = ('Foo',)
-
-        foo = Foo()
-        foo.Foo = sentinel.Foo
-
-        @patch.object(foo, 'Foo', 'Foo')
-        def anonymous():
-            self.assertEqual(foo.Foo, 'Foo')
-        anonymous()
-
-        self.assertEqual(foo.Foo, sentinel.Foo)
-
-
-    def test_patchobject_class_decorator(self):
-        class Something(object):
-            attribute = sentinel.Original
-
-        class Foo(object):
-            def test_method(other_self):
-                self.assertEqual(Something.attribute, sentinel.Patched,
-                                 "unpatched")
-            def not_test_method(other_self):
-                self.assertEqual(Something.attribute, sentinel.Original,
-                                 "non-test method patched")
-
-        Foo = patch.object(Something, 'attribute', sentinel.Patched)(Foo)
-
-        f = Foo()
-        f.test_method()
-        f.not_test_method()
-
-        self.assertEqual(Something.attribute, sentinel.Original,
-                         "patch not restored")
-
-
-    def test_patch_class_decorator(self):
-        class Something(object):
-            attribute = sentinel.Original
-
-        class Foo(object):
-
-            test_class_attr = 'whatever'
-
-            def test_method(other_self, mock_something):
-                self.assertEqual(PTModule.something, mock_something,
-                                 "unpatched")
-            def not_test_method(other_self):
-                self.assertEqual(PTModule.something, sentinel.Something,
-                                 "non-test method patched")
-        Foo = patch('%s.something' % __name__)(Foo)
-
-        f = Foo()
-        f.test_method()
-        f.not_test_method()
-
-        self.assertEqual(Something.attribute, sentinel.Original,
-                         "patch not restored")
-        self.assertEqual(PTModule.something, sentinel.Something,
-                         "patch not restored")
-
-
-    def test_patchobject_twice(self):
-        class Something(object):
-            attribute = sentinel.Original
-            next_attribute = sentinel.Original2
-
-        @patch.object(Something, 'attribute', sentinel.Patched)
-        @patch.object(Something, 'attribute', sentinel.Patched)
-        def test():
-            self.assertEqual(Something.attribute, sentinel.Patched, "unpatched")
-
-        test()
-
-        self.assertEqual(Something.attribute, sentinel.Original,
-                         "patch not restored")
-
-
-    def test_patch_dict(self):
-        foo = {'initial': object(), 'other': 'something'}
-        original = foo.copy()
-
-        @patch.dict(foo)
-        def test():
-            foo['a'] = 3
-            del foo['initial']
-            foo['other'] = 'something else'
-
-        test()
-
-        self.assertEqual(foo, original)
-
-        @patch.dict(foo, {'a': 'b'})
-        def test():
-            self.assertEqual(len(foo), 3)
-            self.assertEqual(foo['a'], 'b')
-
-        test()
-
-        self.assertEqual(foo, original)
-
-        @patch.dict(foo, [('a', 'b')])
-        def test():
-            self.assertEqual(len(foo), 3)
-            self.assertEqual(foo['a'], 'b')
-
-        test()
-
-        self.assertEqual(foo, original)
-
-
-    def test_patch_dict_with_container_object(self):
-        foo = Container()
-        foo['initial'] = object()
-        foo['other'] =  'something'
-
-        original = foo.values.copy()
-
-        @patch.dict(foo)
-        def test():
-            foo['a'] = 3
-            del foo['initial']
-            foo['other'] = 'something else'
-
-        test()
-
-        self.assertEqual(foo.values, original)
-
-        @patch.dict(foo, {'a': 'b'})
-        def test():
-            self.assertEqual(len(foo.values), 3)
-            self.assertEqual(foo['a'], 'b')
-
-        test()
-
-        self.assertEqual(foo.values, original)
-
-
-    def test_patch_dict_with_clear(self):
-        foo = {'initial': object(), 'other': 'something'}
-        original = foo.copy()
-
-        @patch.dict(foo, clear=True)
-        def test():
-            self.assertEqual(foo, {})
-            foo['a'] = 3
-            foo['other'] = 'something else'
-
-        test()
-
-        self.assertEqual(foo, original)
-
-        @patch.dict(foo, {'a': 'b'}, clear=True)
-        def test():
-            self.assertEqual(foo, {'a': 'b'})
-
-        test()
-
-        self.assertEqual(foo, original)
-
-        @patch.dict(foo, [('a', 'b')], clear=True)
-        def test():
-            self.assertEqual(foo, {'a': 'b'})
-
-        test()
-
-        self.assertEqual(foo, original)
-
-
-    def test_patch_dict_with_container_object_and_clear(self):
-        foo = Container()
-        foo['initial'] = object()
-        foo['other'] =  'something'
-
-        original = foo.values.copy()
-
-        @patch.dict(foo, clear=True)
-        def test():
-            self.assertEqual(foo.values, {})
-            foo['a'] = 3
-            foo['other'] = 'something else'
-
-        test()
-
-        self.assertEqual(foo.values, original)
-
-        @patch.dict(foo, {'a': 'b'}, clear=True)
-        def test():
-            self.assertEqual(foo.values, {'a': 'b'})
-
-        test()
-
-        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 = {}
-
-        @patch('%s.SomeClass' % __name__, object())
-        @patch('%s.SomeClass' % __name__, object(), autospec=True)
-        @patch.object(SomeClass, object())
-        @patch.dict(foo)
-        def some_name(): pass
-
-        self.assertEqual(some_name.__name__, 'some_name')
-
-
-    def test_patch_with_exception(self):
-        foo = {}
-
-        @patch.dict(foo, {'a': 'b'})
-        def test():
-            raise NameError('Konrad')
-
-        with self.assertRaises(NameError):
-            test()
-
-        self.assertEqual(foo, {})
-
-
-    def test_patch_dict_with_string(self):
-        @patch.dict('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()
-            self.assertEqual(support.target, {'foo': 'BAZ'})
-        finally:
-            support.target = original
-
-
-    def test_patch_spec_set(self):
-        @patch('%s.SomeClass' % __name__, spec=SomeClass, spec_set=True)
-        def test(MockClass):
-            MockClass.z = 'foo'
-
-        self.assertRaises(AttributeError, test)
-
-        @patch.object(support, 'SomeClass', spec=SomeClass, spec_set=True)
-        def test(MockClass):
-            MockClass.z = 'foo'
-
-        self.assertRaises(AttributeError, test)
-        @patch('%s.SomeClass' % __name__, spec_set=True)
-        def test(MockClass):
-            MockClass.z = 'foo'
-
-        self.assertRaises(AttributeError, test)
-
-        @patch.object(support, 'SomeClass', spec_set=True)
-        def test(MockClass):
-            MockClass.z = 'foo'
-
-        self.assertRaises(AttributeError, test)
-
-
-    def test_spec_set_inherit(self):
-        @patch('%s.SomeClass' % __name__, spec_set=True)
-        def test(MockClass):
-            instance = MockClass()
-            instance.z = 'foo'
-
-        self.assertRaises(AttributeError, test)
-
-
-    def test_patch_start_stop(self):
-        original = something
-        patcher = patch('%s.something' % __name__)
-        self.assertIs(something, original)
-        mock = patcher.start()
-        try:
-            self.assertIsNot(mock, original)
-            self.assertIs(something, mock)
-        finally:
-            patcher.stop()
-        self.assertIs(something, original)
-
-
-    def test_stop_without_start(self):
-        # bpo-36366: calling stop without start will return None.
-        patcher = patch(foo_name, 'bar', 3)
-        self.assertIsNone(patcher.stop())
-
-
-    def test_stop_idempotent(self):
-        # bpo-36366: calling stop on an already stopped patch will return None.
-        patcher = patch(foo_name, 'bar', 3)
-
-        patcher.start()
-        patcher.stop()
-        self.assertIsNone(patcher.stop())
-
-
-    def test_patchobject_start_stop(self):
-        original = something
-        patcher = patch.object(PTModule, 'something', 'foo')
-        self.assertIs(something, original)
-        replaced = patcher.start()
-        try:
-            self.assertEqual(replaced, 'foo')
-            self.assertIs(something, replaced)
-        finally:
-            patcher.stop()
-        self.assertIs(something, original)
-
-
-    def test_patch_dict_start_stop(self):
-        d = {'foo': 'bar'}
-        original = d.copy()
-        patcher = patch.dict(d, [('spam', 'eggs')], clear=True)
-        self.assertEqual(d, original)
-
-        patcher.start()
-        try:
-            self.assertEqual(d, {'spam': 'eggs'})
-        finally:
-            patcher.stop()
-        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'}
-        original = d.copy()
-
-        class Test(object):
-            def test_first(self):
-                this.assertEqual(d, {'foo': 'bar'})
-            def test_second(self):
-                this.assertEqual(d, {'foo': 'bar'})
-
-        Test = patch.dict(d, {'foo': 'bar'}, clear=True)(Test)
-        self.assertEqual(d, original)
-
-        test = Test()
-
-        test.test_first()
-        self.assertEqual(d, original)
-
-        test.test_second()
-        self.assertEqual(d, original)
-
-        test = Test()
-
-        test.test_first()
-        self.assertEqual(d, original)
-
-        test.test_second()
-        self.assertEqual(d, original)
-
-
-    def test_get_only_proxy(self):
-        class Something(object):
-            foo = 'foo'
-        class SomethingElse:
-            foo = 'foo'
-
-        for thing in Something, SomethingElse, Something(), SomethingElse:
-            proxy = _get_proxy(thing)
-
-            @patch.object(proxy, 'foo', 'bar')
-            def test():
-                self.assertEqual(proxy.foo, 'bar')
-            test()
-            self.assertEqual(proxy.foo, 'foo')
-            self.assertEqual(thing.foo, 'foo')
-            self.assertNotIn('foo', proxy.__dict__)
-
-
-    def test_get_set_delete_proxy(self):
-        class Something(object):
-            foo = 'foo'
-        class SomethingElse:
-            foo = 'foo'
-
-        for thing in Something, SomethingElse, Something(), SomethingElse:
-            proxy = _get_proxy(Something, get_only=False)
-
-            @patch.object(proxy, 'foo', 'bar')
-            def test():
-                self.assertEqual(proxy.foo, 'bar')
-            test()
-            self.assertEqual(proxy.foo, 'foo')
-            self.assertEqual(thing.foo, 'foo')
-            self.assertNotIn('foo', proxy.__dict__)
-
-
-    def test_patch_keyword_args(self):
-        kwargs = {'side_effect': KeyError, 'foo.bar.return_value': 33,
-                  'foo': MagicMock()}
-
-        patcher = patch(foo_name, **kwargs)
-        mock = patcher.start()
-        patcher.stop()
-
-        self.assertRaises(KeyError, mock)
-        self.assertEqual(mock.foo.bar(), 33)
-        self.assertIsInstance(mock.foo, MagicMock)
-
-
-    def test_patch_object_keyword_args(self):
-        kwargs = {'side_effect': KeyError, 'foo.bar.return_value': 33,
-                  'foo': MagicMock()}
-
-        patcher = patch.object(Foo, 'f', **kwargs)
-        mock = patcher.start()
-        patcher.stop()
-
-        self.assertRaises(KeyError, mock)
-        self.assertEqual(mock.foo.bar(), 33)
-        self.assertIsInstance(mock.foo, MagicMock)
-
-
-    def test_patch_dict_keyword_args(self):
-        original = {'foo': 'bar'}
-        copy = original.copy()
-
-        patcher = patch.dict(original, foo=3, bar=4, baz=5)
-        patcher.start()
-
-        try:
-            self.assertEqual(original, dict(foo=3, bar=4, baz=5))
-        finally:
-            patcher.stop()
-
-        self.assertEqual(original, copy)
-
-
-    def test_autospec(self):
-        class Boo(object):
-            def __init__(self, a): pass
-            def f(self, a): pass
-            def g(self): pass
-            foo = 'bar'
-
-            class Bar(object):
-                def a(self): pass
-
-        def _test(mock):
-            mock(1)
-            mock.assert_called_with(1)
-            self.assertRaises(TypeError, mock)
-
-        def _test2(mock):
-            mock.f(1)
-            mock.f.assert_called_with(1)
-            self.assertRaises(TypeError, mock.f)
-
-            mock.g()
-            mock.g.assert_called_with()
-            self.assertRaises(TypeError, mock.g, 1)
-
-            self.assertRaises(AttributeError, getattr, mock, 'h')
-
-            mock.foo.lower()
-            mock.foo.lower.assert_called_with()
-            self.assertRaises(AttributeError, getattr, mock.foo, 'bar')
-
-            mock.Bar()
-            mock.Bar.assert_called_with()
-
-            mock.Bar.a()
-            mock.Bar.a.assert_called_with()
-            self.assertRaises(TypeError, mock.Bar.a, 1)
-
-            mock.Bar().a()
-            mock.Bar().a.assert_called_with()
-            self.assertRaises(TypeError, mock.Bar().a, 1)
-
-            self.assertRaises(AttributeError, getattr, mock.Bar, 'b')
-            self.assertRaises(AttributeError, getattr, mock.Bar(), 'b')
-
-        def function(mock):
-            _test(mock)
-            _test2(mock)
-            _test2(mock(1))
-            self.assertIs(mock, Foo)
-            return mock
-
-        test = patch(foo_name, autospec=True)(function)
-
-        mock = test()
-        self.assertIsNot(Foo, mock)
-        # test patching a second time works
-        test()
-
-        module = sys.modules[__name__]
-        test = patch.object(module, 'Foo', autospec=True)(function)
-
-        mock = test()
-        self.assertIsNot(Foo, mock)
-        # test patching a second time works
-        test()
-
-
-    def test_autospec_function(self):
-        @patch('%s.function' % __name__, autospec=True)
-        def test(mock):
-            function.assert_not_called()
-            self.assertRaises(AssertionError, function.assert_called)
-            self.assertRaises(AssertionError, function.assert_called_once)
-            function(1)
-            self.assertRaises(AssertionError, function.assert_not_called)
-            function.assert_called_with(1)
-            function.assert_called()
-            function.assert_called_once()
-            function(2, 3)
-            function.assert_called_with(2, 3)
-
-            self.assertRaises(TypeError, function)
-            self.assertRaises(AttributeError, getattr, function, 'foo')
-
-        test()
-
-
-    def test_autospec_keywords(self):
-        @patch('%s.function' % __name__, autospec=True,
-               return_value=3)
-        def test(mock_function):
-            #self.assertEqual(function.abc, 'foo')
-            return function(1, 2)
-
-        result = test()
-        self.assertEqual(result, 3)
-
-
-    def test_autospec_staticmethod(self):
-        with patch('%s.Foo.static_method' % __name__, autospec=True) as method:
-            Foo.static_method()
-            method.assert_called_once_with()
-
-
-    def test_autospec_classmethod(self):
-        with patch('%s.Foo.class_method' % __name__, autospec=True) as method:
-            Foo.class_method()
-            method.assert_called_once_with()
-
-
-    def test_autospec_with_new(self):
-        patcher = patch('%s.function' % __name__, new=3, autospec=True)
-        self.assertRaises(TypeError, patcher.start)
-
-        module = sys.modules[__name__]
-        patcher = patch.object(module, 'function', new=3, autospec=True)
-        self.assertRaises(TypeError, patcher.start)
-
-
-    def test_autospec_with_object(self):
-        class Bar(Foo):
-            extra = []
-
-        patcher = patch(foo_name, autospec=Bar)
-        mock = patcher.start()
-        try:
-            self.assertIsInstance(mock, Bar)
-            self.assertIsInstance(mock.extra, list)
-        finally:
-            patcher.stop()
-
-
-    def test_autospec_inherits(self):
-        FooClass = Foo
-        patcher = patch(foo_name, autospec=True)
-        mock = patcher.start()
-        try:
-            self.assertIsInstance(mock, FooClass)
-            self.assertIsInstance(mock(3), FooClass)
-        finally:
-            patcher.stop()
-
-
-    def test_autospec_name(self):
-        patcher = patch(foo_name, autospec=True)
-        mock = patcher.start()
-
-        try:
-            self.assertIn(" name='Foo'", repr(mock))
-            self.assertIn(" name='Foo.f'", repr(mock.f))
-            self.assertIn(" name='Foo()'", repr(mock(None)))
-            self.assertIn(" name='Foo().f'", repr(mock(None).f))
-        finally:
-            patcher.stop()
-
-
-    def test_tracebacks(self):
-        @patch.object(Foo, 'f', object())
-        def test():
-            raise AssertionError
-        try:
-            test()
-        except:
-            err = sys.exc_info()
-
-        result = unittest.TextTestResult(None, None, 0)
-        traceback = result._exc_info_to_string(err, self)
-        self.assertIn('raise AssertionError', traceback)
-
-
-    def test_new_callable_patch(self):
-        patcher = patch(foo_name, new_callable=NonCallableMagicMock)
-
-        m1 = patcher.start()
-        patcher.stop()
-        m2 = patcher.start()
-        patcher.stop()
-
-        self.assertIsNot(m1, m2)
-        for mock in m1, m2:
-            self.assertNotCallable(m1)
-
-
-    def test_new_callable_patch_object(self):
-        patcher = patch.object(Foo, 'f', new_callable=NonCallableMagicMock)
-
-        m1 = patcher.start()
-        patcher.stop()
-        m2 = patcher.start()
-        patcher.stop()
-
-        self.assertIsNot(m1, m2)
-        for mock in m1, m2:
-            self.assertNotCallable(m1)
-
-
-    def test_new_callable_keyword_arguments(self):
-        class Bar(object):
-            kwargs = None
-            def __init__(self, **kwargs):
-                Bar.kwargs = kwargs
-
-        patcher = patch(foo_name, new_callable=Bar, arg1=1, arg2=2)
-        m = patcher.start()
-        try:
-            self.assertIs(type(m), Bar)
-            self.assertEqual(Bar.kwargs, dict(arg1=1, arg2=2))
-        finally:
-            patcher.stop()
-
-
-    def test_new_callable_spec(self):
-        class Bar(object):
-            kwargs = None
-            def __init__(self, **kwargs):
-                Bar.kwargs = kwargs
-
-        patcher = patch(foo_name, new_callable=Bar, spec=Bar)
-        patcher.start()
-        try:
-            self.assertEqual(Bar.kwargs, dict(spec=Bar))
-        finally:
-            patcher.stop()
-
-        patcher = patch(foo_name, new_callable=Bar, spec_set=Bar)
-        patcher.start()
-        try:
-            self.assertEqual(Bar.kwargs, dict(spec_set=Bar))
-        finally:
-            patcher.stop()
-
-
-    def test_new_callable_create(self):
-        non_existent_attr = '%s.weeeee' % foo_name
-        p = patch(non_existent_attr, new_callable=NonCallableMock)
-        self.assertRaises(AttributeError, p.start)
-
-        p = patch(non_existent_attr, new_callable=NonCallableMock,
-                  create=True)
-        m = p.start()
-        try:
-            self.assertNotCallable(m, magic=False)
-        finally:
-            p.stop()
-
-
-    def test_new_callable_incompatible_with_new(self):
-        self.assertRaises(
-            ValueError, patch, foo_name, new=object(), new_callable=MagicMock
-        )
-        self.assertRaises(
-            ValueError, patch.object, Foo, 'f', new=object(),
-            new_callable=MagicMock
-        )
-
-
-    def test_new_callable_incompatible_with_autospec(self):
-        self.assertRaises(
-            ValueError, patch, foo_name, new_callable=MagicMock,
-            autospec=True
-        )
-        self.assertRaises(
-            ValueError, patch.object, Foo, 'f', new_callable=MagicMock,
-            autospec=True
-        )
-
-
-    def test_new_callable_inherit_for_mocks(self):
-        class MockSub(Mock):
-            pass
-
-        MockClasses = (
-            NonCallableMock, NonCallableMagicMock, MagicMock, Mock, MockSub
-        )
-        for Klass in MockClasses:
-            for arg in 'spec', 'spec_set':
-                kwargs = {arg: True}
-                p = patch(foo_name, new_callable=Klass, **kwargs)
-                m = p.start()
-                try:
-                    instance = m.return_value
-                    self.assertRaises(AttributeError, getattr, instance, 'x')
-                finally:
-                    p.stop()
-
-
-    def test_new_callable_inherit_non_mock(self):
-        class NotAMock(object):
-            def __init__(self, spec):
-                self.spec = spec
-
-        p = patch(foo_name, new_callable=NotAMock, spec=True)
-        m = p.start()
-        try:
-            self.assertTrue(is_instance(m, NotAMock))
-            self.assertRaises(AttributeError, getattr, m, 'return_value')
-        finally:
-            p.stop()
-
-        self.assertEqual(m.spec, Foo)
-
-
-    def test_new_callable_class_decorating(self):
-        test = self
-        original = Foo
-        class SomeTest(object):
-
-            def _test(self, mock_foo):
-                test.assertIsNot(Foo, original)
-                test.assertIs(Foo, mock_foo)
-                test.assertIsInstance(Foo, SomeClass)
-
-            def test_two(self, mock_foo):
-                self._test(mock_foo)
-            def test_one(self, mock_foo):
-                self._test(mock_foo)
-
-        SomeTest = patch(foo_name, new_callable=SomeClass)(SomeTest)
-        SomeTest().test_one()
-        SomeTest().test_two()
-        self.assertIs(Foo, original)
-
-
-    def test_patch_multiple(self):
-        original_foo = Foo
-        original_f = Foo.f
-        original_g = Foo.g
-
-        patcher1 = patch.multiple(foo_name, f=1, g=2)
-        patcher2 = patch.multiple(Foo, f=1, g=2)
-
-        for patcher in patcher1, patcher2:
-            patcher.start()
-            try:
-                self.assertIs(Foo, original_foo)
-                self.assertEqual(Foo.f, 1)
-                self.assertEqual(Foo.g, 2)
-            finally:
-                patcher.stop()
-
-            self.assertIs(Foo, original_foo)
-            self.assertEqual(Foo.f, original_f)
-            self.assertEqual(Foo.g, original_g)
-
-
-        @patch.multiple(foo_name, f=3, g=4)
-        def test():
-            self.assertIs(Foo, original_foo)
-            self.assertEqual(Foo.f, 3)
-            self.assertEqual(Foo.g, 4)
-
-        test()
-
-
-    def test_patch_multiple_no_kwargs(self):
-        self.assertRaises(ValueError, patch.multiple, foo_name)
-        self.assertRaises(ValueError, patch.multiple, Foo)
-
-
-    def test_patch_multiple_create_mocks(self):
-        original_foo = Foo
-        original_f = Foo.f
-        original_g = Foo.g
-
-        @patch.multiple(foo_name, f=DEFAULT, g=3, foo=DEFAULT)
-        def test(f, foo):
-            self.assertIs(Foo, original_foo)
-            self.assertIs(Foo.f, f)
-            self.assertEqual(Foo.g, 3)
-            self.assertIs(Foo.foo, foo)
-            self.assertTrue(is_instance(f, MagicMock))
-            self.assertTrue(is_instance(foo, MagicMock))
-
-        test()
-        self.assertEqual(Foo.f, original_f)
-        self.assertEqual(Foo.g, original_g)
-
-
-    def test_patch_multiple_create_mocks_different_order(self):
-        original_f = Foo.f
-        original_g = Foo.g
-
-        patcher = patch.object(Foo, 'f', 3)
-        patcher.attribute_name = 'f'
-
-        other = patch.object(Foo, 'g', DEFAULT)
-        other.attribute_name = 'g'
-        patcher.additional_patchers = [other]
-
-        @patcher
-        def test(g):
-            self.assertIs(Foo.g, g)
-            self.assertEqual(Foo.f, 3)
-
-        test()
-        self.assertEqual(Foo.f, original_f)
-        self.assertEqual(Foo.g, original_g)
-
-
-    def test_patch_multiple_stacked_decorators(self):
-        original_foo = Foo
-        original_f = Foo.f
-        original_g = Foo.g
-
-        @patch.multiple(foo_name, f=DEFAULT)
-        @patch.multiple(foo_name, foo=DEFAULT)
-        @patch(foo_name + '.g')
-        def test1(g, **kwargs):
-            _test(g, **kwargs)
-
-        @patch.multiple(foo_name, f=DEFAULT)
-        @patch(foo_name + '.g')
-        @patch.multiple(foo_name, foo=DEFAULT)
-        def test2(g, **kwargs):
-            _test(g, **kwargs)
-
-        @patch(foo_name + '.g')
-        @patch.multiple(foo_name, f=DEFAULT)
-        @patch.multiple(foo_name, foo=DEFAULT)
-        def test3(g, **kwargs):
-            _test(g, **kwargs)
-
-        def _test(g, **kwargs):
-            f = kwargs.pop('f')
-            foo = kwargs.pop('foo')
-            self.assertFalse(kwargs)
-
-            self.assertIs(Foo, original_foo)
-            self.assertIs(Foo.f, f)
-            self.assertIs(Foo.g, g)
-            self.assertIs(Foo.foo, foo)
-            self.assertTrue(is_instance(f, MagicMock))
-            self.assertTrue(is_instance(g, MagicMock))
-            self.assertTrue(is_instance(foo, MagicMock))
-
-        test1()
-        test2()
-        test3()
-        self.assertEqual(Foo.f, original_f)
-        self.assertEqual(Foo.g, original_g)
-
-
-    def test_patch_multiple_create_mocks_patcher(self):
-        original_foo = Foo
-        original_f = Foo.f
-        original_g = Foo.g
-
-        patcher = patch.multiple(foo_name, f=DEFAULT, g=3, foo=DEFAULT)
-
-        result = patcher.start()
-        try:
-            f = result['f']
-            foo = result['foo']
-            self.assertEqual(set(result), set(['f', 'foo']))
-
-            self.assertIs(Foo, original_foo)
-            self.assertIs(Foo.f, f)
-            self.assertIs(Foo.foo, foo)
-            self.assertTrue(is_instance(f, MagicMock))
-            self.assertTrue(is_instance(foo, MagicMock))
-        finally:
-            patcher.stop()
-
-        self.assertEqual(Foo.f, original_f)
-        self.assertEqual(Foo.g, original_g)
-
-
-    def test_patch_multiple_decorating_class(self):
-        test = self
-        original_foo = Foo
-        original_f = Foo.f
-        original_g = Foo.g
-
-        class SomeTest(object):
-
-            def _test(self, f, foo):
-                test.assertIs(Foo, original_foo)
-                test.assertIs(Foo.f, f)
-                test.assertEqual(Foo.g, 3)
-                test.assertIs(Foo.foo, foo)
-                test.assertTrue(is_instance(f, MagicMock))
-                test.assertTrue(is_instance(foo, MagicMock))
-
-            def test_two(self, f, foo):
-                self._test(f, foo)
-            def test_one(self, f, foo):
-                self._test(f, foo)
-
-        SomeTest = patch.multiple(
-            foo_name, f=DEFAULT, g=3, foo=DEFAULT
-        )(SomeTest)
-
-        thing = SomeTest()
-        thing.test_one()
-        thing.test_two()
-
-        self.assertEqual(Foo.f, original_f)
-        self.assertEqual(Foo.g, original_g)
-
-
-    def test_patch_multiple_create(self):
-        patcher = patch.multiple(Foo, blam='blam')
-        self.assertRaises(AttributeError, patcher.start)
-
-        patcher = patch.multiple(Foo, blam='blam', create=True)
-        patcher.start()
-        try:
-            self.assertEqual(Foo.blam, 'blam')
-        finally:
-            patcher.stop()
-
-        self.assertFalse(hasattr(Foo, 'blam'))
-
-
-    def test_patch_multiple_spec_set(self):
-        # if spec_set works then we can assume that spec and autospec also
-        # work as the underlying machinery is the same
-        patcher = patch.multiple(Foo, foo=DEFAULT, spec_set=['a', 'b'])
-        result = patcher.start()
-        try:
-            self.assertEqual(Foo.foo, result['foo'])
-            Foo.foo.a(1)
-            Foo.foo.b(2)
-            Foo.foo.a.assert_called_with(1)
-            Foo.foo.b.assert_called_with(2)
-            self.assertRaises(AttributeError, setattr, Foo.foo, 'c', None)
-        finally:
-            patcher.stop()
-
-
-    def test_patch_multiple_new_callable(self):
-        class Thing(object):
-            pass
-
-        patcher = patch.multiple(
-            Foo, f=DEFAULT, g=DEFAULT, new_callable=Thing
-        )
-        result = patcher.start()
-        try:
-            self.assertIs(Foo.f, result['f'])
-            self.assertIs(Foo.g, result['g'])
-            self.assertIsInstance(Foo.f, Thing)
-            self.assertIsInstance(Foo.g, Thing)
-            self.assertIsNot(Foo.f, Foo.g)
-        finally:
-            patcher.stop()
-
-
-    def test_nested_patch_failure(self):
-        original_f = Foo.f
-        original_g = Foo.g
-
-        @patch.object(Foo, 'g', 1)
-        @patch.object(Foo, 'missing', 1)
-        @patch.object(Foo, 'f', 1)
-        def thing1(): pass
-
-        @patch.object(Foo, 'missing', 1)
-        @patch.object(Foo, 'g', 1)
-        @patch.object(Foo, 'f', 1)
-        def thing2(): pass
-
-        @patch.object(Foo, 'g', 1)
-        @patch.object(Foo, 'f', 1)
-        @patch.object(Foo, 'missing', 1)
-        def thing3(): pass
-
-        for func in thing1, thing2, thing3:
-            self.assertRaises(AttributeError, func)
-            self.assertEqual(Foo.f, original_f)
-            self.assertEqual(Foo.g, original_g)
-
-
-    def test_new_callable_failure(self):
-        original_f = Foo.f
-        original_g = Foo.g
-        original_foo = Foo.foo
-
-        def crasher():
-            raise NameError('crasher')
-
-        @patch.object(Foo, 'g', 1)
-        @patch.object(Foo, 'foo', new_callable=crasher)
-        @patch.object(Foo, 'f', 1)
-        def thing1(): pass
-
-        @patch.object(Foo, 'foo', new_callable=crasher)
-        @patch.object(Foo, 'g', 1)
-        @patch.object(Foo, 'f', 1)
-        def thing2(): pass
-
-        @patch.object(Foo, 'g', 1)
-        @patch.object(Foo, 'f', 1)
-        @patch.object(Foo, 'foo', new_callable=crasher)
-        def thing3(): pass
-
-        for func in thing1, thing2, thing3:
-            self.assertRaises(NameError, func)
-            self.assertEqual(Foo.f, original_f)
-            self.assertEqual(Foo.g, original_g)
-            self.assertEqual(Foo.foo, original_foo)
-
-
-    def test_patch_multiple_failure(self):
-        original_f = Foo.f
-        original_g = Foo.g
-
-        patcher = patch.object(Foo, 'f', 1)
-        patcher.attribute_name = 'f'
-
-        good = patch.object(Foo, 'g', 1)
-        good.attribute_name = 'g'
-
-        bad = patch.object(Foo, 'missing', 1)
-        bad.attribute_name = 'missing'
-
-        for additionals in [good, bad], [bad, good]:
-            patcher.additional_patchers = additionals
-
-            @patcher
-            def func(): pass
-
-            self.assertRaises(AttributeError, func)
-            self.assertEqual(Foo.f, original_f)
-            self.assertEqual(Foo.g, original_g)
-
-
-    def test_patch_multiple_new_callable_failure(self):
-        original_f = Foo.f
-        original_g = Foo.g
-        original_foo = Foo.foo
-
-        def crasher():
-            raise NameError('crasher')
-
-        patcher = patch.object(Foo, 'f', 1)
-        patcher.attribute_name = 'f'
-
-        good = patch.object(Foo, 'g', 1)
-        good.attribute_name = 'g'
-
-        bad = patch.object(Foo, 'foo', new_callable=crasher)
-        bad.attribute_name = 'foo'
-
-        for additionals in [good, bad], [bad, good]:
-            patcher.additional_patchers = additionals
-
-            @patcher
-            def func(): pass
-
-            self.assertRaises(NameError, func)
-            self.assertEqual(Foo.f, original_f)
-            self.assertEqual(Foo.g, original_g)
-            self.assertEqual(Foo.foo, original_foo)
-
-
-    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')
-
-        test()
-        self.assertEqual(foo.fish, 'tasty')
-
-
-    @patch('mock.patch.TEST_PREFIX', 'foo')
-    def test_patch_test_prefix(self):
-        class Foo(object):
-            thing = 'original'
-
-            def foo_one(self):
-                return self.thing
-            def foo_two(self):
-                return self.thing
-            def test_one(self):
-                return self.thing
-            def test_two(self):
-                return self.thing
-
-        Foo = patch.object(Foo, 'thing', 'changed')(Foo)
-
-        foo = Foo()
-        self.assertEqual(foo.foo_one(), 'changed')
-        self.assertEqual(foo.foo_two(), 'changed')
-        self.assertEqual(foo.test_one(), 'original')
-        self.assertEqual(foo.test_two(), 'original')
-
-
-    @patch('mock.patch.TEST_PREFIX', 'bar')
-    def test_patch_dict_test_prefix(self):
-        class Foo(object):
-            def bar_one(self):
-                return dict(the_dict)
-            def bar_two(self):
-                return dict(the_dict)
-            def test_one(self):
-                return dict(the_dict)
-            def test_two(self):
-                return dict(the_dict)
-
-        the_dict = {'key': 'original'}
-        Foo = patch.dict(the_dict, key='changed')(Foo)
-
-        foo =Foo()
-        self.assertEqual(foo.bar_one(), {'key': 'changed'})
-        self.assertEqual(foo.bar_two(), {'key': 'changed'})
-        self.assertEqual(foo.test_one(), {'key': 'original'})
-        self.assertEqual(foo.test_two(), {'key': 'original'})
-
-
-    def test_patch_with_spec_mock_repr(self):
-        for arg in ('spec', 'autospec', 'spec_set'):
-            p = patch('%s.SomeClass' % __name__, **{arg: True})
-            m = p.start()
-            try:
-                self.assertIn(" name='SomeClass'", repr(m))
-                self.assertIn(" name='SomeClass.class_attribute'",
-                              repr(m.class_attribute))
-                self.assertIn(" name='SomeClass()'", repr(m()))
-                self.assertIn(" name='SomeClass().class_attribute'",
-                              repr(m().class_attribute))
-            finally:
-                p.stop()
-
-
-    def test_patch_nested_autospec_repr(self):
-        with patch('mock.tests.support', autospec=True) as m:
-            self.assertIn(" name='support.SomeClass.wibble()'",
-                          repr(m.SomeClass.wibble()))
-            self.assertIn(" name='support.SomeClass().wibble()'",
-                          repr(m.SomeClass().wibble()))
-
-
-
-    def test_mock_calls_with_patch(self):
-        for arg in ('spec', 'autospec', 'spec_set'):
-            p = patch('%s.SomeClass' % __name__, **{arg: True})
-            m = p.start()
-            try:
-                m.wibble()
-
-                kalls = [call.wibble()]
-                self.assertEqual(m.mock_calls, kalls)
-                self.assertEqual(m.method_calls, kalls)
-                self.assertEqual(m.wibble.mock_calls, [call()])
-
-                result = m()
-                kalls.append(call())
-                self.assertEqual(m.mock_calls, kalls)
-
-                result.wibble()
-                kalls.append(call().wibble())
-                self.assertEqual(m.mock_calls, kalls)
-
-                self.assertEqual(result.mock_calls, [call.wibble()])
-                self.assertEqual(result.wibble.mock_calls, [call()])
-                self.assertEqual(result.method_calls, [call.wibble()])
-            finally:
-                p.stop()
-
-
-    def test_patch_imports_lazily(self):
-        p1 = patch('squizz.squozz')
-        self.assertRaises(ImportError, p1.start)
-
-        with uncache('squizz'):
-            squizz = Mock()
-            sys.modules['squizz'] = squizz
-
-            squizz.squozz = 6
-            p1 = patch('squizz.squozz')
-            squizz.squozz = 3
-            p1.start()
-            p1.stop()
-        self.assertEqual(squizz.squozz, 3)
-
-    def test_patch_propagates_exc_on_exit(self):
-        class holder:
-            exc_info = None, None, None
-
-        class custom_patch(_patch):
-            def __exit__(self, etype=None, val=None, tb=None):
-                _patch.__exit__(self, etype, val, tb)
-                holder.exc_info = etype, val, tb
-            stop = __exit__
-
-        def with_custom_patch(target):
-            getter, attribute = _get_target(target)
-            return custom_patch(
-                getter, attribute, DEFAULT, None, False, None,
-                None, None, {}
-            )
-
-        @with_custom_patch('squizz.squozz')
-        def test(mock):
-            raise RuntimeError
-
-        with uncache('squizz'):
-            squizz = Mock()
-            sys.modules['squizz'] = squizz
-
-            self.assertRaises(RuntimeError, test)
-
-        self.assertIs(holder.exc_info[0], RuntimeError)
-        self.assertIsNotNone(holder.exc_info[1],
-                            'exception value not propagated')
-        self.assertIsNotNone(holder.exc_info[2],
-                            'exception traceback not propagated')
-
-
-    def test_create_and_specs(self):
-        for kwarg in ('spec', 'spec_set', 'autospec'):
-            p = patch('%s.doesnotexist' % __name__, create=True,
-                      **{kwarg: True})
-            self.assertRaises(TypeError, p.start)
-            self.assertRaises(NameError, lambda: doesnotexist)
-
-            # check that spec with create is innocuous if the original exists
-            p = patch(MODNAME, create=True, **{kwarg: True})
-            p.start()
-            p.stop()
-
-
-    def test_multiple_specs(self):
-        original = PTModule
-        for kwarg in ('spec', 'spec_set'):
-            p = patch(MODNAME, autospec=0, **{kwarg: 0})
-            self.assertRaises(TypeError, p.start)
-            self.assertIs(PTModule, original)
-
-        for kwarg in ('spec', 'autospec'):
-            p = patch(MODNAME, spec_set=0, **{kwarg: 0})
-            self.assertRaises(TypeError, p.start)
-            self.assertIs(PTModule, original)
-
-        for kwarg in ('spec_set', 'autospec'):
-            p = patch(MODNAME, spec=0, **{kwarg: 0})
-            self.assertRaises(TypeError, p.start)
-            self.assertIs(PTModule, original)
-
-
-    def test_specs_false_instead_of_none(self):
-        p = patch(MODNAME, spec=False, spec_set=False, autospec=False)
-        mock = p.start()
-        try:
-            # no spec should have been set, so attribute access should not fail
-            mock.does_not_exist
-            mock.does_not_exist = 3
-        finally:
-            p.stop()
-
-
-    def test_falsey_spec(self):
-        for kwarg in ('spec', 'autospec', 'spec_set'):
-            p = patch(MODNAME, **{kwarg: 0})
-            m = p.start()
-            try:
-                self.assertRaises(AttributeError, getattr, m, 'doesnotexit')
-            finally:
-                p.stop()
-
-
-    def test_spec_set_true(self):
-        for kwarg in ('spec', 'autospec'):
-            p = patch(MODNAME, spec_set=True, **{kwarg: True})
-            m = p.start()
-            try:
-                self.assertRaises(AttributeError, setattr, m,
-                                  'doesnotexist', 'something')
-                self.assertRaises(AttributeError, getattr, m, 'doesnotexist')
-            finally:
-                p.stop()
-
-
-    def test_callable_spec_as_list(self):
-        spec = ('__call__',)
-        p = patch(MODNAME, spec=spec)
-        m = p.start()
-        try:
-            self.assertTrue(callable(m))
-        finally:
-            p.stop()
-
-
-    def test_not_callable_spec_as_list(self):
-        spec = ('foo', 'bar')
-        p = patch(MODNAME, spec=spec)
-        m = p.start()
-        try:
-            self.assertFalse(callable(m))
-        finally:
-            p.stop()
-
-
-    def test_patch_stopall(self):
-        unlink = os.unlink
-        chdir = os.chdir
-        path = os.path
-        patch('os.unlink', something).start()
-        patch('os.chdir', something_else).start()
-
-        @patch('os.path')
-        def patched(mock_path):
-            patch.stopall()
-            self.assertIs(os.path, mock_path)
-            self.assertIs(os.unlink, unlink)
-            self.assertIs(os.chdir, chdir)
-
-        patched()
-        self.assertIs(os.path, path)
-
-    def test_stopall_lifo(self):
-        stopped = []
-        class thing(object):
-            one = two = three = None
-
-        def get_patch(attribute):
-            class mypatch(_patch):
-                def stop(self):
-                    stopped.append(attribute)
-                    return super(mypatch, self).stop()
-            return mypatch(lambda: thing, attribute, None, None,
-                           False, None, None, None, {})
-        [get_patch(val).start() for val in ("one", "two", "three")]
-        patch.stopall()
-
-        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):
-            """TEST"""
-            return x
-        with patch.object(foo, '__defaults__', (1, )):
-            self.assertEqual(foo(), 1)
-        self.assertEqual(foo(), 0)
-
-        with patch.object(foo, '__doc__', "FUN"):
-            self.assertEqual(foo.__doc__, "FUN")
-        self.assertEqual(foo.__doc__, "TEST")
-
-        with patch.object(foo, '__module__', "testpatch2"):
-            self.assertEqual(foo.__module__, "testpatch2")
-        self.assertEqual(foo.__module__, 'mock.tests.testpatch')
-
-        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)
-
-    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:
-        with patch.dict('sys.modules'):
-            del sys.modules['mock.tests.support']
-            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):
-                pass
-            test()
-
-
-    def test_invalid_target(self):
-        with self.assertRaises(TypeError):
-            patch('')
-
-
-    def test_cant_set_kwargs_when_passing_a_mock(self):
-        @patch('mock.tests.support.X', new=object(), x=1)
-        def test(): pass
-        with self.assertRaises(TypeError):
-            test()
-
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/lib/mock/tests/testsealable.py b/lib/mock/tests/testsealable.py
deleted file mode 100644
index 63a85414..00000000
--- a/lib/mock/tests/testsealable.py
+++ /dev/null
@@ -1,176 +0,0 @@
-import unittest
-import mock
-
-
-class SampleObject:
-
-    def method_sample1(self): pass
-
-    def method_sample2(self): pass
-
-
-class TestSealable(unittest.TestCase):
-
-    def test_attributes_return_more_mocks_by_default(self):
-        m = mock.Mock()
-
-        self.assertIsInstance(m.test, mock.Mock)
-        self.assertIsInstance(m.test(), mock.Mock)
-        self.assertIsInstance(m.test().test2(), mock.Mock)
-
-    def test_new_attributes_cannot_be_accessed_on_seal(self):
-        m = mock.Mock()
-
-        mock.seal(m)
-        with self.assertRaises(AttributeError):
-            m.test
-        with self.assertRaises(AttributeError):
-            m()
-
-    def test_new_attributes_cannot_be_set_on_seal(self):
-        m = mock.Mock()
-
-        mock.seal(m)
-        with self.assertRaises(AttributeError):
-            m.test = 1
-
-    def test_existing_attributes_can_be_set_on_seal(self):
-        m = mock.Mock()
-        m.test.test2 = 1
-
-        mock.seal(m)
-        m.test.test2 = 2
-        self.assertEqual(m.test.test2, 2)
-
-    def test_new_attributes_cannot_be_set_on_child_of_seal(self):
-        m = mock.Mock()
-        m.test.test2 = 1
-
-        mock.seal(m)
-        with self.assertRaises(AttributeError):
-            m.test.test3 = 1
-
-    def test_existing_attributes_allowed_after_seal(self):
-        m = mock.Mock()
-
-        m.test.return_value = 3
-
-        mock.seal(m)
-        self.assertEqual(m.test(), 3)
-
-    def test_initialized_attributes_allowed_after_seal(self):
-        m = mock.Mock(test_value=1)
-
-        mock.seal(m)
-        self.assertEqual(m.test_value, 1)
-
-    def test_call_on_sealed_mock_fails(self):
-        m = mock.Mock()
-
-        mock.seal(m)
-        with self.assertRaises(AttributeError):
-            m()
-
-    def test_call_on_defined_sealed_mock_succeeds(self):
-        m = mock.Mock(return_value=5)
-
-        mock.seal(m)
-        self.assertEqual(m(), 5)
-
-    def test_seals_recurse_on_added_attributes(self):
-        m = mock.Mock()
-
-        m.test1.test2().test3 = 4
-
-        mock.seal(m)
-        self.assertEqual(m.test1.test2().test3, 4)
-        with self.assertRaises(AttributeError):
-            m.test1.test2().test4
-        with self.assertRaises(AttributeError):
-            m.test1.test3
-
-    def test_seals_recurse_on_magic_methods(self):
-        m = mock.MagicMock()
-
-        m.test1.test2["a"].test3 = 4
-        m.test1.test3[2:5].test3 = 4
-
-        mock.seal(m)
-        self.assertEqual(m.test1.test2["a"].test3, 4)
-        self.assertEqual(m.test1.test2[2:5].test3, 4)
-        with self.assertRaises(AttributeError):
-            m.test1.test2["a"].test4
-        with self.assertRaises(AttributeError):
-            m.test1.test3[2:5].test4
-
-    def test_seals_dont_recurse_on_manual_attributes(self):
-        m = mock.Mock(name="root_mock")
-
-        m.test1.test2 = mock.Mock(name="not_sealed")
-        m.test1.test2.test3 = 4
-
-        mock.seal(m)
-        self.assertEqual(m.test1.test2.test3, 4)
-        m.test1.test2.test4  # Does not raise
-        m.test1.test2.test4 = 1  # Does not raise
-
-    def test_integration_with_spec_att_definition(self):
-        """You are not restricted when using mock with spec"""
-        m = mock.Mock(SampleObject)
-
-        m.attr_sample1 = 1
-        m.attr_sample3 = 3
-
-        mock.seal(m)
-        self.assertEqual(m.attr_sample1, 1)
-        self.assertEqual(m.attr_sample3, 3)
-        with self.assertRaises(AttributeError):
-            m.attr_sample2
-
-    def test_integration_with_spec_method_definition(self):
-        """You need to defin the methods, even if they are in the spec"""
-        m = mock.Mock(SampleObject)
-
-        m.method_sample1.return_value = 1
-
-        mock.seal(m)
-        self.assertEqual(m.method_sample1(), 1)
-        with self.assertRaises(AttributeError):
-            m.method_sample2()
-
-    def test_integration_with_spec_method_definition_respects_spec(self):
-        """You cannot define methods out of the spec"""
-        m = mock.Mock(SampleObject)
-
-        with self.assertRaises(AttributeError):
-            m.method_sample3.return_value = 3
-
-    def test_sealed_exception_has_attribute_name(self):
-        m = mock.Mock()
-
-        mock.seal(m)
-        with self.assertRaises(AttributeError) as cm:
-            m.SECRETE_name
-        self.assertIn("SECRETE_name", str(cm.exception))
-
-    def test_attribute_chain_is_maintained(self):
-        m = mock.Mock(name="mock_name")
-        m.test1.test2.test3.test4
-
-        mock.seal(m)
-        with self.assertRaises(AttributeError) as cm:
-            m.test1.test2.test3.test4.boom
-        self.assertIn("mock_name.test1.test2.test3.test4.boom", str(cm.exception))
-
-    def test_call_chain_is_maintained(self):
-        m = mock.Mock()
-        m.test1().test2.test3().test4
-
-        mock.seal(m)
-        with self.assertRaises(AttributeError) as cm:
-            m.test1().test2.test3().test4()
-        self.assertIn("mock.test1().test2.test3().test4", str(cm.exception))
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/lib/mock/tests/testsentinel.py b/lib/mock/tests/testsentinel.py
deleted file mode 100644
index 56664341..00000000
--- a/lib/mock/tests/testsentinel.py
+++ /dev/null
@@ -1,41 +0,0 @@
-import unittest
-import copy
-import pickle
-from mock import sentinel, DEFAULT
-
-
-class SentinelTest(unittest.TestCase):
-
-    def testSentinels(self):
-        self.assertEqual(sentinel.whatever, sentinel.whatever,
-                         'sentinel not stored')
-        self.assertNotEqual(sentinel.whatever, sentinel.whateverelse,
-                            'sentinel should be unique')
-
-
-    def testSentinelName(self):
-        self.assertEqual(str(sentinel.whatever), 'sentinel.whatever',
-                         'sentinel name incorrect')
-
-
-    def testDEFAULT(self):
-        self.assertIs(DEFAULT, sentinel.DEFAULT)
-
-    def testBases(self):
-        # If this doesn't raise an AttributeError then help(mock) is broken
-        self.assertRaises(AttributeError, lambda: sentinel.__bases__)
-
-    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)
-
-    def testCopy(self):
-        self.assertIs(copy.copy(sentinel.whatever), sentinel.whatever)
-        self.assertIs(copy.deepcopy(sentinel.whatever), sentinel.whatever)
-
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/lib/mock/tests/testwith.py b/lib/mock/tests/testwith.py
deleted file mode 100644
index 825387b7..00000000
--- a/lib/mock/tests/testwith.py
+++ /dev/null
@@ -1,347 +0,0 @@
-import unittest
-from warnings import catch_warnings
-
-from mock.tests.support import is_instance
-from mock import MagicMock, Mock, patch, sentinel, mock_open, call
-
-
-
-something  = sentinel.Something
-something_else  = sentinel.SomethingElse
-
-
-class SampleException(Exception): pass
-
-
-class WithTest(unittest.TestCase):
-
-    def test_with_statement(self):
-        with patch('%s.something' % __name__, sentinel.Something2):
-            self.assertEqual(something, sentinel.Something2, "unpatched")
-        self.assertEqual(something, sentinel.Something)
-
-
-    def test_with_statement_exception(self):
-        with self.assertRaises(SampleException):
-            with patch('%s.something' % __name__, sentinel.Something2):
-                self.assertEqual(something, sentinel.Something2, "unpatched")
-                raise SampleException()
-        self.assertEqual(something, sentinel.Something)
-
-
-    def test_with_statement_as(self):
-        with patch('%s.something' % __name__) as mock_something:
-            self.assertEqual(something, mock_something, "unpatched")
-            self.assertTrue(is_instance(mock_something, MagicMock),
-                            "patching wrong type")
-        self.assertEqual(something, sentinel.Something)
-
-
-    def test_patch_object_with_statement(self):
-        class Foo(object):
-            something = 'foo'
-        original = Foo.something
-        with patch.object(Foo, 'something'):
-            self.assertNotEqual(Foo.something, original, "unpatched")
-        self.assertEqual(Foo.something, original)
-
-
-    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")
-
-        self.assertEqual(something, sentinel.Something)
-        self.assertEqual(something_else, sentinel.SomethingElse)
-
-
-    def test_with_statement_specified(self):
-        with patch('%s.something' % __name__, sentinel.Patched) as mock_something:
-            self.assertEqual(something, mock_something, "unpatched")
-            self.assertEqual(mock_something, sentinel.Patched, "wrong patch")
-        self.assertEqual(something, sentinel.Something)
-
-
-    def testContextManagerMocking(self):
-        mock = Mock()
-        mock.__enter__ = Mock()
-        mock.__exit__ = Mock()
-        mock.__exit__.return_value = False
-
-        with mock as m:
-            self.assertEqual(m, mock.__enter__.return_value)
-        mock.__enter__.assert_called_with()
-        mock.__exit__.assert_called_with(None, None, None)
-
-
-    def test_context_manager_with_magic_mock(self):
-        mock = MagicMock()
-
-        with self.assertRaises(TypeError):
-            with mock:
-                'foo' + 3
-        mock.__enter__.assert_called_with()
-        self.assertTrue(mock.__exit__.called)
-
-
-    def test_with_statement_same_attribute(self):
-        with patch('%s.something' % __name__, sentinel.Patched) as mock_something:
-            self.assertEqual(something, mock_something, "unpatched")
-
-            with patch('%s.something' % __name__) as mock_again:
-                self.assertEqual(something, mock_again, "unpatched")
-
-            self.assertEqual(something, mock_something,
-                             "restored with wrong instance")
-
-        self.assertEqual(something, sentinel.Something, "not restored")
-
-
-    def test_with_statement_imbricated(self):
-        with patch('%s.something' % __name__) as mock_something:
-            self.assertEqual(something, mock_something, "unpatched")
-
-            with patch('%s.something_else' % __name__) as mock_something_else:
-                self.assertEqual(something_else, mock_something_else,
-                                 "unpatched")
-
-        self.assertEqual(something, sentinel.Something)
-        self.assertEqual(something_else, sentinel.SomethingElse)
-
-
-    def test_dict_context_manager(self):
-        foo = {}
-        with patch.dict(foo, {'a': 'b'}):
-            self.assertEqual(foo, {'a': 'b'})
-        self.assertEqual(foo, {})
-
-        with self.assertRaises(NameError):
-            with patch.dict(foo, {'a': 'b'}):
-                self.assertEqual(foo, {'a': 'b'})
-                raise NameError('Konrad')
-
-        self.assertEqual(foo, {})
-
-    def test_double_patch_instance_method(self):
-        class C:
-            def f(self): pass
-
-        c = C()
-
-        with patch.object(c, 'f', autospec=True) as patch1:
-            with patch.object(c, 'f', autospec=True) as patch2:
-                c.f()
-            self.assertEqual(patch2.call_count, 1)
-            self.assertEqual(patch1.call_count, 0)
-            c.f()
-        self.assertEqual(patch1.call_count, 1)
-
-
-class TestMockOpen(unittest.TestCase):
-
-    def test_mock_open(self):
-        mock = mock_open()
-        with patch('%s.open' % __name__, mock, create=True) as patched:
-            self.assertIs(patched, mock)
-            open('foo')
-
-        mock.assert_called_once_with('foo')
-
-
-    def test_mock_open_context_manager(self):
-        mock = mock_open()
-        handle = mock.return_value
-        with patch('%s.open' % __name__, mock, create=True):
-            with open('foo') as f:
-                f.read()
-
-        expected_calls = [call('foo'), call().__enter__(), call().read(),
-                          call().__exit__(None, None, None)]
-        self.assertEqual(mock.mock_calls, expected_calls)
-        self.assertIs(f, handle)
-
-    def test_mock_open_context_manager_multiple_times(self):
-        mock = mock_open()
-        with patch('%s.open' % __name__, mock, create=True):
-            with open('foo') as f:
-                f.read()
-            with open('bar') as f:
-                f.read()
-
-        expected_calls = [
-            call('foo'), call().__enter__(), call().read(),
-            call().__exit__(None, None, None),
-            call('bar'), call().__enter__(), call().read(),
-            call().__exit__(None, None, None)]
-        self.assertEqual(mock.mock_calls, expected_calls)
-
-    def test_explicit_mock(self):
-        mock = MagicMock()
-        mock_open(mock)
-
-        with patch('%s.open' % __name__, mock, create=True) as patched:
-            self.assertIs(patched, mock)
-            open('foo')
-
-        mock.assert_called_once_with('foo')
-
-
-    def test_read_data(self):
-        mock = mock_open(read_data='foo')
-        with patch('%s.open' % __name__, mock, create=True):
-            h = open('bar')
-            result = h.read()
-
-        self.assertEqual(result, 'foo')
-
-
-    def test_readline_data(self):
-        # Check that readline will return all the lines from the fake file
-        # And that once fully consumed, readline will return an empty string.
-        mock = mock_open(read_data='foo\nbar\nbaz\n')
-        with patch('%s.open' % __name__, mock, create=True):
-            h = open('bar')
-            line1 = h.readline()
-            line2 = h.readline()
-            line3 = h.readline()
-        self.assertEqual(line1, 'foo\n')
-        self.assertEqual(line2, 'bar\n')
-        self.assertEqual(line3, 'baz\n')
-        self.assertEqual(h.readline(), '')
-
-        # Check that we properly emulate a file that doesn't end in a newline
-        mock = mock_open(read_data='foo')
-        with patch('%s.open' % __name__, mock, create=True):
-            h = open('bar')
-            result = h.readline()
-        self.assertEqual(result, 'foo')
-        self.assertEqual(h.readline(), '')
-
-
-    def test_dunder_iter_data(self):
-        # Check that dunder_iter will return all the lines from the fake file.
-        mock = mock_open(read_data='foo\nbar\nbaz\n')
-        with patch('%s.open' % __name__, mock, create=True):
-            h = open('bar')
-            lines = [l for l in h]
-        self.assertEqual(lines[0], 'foo\n')
-        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
-        mock = mock_open(read_data='foo\nbar\nbaz\n')
-        with patch('%s.open' % __name__, mock, create=True):
-            h = open('bar')
-            result = h.readlines()
-        self.assertEqual(result, ['foo\n', 'bar\n', 'baz\n'])
-
-        # Test that files without a final newline will also be correctly
-        # emulated
-        mock = mock_open(read_data='foo\nbar\nbaz')
-        with patch('%s.open' % __name__, mock, create=True):
-            h = open('bar')
-            result = h.readlines()
-
-        self.assertEqual(result, ['foo\n', 'bar\n', 'baz'])
-
-
-    def test_read_bytes(self):
-        mock = mock_open(read_data=b'\xc6')
-        with patch('%s.open' % __name__, mock, create=True):
-            with open('abc', 'rb') as f:
-                result = f.read()
-        self.assertEqual(result, b'\xc6')
-
-
-    def test_readline_bytes(self):
-        m = mock_open(read_data=b'abc\ndef\nghi\n')
-        with patch('%s.open' % __name__, m, create=True):
-            with open('abc', 'rb') as f:
-                line1 = f.readline()
-                line2 = f.readline()
-                line3 = f.readline()
-        self.assertEqual(line1, b'abc\n')
-        self.assertEqual(line2, b'def\n')
-        self.assertEqual(line3, b'ghi\n')
-
-
-    def test_readlines_bytes(self):
-        m = mock_open(read_data=b'abc\ndef\nghi\n')
-        with patch('%s.open' % __name__, m, create=True):
-            with open('abc', 'rb') as f:
-                result = f.readlines()
-        self.assertEqual(result, [b'abc\n', b'def\n', b'ghi\n'])
-
-
-    def test_mock_open_read_with_argument(self):
-        # At one point calling read with an argument was broken
-        # for mocks returned by mock_open
-        some_data = 'foo\nbar\nbaz'
-        mock = mock_open(read_data=some_data)
-        self.assertEqual(mock().read(10), some_data[:10])
-        self.assertEqual(mock().read(10), some_data[:10])
-
-        f = mock()
-        self.assertEqual(f.read(10), some_data[:10])
-        self.assertEqual(f.read(10), some_data[10:])
-
-
-    def test_interleaved_reads(self):
-        # Test that calling read, readline, and readlines pulls data
-        # sequentially from the data we preload with
-        mock = mock_open(read_data='foo\nbar\nbaz\n')
-        with patch('%s.open' % __name__, mock, create=True):
-            h = open('bar')
-            line1 = h.readline()
-            rest = h.readlines()
-        self.assertEqual(line1, 'foo\n')
-        self.assertEqual(rest, ['bar\n', 'baz\n'])
-
-        mock = mock_open(read_data='foo\nbar\nbaz\n')
-        with patch('%s.open' % __name__, mock, create=True):
-            h = open('bar')
-            line1 = h.readline()
-            rest = h.read()
-        self.assertEqual(line1, 'foo\n')
-        self.assertEqual(rest, 'bar\nbaz\n')
-
-
-    def test_overriding_return_values(self):
-        mock = mock_open(read_data='foo')
-        handle = mock()
-
-        handle.read.return_value = 'bar'
-        handle.readline.return_value = 'bar'
-        handle.readlines.return_value = ['bar']
-
-        self.assertEqual(handle.read(), 'bar')
-        self.assertEqual(handle.readline(), 'bar')
-        self.assertEqual(handle.readlines(), ['bar'])
-
-        # call repeatedly to check that a StopIteration is not propagated
-        self.assertEqual(handle.readline(), 'bar')
-        self.assertEqual(handle.readline(), 'bar')
-
-
-if __name__ == '__main__':
-    unittest.main()