RubyGems - libv8 - Versions diffs - 7.8.279.23.0beta1 → 8.4.255.0 - Mend

libv8 7.8.279.23.0beta1 → 8.4.255.0

Files changed (719) hide show

data/vendor/depot_tools/third_party/pymox/COPYING DELETED

@@ -1,202 +0,0 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-   1. Definitions.
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-   END OF TERMS AND CONDITIONS
-   APPENDIX: How to apply the Apache License to your work.
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-   Copyright [yyyy] [name of copyright owner]
-   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.

data/vendor/depot_tools/third_party/pymox/MANIFEST.in DELETED

@@ -1,5 +0,0 @@
-include COPYING
-include mox_test.py
-include mox_test_helper.py
-include stubout_test.py
-include stubout_testee.py

data/vendor/depot_tools/third_party/pymox/README DELETED

@@ -1,56 +0,0 @@
-Mox is an open source mock object framework for Python, inspired by
-the Java library EasyMock.
-To install:
-  $ python setup.py install
-To run Mox's internal tests:
-  $ python mox_test.py
-Basic usage:
-  import unittest
-  import mox
-  class PersonTest(mox.MoxTestBase):
-    def testUsingMox(self):
-      # Create a mock Person
-      mock_person = self.mox.CreateMock(Person)
-      test_person = ...
-      test_primary_key = ...
-      unknown_person = ...
-      # Expect InsertPerson to be called with test_person; return
-      # test_primary_key at that point
-      mock_person.InsertPerson(test_person).AndReturn(test_primary_key)
-      # Raise an exception when this is called
-      mock_person.DeletePerson(unknown_person).AndRaise(UnknownPersonError())
-      # Switch from record mode to replay mode
-      self.mox.ReplayAll()
-      # Run the test
-      ret_pk = mock_person.InsertPerson(test_person)
-      self.assertEquals(test_primary_key, ret_pk)
-      self.assertRaises(UnknownPersonError, mock_person, unknown_person)
-For more documentation, see:
-  http://code.google.com/p/pymox/wiki/MoxDocumentation
-For more information, see:
-  http://code.google.com/p/pymox/
-Our user and developer discussion group is:
-  http://groups.google.com/group/mox-discuss
-Mox is Copyright 2008 Google Inc, and licensed under the Apache
-License, Version 2.0; see the file COPYING for details.  If you would
-like to help us improve Mox, join the group.

data/vendor/depot_tools/third_party/pymox/__init__.py DELETED

File without changes

data/vendor/depot_tools/third_party/pymox/mox.py DELETED

