RubyGems - libv8 - Versions diffs - 7.3.492.27.1 → 8.4.255.0 - Mend

libv8 7.3.492.27.1 → 8.4.255.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (718) 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()