Delete tools/telemetry.

tools/telemetry/third_party/mox3/mox3/mox.py

Index: tools/telemetry/third_party/mox3/mox3/mox.py
diff --git a/tools/telemetry/third_party/mox3/mox3/mox.py b/tools/telemetry/third_party/mox3/mox3/mox.py
deleted file mode 100644
index 3c10cc8b92ffa31e34cbc93f9adbd884998cafee..0000000000000000000000000000000000000000
--- a/tools/telemetry/third_party/mox3/mox3/mox.py
+++ /dev/null
@@ -1,2168 +0,0 @@
-# Copyright 2008 Google Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-# This is a fork of the pymox library intended to work with Python 3.
-# The file was modified by quermit@gmail.com and dawid.fatyga@gmail.com
-
-"""Mox, an object-mocking framework for Python.
-
-Mox works in the record-replay-verify paradigm.  When you first create
-a mock object, it is in record mode.  You then programmatically set
-the expected behavior of the mock object (what methods are to be
-called on it, with what parameters, what they should return, and in
-what order).
-
-Once you have set up the expected mock behavior, you put it in replay
-mode.  Now the mock responds to method calls just as you told it to.
-If an unexpected method (or an expected method with unexpected
-parameters) is called, then an exception will be raised.
-
-Once you are done interacting with the mock, you need to verify that
-all the expected interactions occured.  (Maybe your code exited
-prematurely without calling some cleanup method!)  The verify phase
-ensures that every expected method was called; otherwise, an exception
-will be raised.
-
-WARNING! Mock objects created by Mox are not thread-safe.  If you are
-call a mock in multiple threads, it should be guarded by a mutex.
-
-TODO(stevepm): Add the option to make mocks thread-safe!
-
-Suggested usage / workflow:
-
-    # Create Mox factory
-    my_mox = Mox()
-
-    # Create a mock data access object
-    mock_dao = my_mox.CreateMock(DAOClass)
-
-    # Set up expected behavior
-    mock_dao.RetrievePersonWithIdentifier('1').AndReturn(person)
-    mock_dao.DeletePerson(person)
-
-    # Put mocks in replay mode
-    my_mox.ReplayAll()
-
-    # Inject mock object and run test
-    controller.SetDao(mock_dao)
-    controller.DeletePersonById('1')
-
-    # Verify all methods were called as expected
-    my_mox.VerifyAll()
-"""
-
-import collections
-import difflib
-import inspect
-import re
-import types
-import unittest
-
-from mox3 import stubout
-
-
-class Error(AssertionError):
-    """Base exception for this module."""
-
-    pass
-
-
-class ExpectedMethodCallsError(Error):
-    """Raised when an expected method wasn't called.
-
-    This can occur if Verify() is called before all expected methods have been
-    called.
-    """
-
-    def __init__(self, expected_methods):
-        """Init exception.
-
-        Args:
-            # expected_methods: A sequence of MockMethod objects that should
-            #                   have been called.
-            expected_methods: [MockMethod]
-
-        Raises:
-            ValueError: if expected_methods contains no methods.
-        """
-
-        if not expected_methods:
-            raise ValueError("There must be at least one expected method")
-        Error.__init__(self)
-        self._expected_methods = expected_methods
-
-    def __str__(self):
-        calls = "\n".join(["%3d.  %s" % (i, m)
-                          for i, m in enumerate(self._expected_methods)])
-        return "Verify: Expected methods never called:\n%s" % (calls,)
-
-
-class UnexpectedMethodCallError(Error):
-    """Raised when an unexpected method is called.
-
-    This can occur if a method is called with incorrect parameters, or out of
-    the specified order.
-    """
-
-    def __init__(self, unexpected_method, expected):
-        """Init exception.
-
-        Args:
-            # unexpected_method: MockMethod that was called but was not at the
-            #     head of the expected_method queue.
-            # expected: MockMethod or UnorderedGroup the method should have
-            #     been in.
-            unexpected_method: MockMethod
-            expected: MockMethod or UnorderedGroup
-        """
-
-        Error.__init__(self)
-        if expected is None:
-            self._str = "Unexpected method call %s" % (unexpected_method,)
-        else:
-            differ = difflib.Differ()
-            diff = differ.compare(str(unexpected_method).splitlines(True),
-                                  str(expected).splitlines(True))
-            self._str = ("Unexpected method call."
-                         "  unexpected:-  expected:+\n%s"
-                         % ("\n".join(line.rstrip() for line in diff),))
-
-    def __str__(self):
-        return self._str
-
-
-class UnknownMethodCallError(Error):
-    """Raised if an unknown method is requested of the mock object."""
-
-    def __init__(self, unknown_method_name):
-        """Init exception.
-
-        Args:
-            # unknown_method_name: Method call that is not part of the mocked
-            #     class's public interface.
-            unknown_method_name: str
-        """
-
-        Error.__init__(self)
-        self._unknown_method_name = unknown_method_name
-
-    def __str__(self):
-        return ("Method called is not a member of the object: %s" %
-                self._unknown_method_name)
-
-
-class PrivateAttributeError(Error):
-    """Raised if a MockObject is passed a private additional attribute name."""
-
-    def __init__(self, attr):
-        Error.__init__(self)
-        self._attr = attr
-
-    def __str__(self):
-        return ("Attribute '%s' is private and should not be available"
-                "in a mock object." % self._attr)
-
-
-class ExpectedMockCreationError(Error):
-    """Raised if mocks should have been created by StubOutClassWithMocks."""
-
-    def __init__(self, expected_mocks):
-        """Init exception.
-
-        Args:
-            # expected_mocks: A sequence of MockObjects that should have been
-            #     created
-
-        Raises:
-            ValueError: if expected_mocks contains no methods.
-        """
-
-        if not expected_mocks:
-            raise ValueError("There must be at least one expected method")
-        Error.__init__(self)
-        self._expected_mocks = expected_mocks
-
-    def __str__(self):
-        mocks = "\n".join(["%3d.  %s" % (i, m)
-                          for i, m in enumerate(self._expected_mocks)])
-        return "Verify: Expected mocks never created:\n%s" % (mocks,)
-
-
-class UnexpectedMockCreationError(Error):
-    """Raised if too many mocks were created by StubOutClassWithMocks."""
-
-    def __init__(self, instance, *params, **named_params):
-        """Init exception.
-
-        Args:
-            # instance: the type of obejct that was created
-            # params: parameters given during instantiation
-            # named_params: named parameters given during instantiation
-        """
-
-        Error.__init__(self)
-        self._instance = instance
-        self._params = params
-        self._named_params = named_params
-
-    def __str__(self):
-        args = ", ".join(["%s" % v for i, v in enumerate(self._params)])
-        error = "Unexpected mock creation: %s(%s" % (self._instance, args)
-
-        if self._named_params:
-            error += ", " + ", ".join(["%s=%s" % (k, v) for k, v in
-                                      self._named_params.items()])
-
-        error += ")"
-        return error
-
-
-class Mox(object):
-    """Mox: a factory for creating mock objects."""
-
-    # A list of types that should be stubbed out with MockObjects (as
-    # opposed to MockAnythings).
-    _USE_MOCK_OBJECT = [types.FunctionType, types.ModuleType, types.MethodType]
-
-    def __init__(self):
-        """Initialize a new Mox."""
-
-        self._mock_objects = []
-        self.stubs = stubout.StubOutForTesting()
-
-    def CreateMock(self, class_to_mock, attrs=None, bounded_to=None):
-        """Create a new mock object.
-
-        Args:
-            # class_to_mock: the class to be mocked
-            class_to_mock: class
-            attrs: dict of attribute names to values that will be
-                   set on the mock object. Only public attributes may be set.
-            bounded_to: optionally, when class_to_mock is not a class,
-                        it points to a real class object, to which
-                        attribute is bound
-
-        Returns:
-            MockObject that can be used as the class_to_mock would be.
-        """
-        if attrs is None:
-            attrs = {}
-        new_mock = MockObject(class_to_mock, attrs=attrs,
-                              class_to_bind=bounded_to)
-        self._mock_objects.append(new_mock)
-        return new_mock
-
-    def CreateMockAnything(self, description=None):
-        """Create a mock that will accept any method calls.
-
-        This does not enforce an interface.
-
-        Args:
-        description: str. Optionally, a descriptive name for the mock object
-        being created, for debugging output purposes.
-        """
-        new_mock = MockAnything(description=description)
-        self._mock_objects.append(new_mock)
-        return new_mock
-
-    def ReplayAll(self):
-        """Set all mock objects to replay mode."""
-
-        for mock_obj in self._mock_objects:
-            mock_obj._Replay()
-
-    def VerifyAll(self):
-        """Call verify on all mock objects created."""
-
-        for mock_obj in self._mock_objects:
-            mock_obj._Verify()
-
-    def ResetAll(self):
-        """Call reset on all mock objects.    This does not unset stubs."""
-
-        for mock_obj in self._mock_objects:
-            mock_obj._Reset()
-
-    def StubOutWithMock(self, obj, attr_name, use_mock_anything=False):
-        """Replace a method, attribute, etc. with a Mock.
-
-        This will replace a class or module with a MockObject, and everything
-        else (method, function, etc) with a MockAnything. This can be
-        overridden to always use a MockAnything by setting use_mock_anything
-        to True.
-
-        Args:
-            obj: A Python object (class, module, instance, callable).
-            attr_name: str. The name of the attribute to replace with a mock.
-            use_mock_anything: bool. True if a MockAnything should be used
-                               regardless of the type of attribute.
-        """
-
-        if inspect.isclass(obj):
-            class_to_bind = obj
-        else:
-            class_to_bind = None
-
-        attr_to_replace = getattr(obj, attr_name)
-        attr_type = type(attr_to_replace)
-
-        if attr_type == MockAnything or attr_type == MockObject:
-            raise TypeError('Cannot mock a MockAnything! Did you remember to '
-                            'call UnsetStubs in your previous test?')
-
-        type_check = (
-            attr_type in self._USE_MOCK_OBJECT or
-            inspect.isclass(attr_to_replace) or
-            isinstance(attr_to_replace, object))
-        if type_check and not use_mock_anything:
-            stub = self.CreateMock(attr_to_replace, bounded_to=class_to_bind)
-        else:
-            stub = self.CreateMockAnything(
-                description='Stub for %s' % attr_to_replace)
-            stub.__name__ = attr_name
-
-        self.stubs.Set(obj, attr_name, stub)
-
-    def StubOutClassWithMocks(self, obj, attr_name):
-        """Replace a class with a "mock factory" that will create mock objects.
-
-        This is useful if the code-under-test directly instantiates
-        dependencies.    Previously some boilder plate was necessary to
-        create a mock that would act as a factory.    Using
-        StubOutClassWithMocks, once you've stubbed out the class you may
-        use the stubbed class as you would any other mock created by mox:
-        during the record phase, new mock instances will be created, and
-        during replay, the recorded mocks will be returned.
-
-        In replay mode
-
-        # Example using StubOutWithMock (the old, clunky way):
-
-        mock1 = mox.CreateMock(my_import.FooClass)
-        mock2 = mox.CreateMock(my_import.FooClass)
-        foo_factory = mox.StubOutWithMock(my_import, 'FooClass',
-                                          use_mock_anything=True)
-        foo_factory(1, 2).AndReturn(mock1)
-        foo_factory(9, 10).AndReturn(mock2)
-        mox.ReplayAll()
-
-        my_import.FooClass(1, 2)     # Returns mock1 again.
-        my_import.FooClass(9, 10)    # Returns mock2 again.
-        mox.VerifyAll()
-
-        # Example using StubOutClassWithMocks:
-
-        mox.StubOutClassWithMocks(my_import, 'FooClass')
-        mock1 = my_import.FooClass(1, 2)     # Returns a new mock of FooClass
-        mock2 = my_import.FooClass(9, 10)    # Returns another mock instance
-        mox.ReplayAll()
-
-        my_import.FooClass(1, 2)     # Returns mock1 again.
-        my_import.FooClass(9, 10)    # Returns mock2 again.
-        mox.VerifyAll()
-        """
-        attr_to_replace = getattr(obj, attr_name)
-        attr_type = type(attr_to_replace)
-
-        if attr_type == MockAnything or attr_type == MockObject:
-            raise TypeError('Cannot mock a MockAnything! Did you remember to '
-                            'call UnsetStubs in your previous test?')
-
-        if not inspect.isclass(attr_to_replace):
-            raise TypeError('Given attr is not a Class. Use StubOutWithMock.')
-
-        factory = _MockObjectFactory(attr_to_replace, self)
-        self._mock_objects.append(factory)
-        self.stubs.Set(obj, attr_name, factory)
-
-    def UnsetStubs(self):
-        """Restore stubs to their original state."""
-
-        self.stubs.UnsetAll()
-
-
-def Replay(*args):
-    """Put mocks into Replay mode.
-
-    Args:
-        # args is any number of mocks to put into replay mode.
-    """
-
-    for mock in args:
-        mock._Replay()
-
-
-def Verify(*args):
-    """Verify mocks.
-
-    Args:
-        # args is any number of mocks to be verified.
-    """
-
-    for mock in args:
-        mock._Verify()
-
-
-def Reset(*args):
-    """Reset mocks.
-
-    Args:
-        # args is any number of mocks to be reset.
-    """
-
-    for mock in args:
-        mock._Reset()
-
-
-class MockAnything(object):
-    """A mock that can be used to mock anything.
-
-    This is helpful for mocking classes that do not provide a public interface.
-    """
-
-    def __init__(self, description=None):
-        """Initialize a new MockAnything.
-
-        Args:
-            description: str. Optionally, a descriptive name for the mock
-                         object being created, for debugging output purposes.
-        """
-        self._description = description
-        self._Reset()
-
-    def __repr__(self):
-        if self._description:
-            return '<MockAnything instance of %s>' % self._description
-        else:
-            return '<MockAnything instance>'
-
-    def __getattr__(self, method_name):
-        """Intercept method calls on this object.
-
-         A new MockMethod is returned that is aware of the MockAnything's
-         state (record or replay).    The call will be recorded or replayed
-         by the MockMethod's __call__.
-
-        Args:
-            # method name: the name of the method being called.
-            method_name: str
-
-        Returns:
-            A new MockMethod aware of MockAnything's state (record or replay).
-        """
-        if method_name == '__dir__':
-                return self.__class__.__dir__.__get__(self, self.__class__)
-
-        return self._CreateMockMethod(method_name)
-
-    def __str__(self):
-        return self._CreateMockMethod('__str__')()
-
-    def __call__(self, *args, **kwargs):
-        return self._CreateMockMethod('__call__')(*args, **kwargs)
-
-    def __getitem__(self, i):
-        return self._CreateMockMethod('__getitem__')(i)
-
-    def _CreateMockMethod(self, method_name, method_to_mock=None,
-                          class_to_bind=object):
-        """Create a new mock method call and return it.
-
-        Args:
-            # method_name: the name of the method being called.
-            # method_to_mock: The actual method being mocked, used for
-            #                 introspection.
-            # class_to_bind: Class to which method is bounded
-            #                (object by default)
-            method_name: str
-            method_to_mock: a method object
-
-        Returns:
-            A new MockMethod aware of MockAnything's state (record or replay).
-        """
-
-        return MockMethod(method_name, self._expected_calls_queue,
-                          self._replay_mode, method_to_mock=method_to_mock,
-                          description=self._description,
-                          class_to_bind=class_to_bind)
-
-    def __nonzero__(self):
-        """Return 1 for nonzero so the mock can be used as a conditional."""
-
-        return 1
-
-    def __bool__(self):
-        """Return True for nonzero so the mock can be used as a conditional."""
-        return True
-
-    def __eq__(self, rhs):
-        """Provide custom logic to compare objects."""
-
-        return (isinstance(rhs, MockAnything) and
-                self._replay_mode == rhs._replay_mode and
-                self._expected_calls_queue == rhs._expected_calls_queue)
-
-    def __ne__(self, rhs):
-        """Provide custom logic to compare objects."""
-
-        return not self == rhs
-
-    def _Replay(self):
-        """Start replaying expected method calls."""
-
-        self._replay_mode = True
-
-    def _Verify(self):
-        """Verify that all of the expected calls have been made.
-
-        Raises:
-            ExpectedMethodCallsError: if there are still more method calls in
-                                      the expected queue.
-        """
-
-        # If the list of expected calls is not empty, raise an exception
-        if self._expected_calls_queue:
-            # The last MultipleTimesGroup is not popped from the queue.
-            if (len(self._expected_calls_queue) == 1 and
-                    isinstance(self._expected_calls_queue[0],
-                               MultipleTimesGroup) and
-                    self._expected_calls_queue[0].IsSatisfied()):
-                pass
-            else:
-                raise ExpectedMethodCallsError(self._expected_calls_queue)
-
-    def _Reset(self):
-        """Reset the state of this mock to record mode with an empty queue."""
-
-        # Maintain a list of method calls we are expecting
-        self._expected_calls_queue = collections.deque()
-
-        # Make sure we are in setup mode, not replay mode
-        self._replay_mode = False
-
-
-class MockObject(MockAnything):
-    """Mock object that simulates the public/protected interface of a class."""
-
-    def __init__(self, class_to_mock, attrs=None, class_to_bind=None):
-        """Initialize a mock object.
-
-        Determines the methods and properties of the class and stores them.
-
-        Args:
-            # class_to_mock: class to be mocked
-            class_to_mock: class
-            attrs: dict of attribute names to values that will be set on the
-                   mock object. Only public attributes may be set.
-            class_to_bind: optionally, when class_to_mock is not a class at
-                           all, it points to a real class
-
-        Raises:
-            PrivateAttributeError: if a supplied attribute is not public.
-            ValueError: if an attribute would mask an existing method.
-        """
-        if attrs is None:
-            attrs = {}
-
-        # Used to hack around the mixin/inheritance of MockAnything, which
-        # is not a proper object (it can be anything. :-)
-        MockAnything.__dict__['__init__'](self)
-
-        # Get a list of all the public and special methods we should mock.
-        self._known_methods = set()
-        self._known_vars = set()
-        self._class_to_mock = class_to_mock
-
-        if inspect.isclass(class_to_mock):
-            self._class_to_bind = self._class_to_mock
-        else:
-            self._class_to_bind = class_to_bind
-
-        try:
-            if inspect.isclass(self._class_to_mock):
-                self._description = class_to_mock.__name__
-            else:
-                self._description = type(class_to_mock).__name__
-        except Exception:
-            pass
-
-        for method in dir(class_to_mock):
-            attr = getattr(class_to_mock, method)
-            if callable(attr):
-                self._known_methods.add(method)
-            elif not (type(attr) is property):
-                # treating properties as class vars makes little sense.
-                self._known_vars.add(method)
-
-        # Set additional attributes at instantiation time; this is quicker
-        # than manually setting attributes that are normally created in
-        # __init__.
-        for attr, value in attrs.items():
-            if attr.startswith("_"):
-                raise PrivateAttributeError(attr)
-            elif attr in self._known_methods:
-                raise ValueError("'%s' is a method of '%s' objects." % (attr,
-                                 class_to_mock))
-            else:
-                setattr(self, attr, value)
-
-    def _CreateMockMethod(self, *args, **kwargs):
-        """Overridden to provide self._class_to_mock to class_to_bind."""
-        kwargs.setdefault("class_to_bind", self._class_to_bind)
-        return super(MockObject, self)._CreateMockMethod(*args, **kwargs)
-
-    def __getattr__(self, name):
-        """Intercept attribute request on this object.
-
-        If the attribute is a public class variable, it will be returned and
-        not recorded as a call.
-
-        If the attribute is not a variable, it is handled like a method
-        call. The method name is checked against the set of mockable
-        methods, and a new MockMethod is returned that is aware of the
-        MockObject's state (record or replay).    The call will be recorded
-        or replayed by the MockMethod's __call__.
-
-        Args:
-            # name: the name of the attribute being requested.
-            name: str
-
-        Returns:
-            Either a class variable or a new MockMethod that is aware of the
-            state of the mock (record or replay).
-
-        Raises:
-            UnknownMethodCallError if the MockObject does not mock the
-            requested method.
-        """
-
-        if name in self._known_vars:
-            return getattr(self._class_to_mock, name)
-
-        if name in self._known_methods:
-            return self._CreateMockMethod(
-                name,
-                method_to_mock=getattr(self._class_to_mock, name))
-
-        raise UnknownMethodCallError(name)
-
-    def __eq__(self, rhs):
-        """Provide custom logic to compare objects."""
-
-        return (isinstance(rhs, MockObject) and
-                self._class_to_mock == rhs._class_to_mock and
-                self._replay_mode == rhs._replay_mode and
-                self._expected_calls_queue == rhs._expected_calls_queue)
-
-    def __setitem__(self, key, value):
-        """Custom logic for mocking classes that support item assignment.
-
-        Args:
-            key: Key to set the value for.
-            value: Value to set.
-
-        Returns:
-            Expected return value in replay mode. A MockMethod object for the
-            __setitem__ method that has already been called if not in replay
-            mode.
-
-        Raises:
-            TypeError if the underlying class does not support item assignment.
-            UnexpectedMethodCallError if the object does not expect the call to
-                __setitem__.
-
-        """
-        # Verify the class supports item assignment.
-        if '__setitem__' not in dir(self._class_to_mock):
-            raise TypeError('object does not support item assignment')
-
-        # If we are in replay mode then simply call the mock __setitem__ method
-        if self._replay_mode:
-            return MockMethod('__setitem__', self._expected_calls_queue,
-                              self._replay_mode)(key, value)
-
-        # Otherwise, create a mock method __setitem__.
-        return self._CreateMockMethod('__setitem__')(key, value)
-
-    def __getitem__(self, key):
-        """Provide custom logic for mocking classes that are subscriptable.
-
-        Args:
-            key: Key to return the value for.
-
-        Returns:
-            Expected return value in replay mode. A MockMethod object for the
-            __getitem__ method that has already been called if not in replay
-            mode.
-
-        Raises:
-            TypeError if the underlying class is not subscriptable.
-            UnexpectedMethodCallError if the object does not expect the call to
-                __getitem__.
-
-        """
-        # Verify the class supports item assignment.
-        if '__getitem__' not in dir(self._class_to_mock):
-            raise TypeError('unsubscriptable object')
-
-        # If we are in replay mode then simply call the mock __getitem__ method
-        if self._replay_mode:
-            return MockMethod('__getitem__', self._expected_calls_queue,
-                              self._replay_mode)(key)
-
-        # Otherwise, create a mock method __getitem__.
-        return self._CreateMockMethod('__getitem__')(key)
-
-    def __iter__(self):
-        """Provide custom logic for mocking classes that are iterable.
-
-        Returns:
-            Expected return value in replay mode. A MockMethod object for the
-            __iter__ method that has already been called if not in replay mode.
-
-        Raises:
-            TypeError if the underlying class is not iterable.
-            UnexpectedMethodCallError if the object does not expect the call to
-                __iter__.
-
-        """
-        methods = dir(self._class_to_mock)
-
-        # Verify the class supports iteration.
-        if '__iter__' not in methods:
-            # If it doesn't have iter method and we are in replay method,
-            # then try to iterate using subscripts.
-            if '__getitem__' not in methods or not self._replay_mode:
-                raise TypeError('not iterable object')
-            else:
-                results = []
-                index = 0
-                try:
-                    while True:
-                        results.append(self[index])
-                        index += 1
-                except IndexError:
-                    return iter(results)
-
-        # If we are in replay mode then simply call the mock __iter__ method.
-        if self._replay_mode:
-            return MockMethod('__iter__', self._expected_calls_queue,
-                              self._replay_mode)()
-
-        # Otherwise, create a mock method __iter__.
-        return self._CreateMockMethod('__iter__')()
-
-    def __contains__(self, key):
-        """Provide custom logic for mocking classes that contain items.
-
-        Args:
-            key: Key to look in container for.
-
-        Returns:
-            Expected return value in replay mode. A MockMethod object for the
-            __contains__ method that has already been called if not in replay
-            mode.
-
-        Raises:
-            TypeError if the underlying class does not implement __contains__
-            UnexpectedMethodCaller if the object does not expect the call to
-            __contains__.
-
-        """
-        contains = self._class_to_mock.__dict__.get('__contains__', None)
-
-        if contains is None:
-            raise TypeError('unsubscriptable object')
-
-        if self._replay_mode:
-            return MockMethod('__contains__', self._expected_calls_queue,
-                              self._replay_mode)(key)
-
-        return self._CreateMockMethod('__contains__')(key)
-
-    def __call__(self, *params, **named_params):
-        """Provide custom logic for mocking classes that are callable."""
-
-        # Verify the class we are mocking is callable.
-        is_callable = hasattr(self._class_to_mock, '__call__')
-        if not is_callable:
-            raise TypeError('Not callable')
-
-        # Because the call is happening directly on this object instead of
-        # a method, the call on the mock method is made right here
-
-        # If we are mocking a Function, then use the function, and not the
-        # __call__ method
-        method = None
-        if type(self._class_to_mock) in (types.FunctionType, types.MethodType):
-            method = self._class_to_mock
-        else:
-            method = getattr(self._class_to_mock, '__call__')
-        mock_method = self._CreateMockMethod('__call__', method_to_mock=method)
-
-        return mock_method(*params, **named_params)
-
-    @property
-    def __name__(self):
-        """Return the name that is being mocked."""
-        return self._description
-
-    # TODO(dejw): this property stopped to work after I introduced changes with
-    #     binding classes. Fortunately I found a solution in the form of
-    #     __getattribute__ method below, but this issue should be investigated
-    @property
-    def __class__(self):
-        return self._class_to_mock
-
-    def __dir__(self):
-        """Return only attributes of a class to mock."""
-        return dir(self._class_to_mock)
-
-    def __getattribute__(self, name):
-        """Return _class_to_mock on __class__ attribute."""
-        if name == "__class__":
-            return super(MockObject, self).__getattribute__("_class_to_mock")
-
-        return super(MockObject, self).__getattribute__(name)
-
-
-class _MockObjectFactory(MockObject):
-    """A MockObjectFactory creates mocks and verifies __init__ params.
-
-    A MockObjectFactory removes the boiler plate code that was previously
-    necessary to stub out direction instantiation of a class.
-
-    The MockObjectFactory creates new MockObjects when called and verifies the
-    __init__ params are correct when in record mode.    When replaying,
-    existing mocks are returned, and the __init__ params are verified.
-
-    See StubOutWithMock vs StubOutClassWithMocks for more detail.
-    """
-
-    def __init__(self, class_to_mock, mox_instance):
-        MockObject.__init__(self, class_to_mock)
-        self._mox = mox_instance
-        self._instance_queue = collections.deque()
-
-    def __call__(self, *params, **named_params):
-        """Instantiate and record that a new mock has been created."""
-
-        method = getattr(self._class_to_mock, '__init__')
-        mock_method = self._CreateMockMethod('__init__', method_to_mock=method)
-        # Note: calling mock_method() is deferred in order to catch the
-        # empty instance_queue first.
-
-        if self._replay_mode:
-            if not self._instance_queue:
-                raise UnexpectedMockCreationError(self._class_to_mock, *params,
-                                                  **named_params)
-
-            mock_method(*params, **named_params)
-
-            return self._instance_queue.pop()
-        else:
-            mock_method(*params, **named_params)
-
-            instance = self._mox.CreateMock(self._class_to_mock)
-            self._instance_queue.appendleft(instance)
-            return instance
-
-    def _Verify(self):
-        """Verify that all mocks have been created."""
-        if self._instance_queue:
-            raise ExpectedMockCreationError(self._instance_queue)
-        super(_MockObjectFactory, self)._Verify()
-
-
-class MethodSignatureChecker(object):
-    """Ensures that methods are called correctly."""
-
-    _NEEDED, _DEFAULT, _GIVEN = range(3)
-
-    def __init__(self, method, class_to_bind=None):
-        """Creates a checker.
-
-        Args:
-            # method: A method to check.
-            # class_to_bind: optionally, a class used to type check first
-            #                method parameter, only used with unbound methods
-            method: function
-            class_to_bind: type or None
-
-        Raises:
-            ValueError: method could not be inspected, so checks aren't
-                        possible. Some methods and functions like built-ins
-                        can't be inspected.
-        """
-        try:
-            self._args, varargs, varkw, defaults = inspect.getargspec(method)
-        except TypeError:
-            raise ValueError('Could not get argument specification for %r'
-                             % (method,))
-        if inspect.ismethod(method) or class_to_bind:
-            self._args = self._args[1:]    # Skip 'self'.
-        self._method = method
-        self._instance = None    # May contain the instance this is bound to.
-        self._instance = getattr(method, "__self__", None)
-
-        # _bounded_to determines whether the method is bound or not
-        if self._instance:
-            self._bounded_to = self._instance.__class__
-        else:
-            self._bounded_to = class_to_bind or getattr(method, "im_class",
-                                                        None)
-
-        self._has_varargs = varargs is not None
-        self._has_varkw = varkw is not None
-        if defaults is None:
-            self._required_args = self._args
-            self._default_args = []
-        else:
-            self._required_args = self._args[:-len(defaults)]
-            self._default_args = self._args[-len(defaults):]
-
-    def _RecordArgumentGiven(self, arg_name, arg_status):
-        """Mark an argument as being given.
-
-        Args:
-            # arg_name: The name of the argument to mark in arg_status.
-            # arg_status: Maps argument names to one of
-            #             _NEEDED, _DEFAULT, _GIVEN.
-            arg_name: string
-            arg_status: dict
-
-        Raises:
-            AttributeError: arg_name is already marked as _GIVEN.
-        """
-        if arg_status.get(arg_name, None) == MethodSignatureChecker._GIVEN:
-            raise AttributeError('%s provided more than once' % (arg_name,))
-        arg_status[arg_name] = MethodSignatureChecker._GIVEN
-
-    def Check(self, params, named_params):
-        """Ensures that the parameters used while recording a call are valid.
-
-        Args:
-            # params: A list of positional parameters.
-            # named_params: A dict of named parameters.
-            params: list
-            named_params: dict
-
-        Raises:
-            AttributeError: the given parameters don't work with the given
-                            method.
-        """
-        arg_status = dict((a, MethodSignatureChecker._NEEDED)
-                          for a in self._required_args)
-        for arg in self._default_args:
-            arg_status[arg] = MethodSignatureChecker._DEFAULT
-
-        # WARNING: Suspect hack ahead.
-        #
-        # Check to see if this is an unbound method, where the instance
-        # should be bound as the first argument.    We try to determine if
-        # the first argument (param[0]) is an instance of the class, or it
-        # is equivalent to the class (used to account for Comparators).
-        #
-        # NOTE: If a Func() comparator is used, and the signature is not
-        # correct, this will cause extra executions of the function.
-        if inspect.ismethod(self._method) or self._bounded_to:
-            # The extra param accounts for the bound instance.
-            if len(params) > len(self._required_args):
-                expected = self._bounded_to
-
-                # Check if the param is an instance of the expected class,
-                # or check equality (useful for checking Comparators).
-
-                # This is a hack to work around the fact that the first
-                # parameter can be a Comparator, and the comparison may raise
-                # an exception during this comparison, which is OK.
-                try:
-                    param_equality = (params[0] == expected)
-                except Exception:
-                    param_equality = False
-
-                if isinstance(params[0], expected) or param_equality:
-                    params = params[1:]
-                # If the IsA() comparator is being used, we need to check the
-                # inverse of the usual case - that the given instance is a
-                # subclass of the expected class. For example, the code under
-                # test does late binding to a subclass.
-                elif (isinstance(params[0], IsA) and
-                      params[0]._IsSubClass(expected)):
-                    params = params[1:]
-
-        # Check that each positional param is valid.
-        for i in range(len(params)):
-            try:
-                arg_name = self._args[i]
-            except IndexError:
-                if not self._has_varargs:
-                    raise AttributeError(
-                        '%s does not take %d or more positional '
-                        'arguments' % (self._method.__name__, i))
-            else:
-                self._RecordArgumentGiven(arg_name, arg_status)
-
-        # Check each keyword argument.
-        for arg_name in named_params:
-            if arg_name not in arg_status and not self._has_varkw:
-                raise AttributeError('%s is not expecting keyword argument %s'
-                                     % (self._method.__name__, arg_name))
-            self._RecordArgumentGiven(arg_name, arg_status)
-
-        # Ensure all the required arguments have been given.
-        still_needed = [k for k, v in arg_status.items()
-                        if v == MethodSignatureChecker._NEEDED]
-        if still_needed:
-            raise AttributeError('No values given for arguments: %s'
-                                 % (' '.join(sorted(still_needed))))
-
-
-class MockMethod(object):
-    """Callable mock method.
-
-    A MockMethod should act exactly like the method it mocks, accepting
-    parameters and returning a value, or throwing an exception (as specified).
-    When this method is called, it can optionally verify whether the called
-    method (name and signature) matches the expected method.
-    """
-
-    def __init__(self, method_name, call_queue, replay_mode,
-                 method_to_mock=None, description=None, class_to_bind=None):
-        """Construct a new mock method.
-
-        Args:
-            # method_name: the name of the method
-            # call_queue: deque of calls, verify this call against the head,
-            #             or add this call to the queue.
-            # replay_mode: False if we are recording, True if we are verifying
-            #              calls against the call queue.
-            # method_to_mock: The actual method being mocked, used for
-            #                 introspection.
-            # description: optionally, a descriptive name for this method.
-            #              Typically this is equal to the descriptive name of
-            #              the method's class.
-            # class_to_bind: optionally, a class that is used for unbound
-            #                methods (or functions in Python3) to which method
-            #                is bound, in order not to loose binding
-            #                information. If given, it will be used for
-            #                checking the type of first method parameter
-            method_name: str
-            call_queue: list or deque
-            replay_mode: bool
-            method_to_mock: a method object
-            description: str or None
-            class_to_bind: type or None
-        """
-
-        self._name = method_name
-        self.__name__ = method_name
-        self._call_queue = call_queue
-        if not isinstance(call_queue, collections.deque):
-            self._call_queue = collections.deque(self._call_queue)
-        self._replay_mode = replay_mode
-        self._description = description
-
-        self._params = None
-        self._named_params = None
-        self._return_value = None
-        self._exception = None
-        self._side_effects = None
-
-        try:
-            self._checker = MethodSignatureChecker(method_to_mock,
-                                                   class_to_bind=class_to_bind)
-        except ValueError:
-            self._checker = None
-
-    def __call__(self, *params, **named_params):
-        """Log parameters and return the specified return value.
-
-        If the Mock(Anything/Object) associated with this call is in record
-        mode, this MockMethod will be pushed onto the expected call queue.
-        If the mock is in replay mode, this will pop a MockMethod off the
-        top of the queue and verify this call is equal to the expected call.
-
-        Raises:
-            UnexpectedMethodCall if this call is supposed to match an expected
-                method call and it does not.
-        """
-
-        self._params = params
-        self._named_params = named_params
-
-        if not self._replay_mode:
-            if self._checker is not None:
-                self._checker.Check(params, named_params)
-            self._call_queue.append(self)
-            return self
-
-        expected_method = self._VerifyMethodCall()
-
-        if expected_method._side_effects:
-            result = expected_method._side_effects(*params, **named_params)
-            if expected_method._return_value is None:
-                expected_method._return_value = result
-
-        if expected_method._exception:
-            raise expected_method._exception
-
-        return expected_method._return_value
-
-    def __getattr__(self, name):
-        """Raise an AttributeError with a helpful message."""
-
-        raise AttributeError(
-            'MockMethod has no attribute "%s". '
-            'Did you remember to put your mocks in replay mode?' % name)
-
-    def __iter__(self):
-        """Raise a TypeError with a helpful message."""
-        raise TypeError(
-            'MockMethod cannot be iterated. '
-            'Did you remember to put your mocks in replay mode?')
-
-    def next(self):
-        """Raise a TypeError with a helpful message."""
-        raise TypeError(
-            'MockMethod cannot be iterated. '
-            'Did you remember to put your mocks in replay mode?')
-
-    def __next__(self):
-        """Raise a TypeError with a helpful message."""
-        raise TypeError(
-            'MockMethod cannot be iterated. '
-            'Did you remember to put your mocks in replay mode?')
-
-    def _PopNextMethod(self):
-        """Pop the next method from our call queue."""
-        try:
-            return self._call_queue.popleft()
-        except IndexError:
-            raise UnexpectedMethodCallError(self, None)
-
-    def _VerifyMethodCall(self):
-        """Verify the called method is expected.
-
-        This can be an ordered method, or part of an unordered set.
-
-        Returns:
-            The expected mock method.
-
-        Raises:
-            UnexpectedMethodCall if the method called was not expected.
-        """
-
-        expected = self._PopNextMethod()
-
-        # Loop here, because we might have a MethodGroup followed by another
-        # group.
-        while isinstance(expected, MethodGroup):
-            expected, method = expected.MethodCalled(self)
-            if method is not None:
-                return method
-
-        # This is a mock method, so just check equality.
-        if expected != self:
-            raise UnexpectedMethodCallError(self, expected)
-
-        return expected
-
-    def __str__(self):
-        params = ', '.join(
-            [repr(p) for p in self._params or []] +
-            ['%s=%r' % x for x in sorted((self._named_params or {}).items())])
-        full_desc = "%s(%s) -> %r" % (self._name, params, self._return_value)
-        if self._description:
-            full_desc = "%s.%s" % (self._description, full_desc)
-        return full_desc
-
-    def __hash__(self):
-        return id(self)
-
-    def __eq__(self, rhs):
-        """Test whether this MockMethod is equivalent to another MockMethod.
-
-        Args:
-            # rhs: the right hand side of the test
-            rhs: MockMethod
-        """
-
-        return (isinstance(rhs, MockMethod) and
-                self._name == rhs._name and
-                self._params == rhs._params and
-                self._named_params == rhs._named_params)
-
-    def __ne__(self, rhs):
-        """Test if this MockMethod is not equivalent to another MockMethod.
-
-        Args:
-            # rhs: the right hand side of the test
-            rhs: MockMethod
-        """
-
-        return not self == rhs
-
-    def GetPossibleGroup(self):
-        """Returns a possible group from the end of the call queue.
-
-        Return None if no other methods are on the stack.
-        """
-
-        # Remove this method from the tail of the queue so we can add it
-        # to a group.
-        this_method = self._call_queue.pop()
-        assert this_method == self
-
-        # Determine if the tail of the queue is a group, or just a regular
-        # ordered mock method.
-        group = None
-        try:
-            group = self._call_queue[-1]
-        except IndexError:
-            pass
-
-        return group
-
-    def _CheckAndCreateNewGroup(self, group_name, group_class):
-        """Checks if the last method (a possible group) is an instance of our
-        group_class. Adds the current method to this group or creates a
-        new one.
-
-        Args:
-
-            group_name: the name of the group.
-            group_class: the class used to create instance of this new group
-        """
-        group = self.GetPossibleGroup()
-
-        # If this is a group, and it is the correct group, add the method.
-        if isinstance(group, group_class) and group.group_name() == group_name:
-            group.AddMethod(self)
-            return self
-
-        # Create a new group and add the method.
-        new_group = group_class(group_name)
-        new_group.AddMethod(self)
-        self._call_queue.append(new_group)
-        return self
-
-    def InAnyOrder(self, group_name="default"):
-        """Move this method into a group of unordered calls.
-
-        A group of unordered calls must be defined together, and must be
-        executed in full before the next expected method can be called.
-        There can be multiple groups that are expected serially, if they are
-        given different group names. The same group name can be reused if there
-        is a standard method call, or a group with a different name, spliced
-        between usages.
-
-        Args:
-            group_name: the name of the unordered group.
-
-        Returns:
-            self
-        """
-        return self._CheckAndCreateNewGroup(group_name, UnorderedGroup)
-
-    def MultipleTimes(self, group_name="default"):
-        """Move method into group of calls which may be called multiple times.
-
-        A group of repeating calls must be defined together, and must be
-        executed in full before the next expected method can be called.
-
-        Args:
-            group_name: the name of the unordered group.
-
-        Returns:
-            self
-        """
-        return self._CheckAndCreateNewGroup(group_name, MultipleTimesGroup)
-
-    def AndReturn(self, return_value):
-        """Set the value to return when this method is called.
-
-        Args:
-            # return_value can be anything.
-        """
-
-        self._return_value = return_value
-        return return_value
-
-    def AndRaise(self, exception):
-        """Set the exception to raise when this method is called.
-
-        Args:
-            # exception: the exception to raise when this method is called.
-            exception: Exception
-        """
-
-        self._exception = exception
-
-    def WithSideEffects(self, side_effects):
-        """Set the side effects that are simulated when this method is called.
-
-        Args:
-            side_effects: A callable which modifies the parameters or other
-                          relevant state which a given test case depends on.
-
-        Returns:
-            Self for chaining with AndReturn and AndRaise.
-        """
-        self._side_effects = side_effects
-        return self
-
-
-class Comparator:
-    """Base class for all Mox comparators.
-
-    A Comparator can be used as a parameter to a mocked method when the exact
-    value is not known.    For example, the code you are testing might build up
-    a long SQL string that is passed to your mock DAO. You're only interested
-    that the IN clause contains the proper primary keys, so you can set your
-    mock up as follows:
-
-    mock_dao.RunQuery(StrContains('IN (1, 2, 4, 5)')).AndReturn(mock_result)
-
-    Now whatever query is passed in must contain the string 'IN (1, 2, 4, 5)'.
-
-    A Comparator may replace one or more parameters, for example:
-    # return at most 10 rows
-    mock_dao.RunQuery(StrContains('SELECT'), 10)
-
-    or
-
-    # Return some non-deterministic number of rows
-    mock_dao.RunQuery(StrContains('SELECT'), IsA(int))
-    """
-
-    def equals(self, rhs):
-        """Special equals method that all comparators must implement.
-
-        Args:
-            rhs: any python object
-        """
-
-        raise NotImplementedError('method must be implemented by a subclass.')
-
-    def __eq__(self, rhs):
-        return self.equals(rhs)
-
-    def __ne__(self, rhs):
-        return not self.equals(rhs)
-
-
-class Is(Comparator):
-    """Comparison class used to check identity, instead of equality."""
-
-    def __init__(self, obj):
-        self._obj = obj
-
-    def equals(self, rhs):
-        return rhs is self._obj
-
-    def __repr__(self):
-        return "<is %r (%s)>" % (self._obj, id(self._obj))
-
-
-class IsA(Comparator):
-    """This class wraps a basic Python type or class.    It is used to verify
-    that a parameter is of the given type or class.
-
-    Example:
-    mock_dao.Connect(IsA(DbConnectInfo))
-    """
-
-    def __init__(self, class_name):
-        """Initialize IsA
-
-        Args:
-            class_name: basic python type or a class
-        """
-
-        self._class_name = class_name
-
-    def equals(self, rhs):
-        """Check to see if the RHS is an instance of class_name.
-
-        Args:
-            # rhs: the right hand side of the test
-            rhs: object
-
-        Returns:
-            bool
-        """
-
-        try:
-            return isinstance(rhs, self._class_name)
-        except TypeError:
-            # Check raw types if there was a type error.    This is helpful for
-            # things like cStringIO.StringIO.
-            return type(rhs) == type(self._class_name)
-
-    def _IsSubClass(self, clazz):
-        """Check to see if the IsA comparators class is a subclass of clazz.
-
-        Args:
-            # clazz: a class object
-
-        Returns:
-            bool
-        """
-
-        try:
-            return issubclass(self._class_name, clazz)
-        except TypeError:
-            # Check raw types if there was a type error.    This is helpful for
-            # things like cStringIO.StringIO.
-            return type(clazz) == type(self._class_name)
-
-    def __repr__(self):
-        return 'mox.IsA(%s) ' % str(self._class_name)
-
-
-class IsAlmost(Comparator):
-    """Comparison class used to check whether a parameter is nearly equal
-    to a given value.    Generally useful for floating point numbers.
-
-    Example mock_dao.SetTimeout((IsAlmost(3.9)))
-    """
-
-    def __init__(self, float_value, places=7):
-        """Initialize IsAlmost.
-
-        Args:
-            float_value: The value for making the comparison.
-            places: The number of decimal places to round to.
-        """
-
-        self._float_value = float_value
-        self._places = places
-
-    def equals(self, rhs):
-        """Check to see if RHS is almost equal to float_value
-
-        Args:
-            rhs: the value to compare to float_value
-
-        Returns:
-            bool
-        """
-
-        try:
-            return round(rhs - self._float_value, self._places) == 0
-        except Exception:
-            # Probably because either float_value or rhs is not a number.
-            return False
-
-    def __repr__(self):
-        return str(self._float_value)
-
-
-class StrContains(Comparator):
-    """Comparison class used to check whether a substring exists in a
-    string parameter.    This can be useful in mocking a database with SQL
-    passed in as a string parameter, for example.
-
-    Example:
-    mock_dao.RunQuery(StrContains('IN (1, 2, 4, 5)')).AndReturn(mock_result)
-    """
-
-    def __init__(self, search_string):
-        """Initialize.
-
-        Args:
-            # search_string: the string you are searching for
-            search_string: str
-        """
-
-        self._search_string = search_string
-
-    def equals(self, rhs):
-        """Check to see if the search_string is contained in the rhs string.
-
-        Args:
-            # rhs: the right hand side of the test
-            rhs: object
-
-        Returns:
-            bool
-        """
-
-        try:
-            return rhs.find(self._search_string) > -1
-        except Exception:
-            return False
-
-    def __repr__(self):
-        return '<str containing \'%s\'>' % self._search_string
-
-
-class Regex(Comparator):
-    """Checks if a string matches a regular expression.
-
-    This uses a given regular expression to determine equality.
-    """
-
-    def __init__(self, pattern, flags=0):
-        """Initialize.
-
-        Args:
-            # pattern is the regular expression to search for
-            pattern: str
-            # flags passed to re.compile function as the second argument
-            flags: int
-        """
-        self.flags = flags
-        self.regex = re.compile(pattern, flags=flags)
-
-    def equals(self, rhs):
-        """Check to see if rhs matches regular expression pattern.
-
-        Returns:
-            bool
-        """
-
-        try:
-            return self.regex.search(rhs) is not None
-        except Exception:
-            return False
-
-    def __repr__(self):
-        s = '<regular expression \'%s\'' % self.regex.pattern
-        if self.flags:
-            s += ', flags=%d' % self.flags
-        s += '>'
-        return s
-
-
-class In(Comparator):
-    """Checks whether an item (or key) is in a list (or dict) parameter.
-
-    Example:
-    mock_dao.GetUsersInfo(In('expectedUserName')).AndReturn(mock_result)
-    """
-
-    def __init__(self, key):
-        """Initialize.
-
-        Args:
-            # key is any thing that could be in a list or a key in a dict
-        """
-
-        self._key = key
-
-    def equals(self, rhs):
-        """Check to see whether key is in rhs.
-
-        Args:
-            rhs: dict
-
-        Returns:
-            bool
-        """
-
-        try:
-            return self._key in rhs
-        except Exception:
-            return False
-
-    def __repr__(self):
-        return '<sequence or map containing \'%s\'>' % str(self._key)
-
-
-class Not(Comparator):
-    """Checks whether a predicates is False.
-
-    Example:
-        mock_dao.UpdateUsers(Not(ContainsKeyValue('stevepm',
-                                                  stevepm_user_info)))
-    """
-
-    def __init__(self, predicate):
-        """Initialize.
-
-        Args:
-            # predicate: a Comparator instance.
-        """
-
-        assert isinstance(predicate, Comparator), ("predicate %r must be a"
-                                                   " Comparator." % predicate)
-        self._predicate = predicate
-
-    def equals(self, rhs):
-        """Check to see whether the predicate is False.
-
-        Args:
-            rhs: A value that will be given in argument of the predicate.
-
-        Returns:
-            bool
-        """
-
-        try:
-            return not self._predicate.equals(rhs)
-        except Exception:
-            return False
-
-    def __repr__(self):
-        return '<not \'%s\'>' % self._predicate
-
-
-class ContainsKeyValue(Comparator):
-    """Checks whether a key/value pair is in a dict parameter.
-
-    Example:
-    mock_dao.UpdateUsers(ContainsKeyValue('stevepm', stevepm_user_info))
-    """
-
-    def __init__(self, key, value):
-        """Initialize.
-
-        Args:
-            # key: a key in a dict
-            # value: the corresponding value
-        """
-
-        self._key = key
-        self._value = value
-
-    def equals(self, rhs):
-        """Check whether the given key/value pair is in the rhs dict.
-
-        Returns:
-            bool
-        """
-
-        try:
-            return rhs[self._key] == self._value
-        except Exception:
-            return False
-
-    def __repr__(self):
-        return '<map containing the entry \'%s: %s\'>' % (str(self._key),
-                                                          str(self._value))
-
-
-class ContainsAttributeValue(Comparator):
-    """Checks whether passed parameter contains attributes with a given value.
-
-    Example:
-    mock_dao.UpdateSomething(ContainsAttribute('stevepm', stevepm_user_info))
-    """
-
-    def __init__(self, key, value):
-        """Initialize.
-
-        Args:
-            # key: an attribute name of an object
-            # value: the corresponding value
-        """
-
-        self._key = key
-        self._value = value
-
-    def equals(self, rhs):
-        """Check if the given attribute has a matching value in the rhs object.
-
-        Returns:
-            bool
-        """
-
-        try:
-            return getattr(rhs, self._key) == self._value
-        except Exception:
-            return False
-
-
-class SameElementsAs(Comparator):
-    """Checks whether sequences contain the same elements (ignoring order).
-
-    Example:
-    mock_dao.ProcessUsers(SameElementsAs('stevepm', 'salomaki'))
-    """
-
-    def __init__(self, expected_seq):
-        """Initialize.
-
-        Args:
-            expected_seq: a sequence
-        """
-        # Store in case expected_seq is an iterator.
-        self._expected_list = list(expected_seq)
-
-    def equals(self, actual_seq):
-        """Check to see whether actual_seq has same elements as expected_seq.
-
-        Args:
-            actual_seq: sequence
-
-        Returns:
-            bool
-        """
-        try:
-            # Store in case actual_seq is an iterator. We potentially iterate
-            # twice: once to make the dict, once in the list fallback.
-            actual_list = list(actual_seq)
-        except TypeError:
-            # actual_seq cannot be read as a sequence.
-            #
-            # This happens because Mox uses __eq__ both to check object
-            # equality (in MethodSignatureChecker) and to invoke Comparators.
-            return False
-
-        try:
-            return set(self._expected_list) == set(actual_list)
-        except TypeError:
-            # Fall back to slower list-compare if any of the objects
-            # are unhashable.
-            if len(self._expected_list) != len(actual_list):
-                return False
-            for el in actual_list:
-                if el not in self._expected_list:
-                    return False
-        return True
-
-    def __repr__(self):
-        return '<sequence with same elements as \'%s\'>' % self._expected_list
-
-
-class And(Comparator):
-    """Evaluates one or more Comparators on RHS, returns an AND of the results.
-    """
-
-    def __init__(self, *args):
-        """Initialize.
-
-        Args:
-            *args: One or more Comparator
-        """
-
-        self._comparators = args
-
-    def equals(self, rhs):
-        """Checks whether all Comparators are equal to rhs.
-
-        Args:
-            # rhs: can be anything
-
-        Returns:
-            bool
-        """
-
-        for comparator in self._comparators:
-            if not comparator.equals(rhs):
-                return False
-
-        return True
-
-    def __repr__(self):
-        return '<AND %s>' % str(self._comparators)
-
-
-class Or(Comparator):
-    """Evaluates one or more Comparators on RHS; returns OR of the results."""
-
-    def __init__(self, *args):
-        """Initialize.
-
-        Args:
-            *args: One or more Mox comparators
-        """
-
-        self._comparators = args
-
-    def equals(self, rhs):
-        """Checks whether any Comparator is equal to rhs.
-
-        Args:
-            # rhs: can be anything
-
-        Returns:
-            bool
-        """
-
-        for comparator in self._comparators:
-            if comparator.equals(rhs):
-                return True
-
-        return False
-
-    def __repr__(self):
-        return '<OR %s>' % str(self._comparators)
-
-
-class Func(Comparator):
-    """Call a function that should verify the parameter passed in is correct.
-
-    You may need the ability to perform more advanced operations on the
-    parameter in order to validate it. You can use this to have a callable
-    validate any parameter. The callable should return either True or False.
-
-
-    Example:
-
-    def myParamValidator(param):
-        # Advanced logic here
-        return True
-
-    mock_dao.DoSomething(Func(myParamValidator), true)
-    """
-
-    def __init__(self, func):
-        """Initialize.
-
-        Args:
-            func: callable that takes one parameter and returns a bool
-        """
-
-        self._func = func
-
-    def equals(self, rhs):
-        """Test whether rhs passes the function test.
-
-        rhs is passed into func.
-
-        Args:
-            rhs: any python object
-
-        Returns:
-            the result of func(rhs)
-        """
-
-        return self._func(rhs)
-
-    def __repr__(self):
-        return str(self._func)
-
-
-class IgnoreArg(Comparator):
-    """Ignore an argument.
-
-    This can be used when we don't care about an argument of a method call.
-
-    Example:
-    # Check if CastMagic is called with 3 as first arg and
-    # 'disappear' as third.
-    mymock.CastMagic(3, IgnoreArg(), 'disappear')
-    """
-
-    def equals(self, unused_rhs):
-        """Ignores arguments and returns True.
-
-        Args:
-            unused_rhs: any python object
-
-        Returns:
-            always returns True
-        """
-
-        return True
-
-    def __repr__(self):
-        return '<IgnoreArg>'
-
-
-class Value(Comparator):
-    """Compares argument against a remembered value.
-
-    To be used in conjunction with Remember comparator.    See Remember()
-    for example.
-    """
-
-    def __init__(self):
-        self._value = None
-        self._has_value = False
-
-    def store_value(self, rhs):
-        self._value = rhs
-        self._has_value = True
-
-    def equals(self, rhs):
-        if not self._has_value:
-            return False
-        else:
-            return rhs == self._value
-
-    def __repr__(self):
-        if self._has_value:
-            return "<Value %r>" % self._value
-        else:
-            return "<Value>"
-
-
-class Remember(Comparator):
-    """Remembers the argument to a value store.
-
-    To be used in conjunction with Value comparator.
-
-    Example:
-    # Remember the argument for one method call.
-    users_list = Value()
-    mock_dao.ProcessUsers(Remember(users_list))
-
-    # Check argument against remembered value.
-    mock_dao.ReportUsers(users_list)
-    """
-
-    def __init__(self, value_store):
-        if not isinstance(value_store, Value):
-            raise TypeError(
-                "value_store is not an instance of the Value class")
-        self._value_store = value_store
-
-    def equals(self, rhs):
-        self._value_store.store_value(rhs)
-        return True
-
-    def __repr__(self):
-        return "<Remember %d>" % id(self._value_store)
-
-
-class MethodGroup(object):
-    """Base class containing common behaviour for MethodGroups."""
-
-    def __init__(self, group_name):
-        self._group_name = group_name
-
-    def group_name(self):
-        return self._group_name
-
-    def __str__(self):
-        return '<%s "%s">' % (self.__class__.__name__, self._group_name)
-
-    def AddMethod(self, mock_method):
-        raise NotImplementedError
-
-    def MethodCalled(self, mock_method):
-        raise NotImplementedError
-
-    def IsSatisfied(self):
-        raise NotImplementedError
-
-
-class UnorderedGroup(MethodGroup):
-    """UnorderedGroup holds a set of method calls that may occur in any order.
-
-    This construct is helpful for non-deterministic events, such as iterating
-    over the keys of a dict.
-    """
-
-    def __init__(self, group_name):
-        super(UnorderedGroup, self).__init__(group_name)
-        self._methods = []
-
-    def __str__(self):
-        return '%s "%s" pending calls:\n%s' % (
-            self.__class__.__name__,
-            self._group_name,
-            "\n".join(str(method) for method in self._methods))
-
-    def AddMethod(self, mock_method):
-        """Add a method to this group.
-
-        Args:
-            mock_method: A mock method to be added to this group.
-        """
-
-        self._methods.append(mock_method)
-
-    def MethodCalled(self, mock_method):
-        """Remove a method call from the group.
-
-        If the method is not in the set, an UnexpectedMethodCallError will be
-        raised.
-
-        Args:
-            mock_method: a mock method that should be equal to a method in the
-                         group.
-
-        Returns:
-            The mock method from the group
-
-        Raises:
-            UnexpectedMethodCallError if the mock_method was not in the group.
-        """
-
-        # Check to see if this method exists, and if so, remove it from the set
-        # and return it.
-        for method in self._methods:
-            if method == mock_method:
-                # Remove the called mock_method instead of the method in the
-                # group. The called method will match any comparators when
-                # equality is checked during removal. The method in the group
-                # could pass a comparator to another comparator during the
-                # equality check.
-                self._methods.remove(mock_method)
-
-                # If group is not empty, put it back at the head of the queue.
-                if not self.IsSatisfied():
-                    mock_method._call_queue.appendleft(self)
-
-                return self, method
-
-        raise UnexpectedMethodCallError(mock_method, self)
-
-    def IsSatisfied(self):
-        """Return True if there are not any methods in this group."""
-
-        return len(self._methods) == 0
-
-
-class MultipleTimesGroup(MethodGroup):
-    """MultipleTimesGroup holds methods that may be called any number of times.
-
-    Note: Each method must be called at least once.
-
-    This is helpful, if you don't know or care how many times a method is
-    called.
-    """
-
-    def __init__(self, group_name):
-        super(MultipleTimesGroup, self).__init__(group_name)
-        self._methods = set()
-        self._methods_left = set()
-
-    def AddMethod(self, mock_method):
-        """Add a method to this group.
-
-        Args:
-            mock_method: A mock method to be added to this group.
-        """
-
-        self._methods.add(mock_method)
-        self._methods_left.add(mock_method)
-
-    def MethodCalled(self, mock_method):
-        """Remove a method call from the group.
-
-        If the method is not in the set, an UnexpectedMethodCallError will be
-        raised.
-
-        Args:
-            mock_method: a mock method that should be equal to a method in the
-                         group.
-
-        Returns:
-            The mock method from the group
-
-        Raises:
-            UnexpectedMethodCallError if the mock_method was not in the group.
-        """
-
-        # Check to see if this method exists, and if so add it to the set of
-        # called methods.
-        for method in self._methods:
-            if method == mock_method:
-                self._methods_left.discard(method)
-                # Always put this group back on top of the queue,
-                # because we don't know when we are done.
-                mock_method._call_queue.appendleft(self)
-                return self, method
-
-        if self.IsSatisfied():
-            next_method = mock_method._PopNextMethod()
-            return next_method, None
-        else:
-            raise UnexpectedMethodCallError(mock_method, self)
-
-    def IsSatisfied(self):
-        """Return True if all methods in group are called at least once."""
-        return len(self._methods_left) == 0
-
-
-class MoxMetaTestBase(type):
-    """Metaclass to add mox cleanup and verification to every test.
-
-    As the mox unit testing class is being constructed (MoxTestBase or a
-    subclass), this metaclass will modify all test functions to call the
-    CleanUpMox method of the test class after they finish. This means that
-    unstubbing and verifying will happen for every test with no additional
-    code, and any failures will result in test failures as opposed to errors.
-    """
-
-    def __init__(cls, name, bases, d):
-        type.__init__(cls, name, bases, d)
-
-        # also get all the attributes from the base classes to account
-        # for a case when test class is not the immediate child of MoxTestBase
-        for base in bases:
-            for attr_name in dir(base):
-                if attr_name not in d:
-                    d[attr_name] = getattr(base, attr_name)
-
-        for func_name, func in d.items():
-            if func_name.startswith('test') and callable(func):
-
-                setattr(cls, func_name, MoxMetaTestBase.CleanUpTest(cls, func))
-
-    @staticmethod
-    def CleanUpTest(cls, func):
-        """Adds Mox cleanup code to any MoxTestBase method.
-
-        Always unsets stubs after a test. Will verify all mocks for tests that
-        otherwise pass.
-
-        Args:
-            cls: MoxTestBase or subclass; the class whose method we are
-                                          altering.
-            func: method; the method of the MoxTestBase test class we wish to
-                          alter.
-
-        Returns:
-            The modified method.
-        """
-        def new_method(self, *args, **kwargs):
-            mox_obj = getattr(self, 'mox', None)
-            stubout_obj = getattr(self, 'stubs', None)
-            cleanup_mox = False
-            cleanup_stubout = False
-            if mox_obj and isinstance(mox_obj, Mox):
-                cleanup_mox = True
-            if stubout_obj and isinstance(stubout_obj,
-                                          stubout.StubOutForTesting):
-                cleanup_stubout = True
-            try:
-                func(self, *args, **kwargs)
-            finally:
-                if cleanup_mox:
-                    mox_obj.UnsetStubs()
-                if cleanup_stubout:
-                    stubout_obj.UnsetAll()
-                    stubout_obj.SmartUnsetAll()
-            if cleanup_mox:
-                mox_obj.VerifyAll()
-        new_method.__name__ = func.__name__
-        new_method.__doc__ = func.__doc__
-        new_method.__module__ = func.__module__
-        return new_method
-
-
-_MoxTestBase = MoxMetaTestBase('_MoxTestBase', (unittest.TestCase, ), {})
-
-
-class MoxTestBase(_MoxTestBase):
-    """Convenience test class to make stubbing easier.
-
-    Sets up a "mox" attribute which is an instance of Mox (any mox tests will
-    want this), and a "stubs" attribute that is an instance of
-    StubOutForTesting (needed at times). Also automatically unsets any stubs
-    and verifies that all mock methods have been called at the end of each
-    test, eliminating boilerplate code.
-    """
-
-    def setUp(self):
-        super(MoxTestBase, self).setUp()
-        self.mox = Mox()
-        self.stubs = stubout.StubOutForTesting()