@@ -1,1643 +0,0 @@
-#!/usr/bin/python2.4
-#
-# 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.
-"""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()
-"""
-from collections import deque
-import difflib
-import inspect
-import re
-import types
-import unittest
-import stubout
-class Error(AssertionError):
-  """Base exception for this module."""
-  pass
-class ExpectedMethodCallsError(Error):
-  """Raised when 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(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 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.ClassType, types.InstanceType, types.ModuleType,
-                      types.ObjectType, types.TypeType]
-  def __init__(self):
-    """Initialize a new Mox."""
-    self._mock_objects = []
-    self.stubs = stubout.StubOutForTesting()
-  def CreateMock(self, class_to_mock):
-    """Create a new mock object.
-    Args:
-      # class_to_mock: the class to be mocked
-      class_to_mock: class
-    Returns:
-      MockObject that can be used as the class_to_mock would be.
-    """
-    new_mock = MockObject(class_to_mock)
-    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.
-    """
-    attr_to_replace = getattr(obj, attr_name)
-    # Check for a MockAnything. This could cause confusing problems later on.
-    if attr_to_replace == MockAnything():
-      raise TypeError('Cannot mock a MockAnything! Did you remember to '
-                      'call UnsetStubs in your previous test?')
-    if type(attr_to_replace) in self._USE_MOCK_OBJECT and not use_mock_anything:
-      stub = self.CreateMock(attr_to_replace)
-    else:
-      stub = self.CreateMockAnything(description='Stub for %s' % attr_to_replace)
-    self.stubs.Set(obj, attr_name, stub)
-  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:
-  """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 __str__(self):
-    return "<MockAnything instance at %s>" % id(self)
-  def __repr__(self):
-    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).
-    """
-    return self._CreateMockMethod(method_name)
-  def _CreateMockMethod(self, method_name, method_to_mock=None):
-    """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.
-      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)
-  def __nonzero__(self):
-    """Return 1 for nonzero so the mock can be used as a conditional."""
-    return 1
-  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 = deque()
-    # Make sure we are in setup mode, not replay mode
-    self._replay_mode = False
-class MockObject(MockAnything, object):
-  """A mock object that simulates the public/protected interface of a class."""
-  def __init__(self, class_to_mock):
-    """Initialize a mock object.
-    This determines the methods and properties of the class and stores them.
-    Args:
-      # class_to_mock: class to be mocked
-      class_to_mock: class
-    """
-    # This is 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
-    for method in dir(class_to_mock):
-      if callable(getattr(class_to_mock, method)):
-        self._known_methods.add(method)
-      else:
-        self._known_vars.add(method)
-  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):
-    """Provide 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.
-    callable = hasattr(self._class_to_mock, '__call__')
-    if not 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
-    mock_method = self._CreateMockMethod('__call__')
-    return mock_method(*params, **named_params)
-  @property
-  def __class__(self):
-    """Return the class that is being mocked."""
-    return self._class_to_mock
-class MethodCallChecker(object):
-  """Ensures that methods are called correctly."""
-  _NEEDED, _DEFAULT, _GIVEN = range(3)
-  def __init__(self, method):
-    """Creates a checker.
-    Args:
-      # method: A method to check.
-      method: function
-    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):
-      self._args = self._args[1:]  # Skip 'self'.
-    self._method = method
-    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) == MethodCallChecker._GIVEN:
-      raise AttributeError('%s provided more than once' % (arg_name,))
-    arg_status[arg_name] = MethodCallChecker._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, MethodCallChecker._NEEDED)
-                      for a in self._required_args)
-    for arg in self._default_args:
-      arg_status[arg] = MethodCallChecker._DEFAULT
-    # 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.iteritems()
-                    if v == MethodCallChecker._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):
-    """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.
-      method_name: str
-      call_queue: list or deque
-      replay_mode: bool
-      method_to_mock: a method object
-      description: str or None
-    """
-    self._name = method_name
-    self._call_queue = call_queue
-    if not isinstance(call_queue, deque):
-      self._call_queue = 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 = MethodCallChecker(method_to_mock)
-    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:
-      expected_method._side_effects(*params, **named_params)
-    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 _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 __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 whether 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 or 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 this 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 mehtod 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 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 __repr__(self):
-    return 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 TypeError:
-      # This is 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.regex = re.compile(pattern, flags=flags)
-  def equals(self, rhs):
-    """Check to see if rhs matches regular expression pattern.
-    Returns:
-      bool
-    """
-    return self.regex.search(rhs) is not None
-  def __repr__(self):
-    s = '<regular expression \'%s\'' % self.regex.pattern
-    if self.regex.flags:
-      s += ', flags=%d' % self.regex.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
-    """
-    return self._key in rhs
-  def __repr__(self):
-    return '<sequence or map containing \'%s\'>' % 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
-    """
-    return not self._predicate.equals(rhs)
-  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\'>' % (self._key, self._value)
-class SameElementsAs(Comparator):
-  """Checks whether iterables contain the same elements (ignoring order).
-  Example:
-  mock_dao.ProcessUsers(SameElementsAs('stevepm', 'salomaki'))
-  """
-  def __init__(self, expected_seq):
-    """Initialize.
-    Args:
-      expected_seq: a sequence
-    """
-    self._expected_seq = 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:
-      expected = dict([(element, None) for element in self._expected_seq])
-      actual = dict([(element, None) for element in actual_seq])
-    except TypeError:
-      # Fall back to slower list-compare if any of the objects are unhashable.
-      expected = list(self._expected_seq)
-      actual = list(actual_seq)
-      expected.sort()
-      actual.sort()
-    return expected == actual
-  def __repr__(self):
-    return '<sequence with same elements as \'%s\'>' % self._expected_seq
-class And(Comparator):
-  """Evaluates one or more Comparators on RHS and 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 and returns an 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 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 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 this 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 this 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):
-        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 test 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)
-      cleanup_mox = False
-      if mox_obj and isinstance(mox_obj, Mox):
-        cleanup_mox = True
-      try:
-        func(self, *args, **kwargs)
-      finally:
-        if cleanup_mox:
-          mox_obj.UnsetStubs()
-      if cleanup_mox:
-        mox_obj.VerifyAll()
-    new_method.__name__ = func.__name__
-    new_method.__doc__ = func.__doc__
-    new_method.__module__ = func.__module__
-    return new_method
-class MoxTestBase(unittest.TestCase):
-  """Convenience test class to make stubbing easier.
-  Sets up a "mox" attribute which is an instance of Mox - any mox tests will
-  want this. Also automatically unsets any stubs and verifies that all mock
-  methods have been called at the end of each test, eliminating boilerplate
-  code.
-  """
-  __metaclass__ = MoxMetaTestBase
-  def setUp(self):
-    super(MoxTestBase, self).setUp()
-    self.mox = Mox()