libv8 7.3.492.27.0 → 8.4.255.0

data/vendor/depot_tools/third_party/pymox/mox_test.py

@@ -1,1708 +0,0 @@
-#!/usr/bin/python2.4
-#
-# Unit tests for Mox.
-#
-# 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.
-
-import cStringIO
-import unittest
-import re
-
-import mox
-
-import mox_test_helper
-
-
-class ExpectedMethodCallsErrorTest(unittest.TestCase):
-  """Test creation and string conversion of ExpectedMethodCallsError."""
-
-  def testAtLeastOneMethod(self):
-    self.assertRaises(ValueError, mox.ExpectedMethodCallsError, [])
-
-  def testOneError(self):
-    method = mox.MockMethod("testMethod", [], False)
-    method(1, 2).AndReturn('output')
-    e = mox.ExpectedMethodCallsError([method])
-    self.assertEqual(
-        "Verify: Expected methods never called:\n"
-        "  0.  testMethod(1, 2) -> 'output'",
-        str(e))
-
-  def testManyErrors(self):
-    method1 = mox.MockMethod("testMethod", [], False)
-    method1(1, 2).AndReturn('output')
-    method2 = mox.MockMethod("testMethod", [], False)
-    method2(a=1, b=2, c="only named")
-    method3 = mox.MockMethod("testMethod2", [], False)
-    method3().AndReturn(44)
-    method4 = mox.MockMethod("testMethod", [], False)
-    method4(1, 2).AndReturn('output')
-    e = mox.ExpectedMethodCallsError([method1, method2, method3, method4])
-    self.assertEqual(
-        "Verify: Expected methods never called:\n"
-        "  0.  testMethod(1, 2) -> 'output'\n"
-        "  1.  testMethod(a=1, b=2, c='only named') -> None\n"
-        "  2.  testMethod2() -> 44\n"
-        "  3.  testMethod(1, 2) -> 'output'",
-        str(e))
-
-
-class OrTest(unittest.TestCase):
-  """Test Or correctly chains Comparators."""
-
-  def testValidOr(self):
-    """Or should be True if either Comparator returns True."""
-    self.assert_(mox.Or(mox.IsA(dict), mox.IsA(str)) == {})
-    self.assert_(mox.Or(mox.IsA(dict), mox.IsA(str)) == 'test')
-    self.assert_(mox.Or(mox.IsA(str), mox.IsA(str)) == 'test')
-
-  def testInvalidOr(self):
-    """Or should be False if both Comparators return False."""
-    self.failIf(mox.Or(mox.IsA(dict), mox.IsA(str)) == 0)
-
-
-class AndTest(unittest.TestCase):
-  """Test And correctly chains Comparators."""
-
-  def testValidAnd(self):
-    """And should be True if both Comparators return True."""
-    self.assert_(mox.And(mox.IsA(str), mox.IsA(str)) == '1')
-
-  def testClauseOneFails(self):
-    """And should be False if the first Comparator returns False."""
-
-    self.failIf(mox.And(mox.IsA(dict), mox.IsA(str)) == '1')
-
-  def testAdvancedUsage(self):
-    """And should work with other Comparators.
-
-    Note: this test is reliant on In and ContainsKeyValue.
-    """
-    test_dict = {"mock" : "obj", "testing" : "isCOOL"}
-    self.assert_(mox.And(mox.In("testing"),
-                           mox.ContainsKeyValue("mock", "obj")) == test_dict)
-
-  def testAdvancedUsageFails(self):
-    """Note: this test is reliant on In and ContainsKeyValue."""
-    test_dict = {"mock" : "obj", "testing" : "isCOOL"}
-    self.failIf(mox.And(mox.In("NOTFOUND"),
-                          mox.ContainsKeyValue("mock", "obj")) == test_dict)
-
-
-class SameElementsAsTest(unittest.TestCase):
-  """Test SameElementsAs correctly identifies sequences with same elements."""
-
-  def testSortedLists(self):
-    """Should return True if two lists are exactly equal."""
-    self.assert_(mox.SameElementsAs([1, 2.0, 'c']) == [1, 2.0, 'c'])
-
-  def testUnsortedLists(self):
-    """Should return True if two lists are unequal but have same elements."""
-    self.assert_(mox.SameElementsAs([1, 2.0, 'c']) == [2.0, 'c', 1])
-
-  def testUnhashableLists(self):
-    """Should return True if two lists have the same unhashable elements."""
-    self.assert_(mox.SameElementsAs([{'a': 1}, {2: 'b'}]) ==
-                 [{2: 'b'}, {'a': 1}])
-
-  def testEmptyLists(self):
-    """Should return True for two empty lists."""
-    self.assert_(mox.SameElementsAs([]) == [])
-
-  def testUnequalLists(self):
-    """Should return False if the lists are not equal."""
-    self.failIf(mox.SameElementsAs([1, 2.0, 'c']) == [2.0, 'c'])
-
-  def testUnequalUnhashableLists(self):
-    """Should return False if two lists with unhashable elements are unequal."""
-    self.failIf(mox.SameElementsAs([{'a': 1}, {2: 'b'}]) == [{2: 'b'}])
-
-
-class ContainsKeyValueTest(unittest.TestCase):
-  """Test ContainsKeyValue correctly identifies key/value pairs in a dict.
-  """
-
-  def testValidPair(self):
-    """Should return True if the key value is in the dict."""
-    self.assert_(mox.ContainsKeyValue("key", 1) == {"key": 1})
-
-  def testInvalidValue(self):
-    """Should return False if the value is not correct."""
-    self.failIf(mox.ContainsKeyValue("key", 1) == {"key": 2})
-
-  def testInvalidKey(self):
-    """Should return False if they key is not in the dict."""
-    self.failIf(mox.ContainsKeyValue("qux", 1) == {"key": 2})
-
-
-class InTest(unittest.TestCase):
-  """Test In correctly identifies a key in a list/dict"""
-
-  def testItemInList(self):
-    """Should return True if the item is in the list."""
-    self.assert_(mox.In(1) == [1, 2, 3])
-
-  def testKeyInDict(self):
-    """Should return True if the item is a key in a dict."""
-    self.assert_(mox.In("test") == {"test" : "module"})
-
-
-class NotTest(unittest.TestCase):
-  """Test Not correctly identifies False predicates."""
-
-  def testItemInList(self):
-    """Should return True if the item is NOT in the list."""
-    self.assert_(mox.Not(mox.In(42)) == [1, 2, 3])
-
-  def testKeyInDict(self):
-    """Should return True if the item is NOT a key in a dict."""
-    self.assert_(mox.Not(mox.In("foo")) == {"key" : 42})
-
-  def testInvalidKeyWithNot(self):
-    """Should return False if they key is NOT in the dict."""
-    self.assert_(mox.Not(mox.ContainsKeyValue("qux", 1)) == {"key": 2})
-
-
-class StrContainsTest(unittest.TestCase):
-  """Test StrContains correctly checks for substring occurrence of a parameter.
-  """
-
-  def testValidSubstringAtStart(self):
-    """Should return True if the substring is at the start of the string."""
-    self.assert_(mox.StrContains("hello") == "hello world")
-
-  def testValidSubstringInMiddle(self):
-    """Should return True if the substring is in the middle of the string."""
-    self.assert_(mox.StrContains("lo wo") == "hello world")
-
-  def testValidSubstringAtEnd(self):
-    """Should return True if the substring is at the end of the string."""
-    self.assert_(mox.StrContains("ld") == "hello world")
-
-  def testInvaildSubstring(self):
-    """Should return False if the substring is not in the string."""
-    self.failIf(mox.StrContains("AAA") == "hello world")
-
-  def testMultipleMatches(self):
-    """Should return True if there are multiple occurances of substring."""
-    self.assert_(mox.StrContains("abc") == "ababcabcabcababc")
-
-
-class RegexTest(unittest.TestCase):
-  """Test Regex correctly matches regular expressions."""
-
-  def testIdentifyBadSyntaxDuringInit(self):
-    """The user should know immediately if a regex has bad syntax."""
-    self.assertRaises(re.error, mox.Regex, '(a|b')
-
-  def testPatternInMiddle(self):
-    """Should return True if the pattern matches at the middle of the string.
-
-    This ensures that re.search is used (instead of re.find).
-    """
-    self.assert_(mox.Regex(r"a\s+b") == "x y z a b c")
-
-  def testNonMatchPattern(self):
-    """Should return False if the pattern does not match the string."""
-    self.failIf(mox.Regex(r"a\s+b") == "x y z")
-
-  def testFlagsPassedCorrectly(self):
-    """Should return True as we pass IGNORECASE flag."""
-    self.assert_(mox.Regex(r"A", re.IGNORECASE) == "a")
-
-  def testReprWithoutFlags(self):
-    """repr should return the regular expression pattern."""
-    self.assert_(repr(mox.Regex(r"a\s+b")) == "<regular expression 'a\s+b'>")
-
-  def testReprWithFlags(self):
-    """repr should return the regular expression pattern and flags."""
-    self.assert_(repr(mox.Regex(r"a\s+b", flags=4)) ==
-                 "<regular expression 'a\s+b', flags=4>")
-
-
-class IsATest(unittest.TestCase):
-  """Verify IsA correctly checks equality based upon class type, not value."""
-
-  def testEqualityValid(self):
-    """Verify that == correctly identifies objects of the same type."""
-    self.assert_(mox.IsA(str) == 'test')
-
-  def testEqualityInvalid(self):
-    """Verify that == correctly identifies objects of different types."""
-    self.failIf(mox.IsA(str) == 10)
-
-  def testInequalityValid(self):
-    """Verify that != identifies objects of different type."""
-    self.assert_(mox.IsA(str) != 10)
-
-  def testInequalityInvalid(self):
-    """Verify that != correctly identifies objects of the same type."""
-    self.failIf(mox.IsA(str) != "test")
-
-  def testEqualityInListValid(self):
-    """Verify list contents are properly compared."""
-    isa_list = [mox.IsA(str), mox.IsA(str)]
-    str_list = ["abc", "def"]
-    self.assert_(isa_list == str_list)
-
-  def testEquailtyInListInvalid(self):
-    """Verify list contents are properly compared."""
-    isa_list = [mox.IsA(str),mox.IsA(str)]
-    mixed_list = ["abc", 123]
-    self.failIf(isa_list == mixed_list)
-
-  def testSpecialTypes(self):
-    """Verify that IsA can handle objects like cStringIO.StringIO."""
-    isA = mox.IsA(cStringIO.StringIO())
-    stringIO = cStringIO.StringIO()
-    self.assert_(isA == stringIO)
-
-
-class IsAlmostTest(unittest.TestCase):
-  """Verify IsAlmost correctly checks equality of floating point numbers."""
-
-  def testEqualityValid(self):
-    """Verify that == correctly identifies nearly equivalent floats."""
-    self.assertEquals(mox.IsAlmost(1.8999999999), 1.9)
-
-  def testEqualityInvalid(self):
-    """Verify that == correctly identifies non-equivalent floats."""
-    self.assertNotEquals(mox.IsAlmost(1.899), 1.9)
-
-  def testEqualityWithPlaces(self):
-    """Verify that specifying places has the desired effect."""
-    self.assertNotEquals(mox.IsAlmost(1.899), 1.9)
-    self.assertEquals(mox.IsAlmost(1.899, places=2), 1.9)
-
-  def testNonNumericTypes(self):
-    """Verify that IsAlmost handles non-numeric types properly."""
-
-    self.assertNotEquals(mox.IsAlmost(1.8999999999), '1.9')
-    self.assertNotEquals(mox.IsAlmost('1.8999999999'), 1.9)
-    self.assertNotEquals(mox.IsAlmost('1.8999999999'), '1.9')
-
-
-class MockMethodTest(unittest.TestCase):
-  """Test class to verify that the MockMethod class is working correctly."""
-
-  def setUp(self):
-    self.expected_method = mox.MockMethod("testMethod", [], False)(['original'])
-    self.mock_method = mox.MockMethod("testMethod", [self.expected_method],
-                                        True)
-
-  def testAndReturnNoneByDefault(self):
-    """Should return None by default."""
-    return_value = self.mock_method(['original'])
-    self.assert_(return_value == None)
-
-  def testAndReturnValue(self):
-    """Should return a specificed return value."""
-    expected_return_value = "test"
-    self.expected_method.AndReturn(expected_return_value)
-    return_value = self.mock_method(['original'])
-    self.assert_(return_value == expected_return_value)
-
-  def testAndRaiseException(self):
-    """Should raise a specified exception."""
-    expected_exception = Exception('test exception')
-    self.expected_method.AndRaise(expected_exception)
-    self.assertRaises(Exception, self.mock_method)
-
-  def testWithSideEffects(self):
-    """Should call state modifier."""
-    local_list = ['original']
-    def modifier(mutable_list):
-      self.assertTrue(local_list is mutable_list)
-      mutable_list[0] = 'mutation'
-    self.expected_method.WithSideEffects(modifier).AndReturn(1)
-    self.mock_method(local_list)
-    self.assertEquals('mutation', local_list[0])
-
-  def testEqualityNoParamsEqual(self):
-    """Methods with the same name and without params should be equal."""
-    expected_method = mox.MockMethod("testMethod", [], False)
-    self.assertEqual(self.mock_method, expected_method)
-
-  def testEqualityNoParamsNotEqual(self):
-    """Methods with different names and without params should not be equal."""
-    expected_method = mox.MockMethod("otherMethod", [], False)
-    self.failIfEqual(self.mock_method, expected_method)
-
-  def testEqualityParamsEqual(self):
-    """Methods with the same name and parameters should be equal."""
-    params = [1, 2, 3]
-    expected_method = mox.MockMethod("testMethod", [], False)
-    expected_method._params = params
-
-    self.mock_method._params = params
-    self.assertEqual(self.mock_method, expected_method)
-
-  def testEqualityParamsNotEqual(self):
-    """Methods with the same name and different params should not be equal."""
-    expected_method = mox.MockMethod("testMethod", [], False)
-    expected_method._params = [1, 2, 3]
-
-    self.mock_method._params = ['a', 'b', 'c']
-    self.failIfEqual(self.mock_method, expected_method)
-
-  def testEqualityNamedParamsEqual(self):
-    """Methods with the same name and same named params should be equal."""
-    named_params = {"input1": "test", "input2": "params"}
-    expected_method = mox.MockMethod("testMethod", [], False)
-    expected_method._named_params = named_params
-
-    self.mock_method._named_params = named_params
-    self.assertEqual(self.mock_method, expected_method)
-
-  def testEqualityNamedParamsNotEqual(self):
-    """Methods with the same name and diffnamed params should not be equal."""
-    expected_method = mox.MockMethod("testMethod", [], False)
-    expected_method._named_params = {"input1": "test", "input2": "params"}
-
-    self.mock_method._named_params = {"input1": "test2", "input2": "params2"}
-    self.failIfEqual(self.mock_method, expected_method)
-
-  def testEqualityWrongType(self):
-    """Method should not be equal to an object of a different type."""
-    self.failIfEqual(self.mock_method, "string?")
-
-  def testObjectEquality(self):
-    """Equality of objects should work without a Comparator"""
-    instA = TestClass();
-    instB = TestClass();
-
-    params = [instA, ]
-    expected_method = mox.MockMethod("testMethod", [], False)
-    expected_method._params = params
-
-    self.mock_method._params = [instB, ]
-    self.assertEqual(self.mock_method, expected_method)
-
-  def testStrConversion(self):
-    method = mox.MockMethod("f", [], False)
-    method(1, 2, "st", n1=8, n2="st2")
-    self.assertEqual(str(method), ("f(1, 2, 'st', n1=8, n2='st2') -> None"))
-
-    method = mox.MockMethod("testMethod", [], False)
-    method(1, 2, "only positional")
-    self.assertEqual(str(method), "testMethod(1, 2, 'only positional') -> None")
-
-    method = mox.MockMethod("testMethod", [], False)
-    method(a=1, b=2, c="only named")
-    self.assertEqual(str(method),
-                     "testMethod(a=1, b=2, c='only named') -> None")
-
-    method = mox.MockMethod("testMethod", [], False)
-    method()
-    self.assertEqual(str(method), "testMethod() -> None")
-
-    method = mox.MockMethod("testMethod", [], False)
-    method(x="only 1 parameter")
-    self.assertEqual(str(method), "testMethod(x='only 1 parameter') -> None")
-
-    method = mox.MockMethod("testMethod", [], False)
-    method().AndReturn('return_value')
-    self.assertEqual(str(method), "testMethod() -> 'return_value'")
-
-    method = mox.MockMethod("testMethod", [], False)
-    method().AndReturn(('a', {1: 2}))
-    self.assertEqual(str(method), "testMethod() -> ('a', {1: 2})")
-
-
-class MockAnythingTest(unittest.TestCase):
-  """Verify that the MockAnything class works as expected."""
-
-  def setUp(self):
-    self.mock_object = mox.MockAnything()
-
-  def testRepr(self):
-    """Calling repr on a MockAnything instance must work."""
-    self.assertEqual('<MockAnything instance>', repr(self.mock_object))
-
-  def testSetupMode(self):
-    """Verify the mock will accept any call."""
-    self.mock_object.NonsenseCall()
-    self.assert_(len(self.mock_object._expected_calls_queue) == 1)
-
-  def testReplayWithExpectedCall(self):
-    """Verify the mock replays method calls as expected."""
-    self.mock_object.ValidCall()          # setup method call
-    self.mock_object._Replay()            # start replay mode
-    self.mock_object.ValidCall()          # make method call
-
-  def testReplayWithUnexpectedCall(self):
-    """Unexpected method calls should raise UnexpectedMethodCallError."""
-    self.mock_object.ValidCall()          # setup method call
-    self.mock_object._Replay()             # start replay mode
-    self.assertRaises(mox.UnexpectedMethodCallError,
-                      self.mock_object.OtherValidCall)
-
-  def testVerifyWithCompleteReplay(self):
-    """Verify should not raise an exception for a valid replay."""
-    self.mock_object.ValidCall()          # setup method call
-    self.mock_object._Replay()             # start replay mode
-    self.mock_object.ValidCall()          # make method call
-    self.mock_object._Verify()
-
-  def testVerifyWithIncompleteReplay(self):
-    """Verify should raise an exception if the replay was not complete."""
-    self.mock_object.ValidCall()          # setup method call
-    self.mock_object._Replay()             # start replay mode
-    # ValidCall() is never made
-    self.assertRaises(mox.ExpectedMethodCallsError, self.mock_object._Verify)
-
-  def testSpecialClassMethod(self):
-    """Verify should not raise an exception when special methods are used."""
-    self.mock_object[1].AndReturn(True)
-    self.mock_object._Replay()
-    returned_val = self.mock_object[1]
-    self.assert_(returned_val)
-    self.mock_object._Verify()
-
-  def testNonzero(self):
-    """You should be able to use the mock object in an if."""
-    self.mock_object._Replay()
-    if self.mock_object:
-      pass
-
-  def testNotNone(self):
-    """Mock should be comparable to None."""
-    self.mock_object._Replay()
-    if self.mock_object is not None:
-      pass
-
-    if self.mock_object is None:
-      pass
-
-  def testEquals(self):
-    """A mock should be able to compare itself to another object."""
-    self.mock_object._Replay()
-    self.assertEquals(self.mock_object, self.mock_object)
-
-  def testEqualsMockFailure(self):
-    """Verify equals identifies unequal objects."""
-    self.mock_object.SillyCall()
-    self.mock_object._Replay()
-    self.assertNotEquals(self.mock_object, mox.MockAnything())
-
-  def testEqualsInstanceFailure(self):
-    """Verify equals identifies that objects are different instances."""
-    self.mock_object._Replay()
-    self.assertNotEquals(self.mock_object, TestClass())
-
-  def testNotEquals(self):
-    """Verify not equals works."""
-    self.mock_object._Replay()
-    self.assertFalse(self.mock_object != self.mock_object)
-
-  def testNestedMockCallsRecordedSerially(self):
-    """Test that nested calls work when recorded serially."""
-    self.mock_object.CallInner().AndReturn(1)
-    self.mock_object.CallOuter(1)
-    self.mock_object._Replay()
-
-    self.mock_object.CallOuter(self.mock_object.CallInner())
-
-    self.mock_object._Verify()
-
-  def testNestedMockCallsRecordedNested(self):
-    """Test that nested cals work when recorded in a nested fashion."""
-    self.mock_object.CallOuter(self.mock_object.CallInner().AndReturn(1))
-    self.mock_object._Replay()
-
-    self.mock_object.CallOuter(self.mock_object.CallInner())
-
-    self.mock_object._Verify()
-
-  def testIsCallable(self):
-    """Test that MockAnything can even mock a simple callable.
-
-    This is handy for "stubbing out" a method in a module with a mock, and
-    verifying that it was called.
-    """
-    self.mock_object().AndReturn('mox0rd')
-    self.mock_object._Replay()
-
-    self.assertEquals('mox0rd', self.mock_object())
-
-    self.mock_object._Verify()
-
-  def testIsReprable(self):
-    """Test that MockAnythings can be repr'd without causing a failure."""
-    self.failUnless('MockAnything' in repr(self.mock_object))
-
-
-class MethodCheckerTest(unittest.TestCase):
-  """Tests MockMethod's use of MethodChecker method."""
-
-  def testNoParameters(self):
-    method = mox.MockMethod('NoParameters', [], False,
-                            CheckCallTestClass.NoParameters)
-    method()
-    self.assertRaises(AttributeError, method, 1)
-    self.assertRaises(AttributeError, method, 1, 2)
-    self.assertRaises(AttributeError, method, a=1)
-    self.assertRaises(AttributeError, method, 1, b=2)
-
-  def testOneParameter(self):
-    method = mox.MockMethod('OneParameter', [], False,
-                            CheckCallTestClass.OneParameter)
-    self.assertRaises(AttributeError, method)
-    method(1)
-    method(a=1)
-    self.assertRaises(AttributeError, method, b=1)
-    self.assertRaises(AttributeError, method, 1, 2)
-    self.assertRaises(AttributeError, method, 1, a=2)
-    self.assertRaises(AttributeError, method, 1, b=2)
-
-  def testTwoParameters(self):
-    method = mox.MockMethod('TwoParameters', [], False,
-                            CheckCallTestClass.TwoParameters)
-    self.assertRaises(AttributeError, method)
-    self.assertRaises(AttributeError, method, 1)
-    self.assertRaises(AttributeError, method, a=1)
-    self.assertRaises(AttributeError, method, b=1)
-    method(1, 2)
-    method(1, b=2)
-    method(a=1, b=2)
-    method(b=2, a=1)
-    self.assertRaises(AttributeError, method, b=2, c=3)
-    self.assertRaises(AttributeError, method, a=1, b=2, c=3)
-    self.assertRaises(AttributeError, method, 1, 2, 3)
-    self.assertRaises(AttributeError, method, 1, 2, 3, 4)
-    self.assertRaises(AttributeError, method, 3, a=1, b=2)
-
-  def testOneDefaultValue(self):
-    method = mox.MockMethod('OneDefaultValue', [], False,
-                            CheckCallTestClass.OneDefaultValue)
-    method()
-    method(1)
-    method(a=1)
-    self.assertRaises(AttributeError, method, b=1)
-    self.assertRaises(AttributeError, method, 1, 2)
-    self.assertRaises(AttributeError, method, 1, a=2)
-    self.assertRaises(AttributeError, method, 1, b=2)
-
-  def testTwoDefaultValues(self):
-    method = mox.MockMethod('TwoDefaultValues', [], False,
-                            CheckCallTestClass.TwoDefaultValues)
-    self.assertRaises(AttributeError, method)
-    self.assertRaises(AttributeError, method, c=3)
-    self.assertRaises(AttributeError, method, 1)
-    self.assertRaises(AttributeError, method, 1, d=4)
-    self.assertRaises(AttributeError, method, 1, d=4, c=3)
-    method(1, 2)
-    method(a=1, b=2)
-    method(1, 2, 3)
-    method(1, 2, 3, 4)
-    method(1, 2, c=3)
-    method(1, 2, c=3, d=4)
-    method(1, 2, d=4, c=3)
-    method(d=4, c=3, a=1, b=2)
-    self.assertRaises(AttributeError, method, 1, 2, 3, 4, 5)
-    self.assertRaises(AttributeError, method, 1, 2, e=9)
-    self.assertRaises(AttributeError, method, a=1, b=2, e=9)
-
-  def testArgs(self):
-    method = mox.MockMethod('Args', [], False, CheckCallTestClass.Args)
-    self.assertRaises(AttributeError, method)
-    self.assertRaises(AttributeError, method, 1)
-    method(1, 2)
-    method(a=1, b=2)
-    method(1, 2, 3)
-    method(1, 2, 3, 4)
-    self.assertRaises(AttributeError, method, 1, 2, a=3)
-    self.assertRaises(AttributeError, method, 1, 2, c=3)
-
-  def testKwargs(self):
-    method = mox.MockMethod('Kwargs', [], False, CheckCallTestClass.Kwargs)
-    self.assertRaises(AttributeError, method)
-    method(1)
-    method(1, 2)
-    method(a=1, b=2)
-    method(b=2, a=1)
-    self.assertRaises(AttributeError, method, 1, 2, 3)
-    self.assertRaises(AttributeError, method, 1, 2, a=3)
-    method(1, 2, c=3)
-    method(a=1, b=2, c=3)
-    method(c=3, a=1, b=2)
-    method(a=1, b=2, c=3, d=4)
-    self.assertRaises(AttributeError, method, 1, 2, 3, 4)
-
-  def testArgsAndKwargs(self):
-    method = mox.MockMethod('ArgsAndKwargs', [], False,
-                            CheckCallTestClass.ArgsAndKwargs)
-    self.assertRaises(AttributeError, method)
-    method(1)
-    method(1, 2)
-    method(1, 2, 3)
-    method(a=1)
-    method(1, b=2)
-    self.assertRaises(AttributeError, method, 1, a=2)
-    method(b=2, a=1)
-    method(c=3, b=2, a=1)
-    method(1, 2, c=3)
-
-
-class CheckCallTestClass(object):
-  def NoParameters(self):
-    pass
-
-  def OneParameter(self, a):
-    pass
-
-  def TwoParameters(self, a, b):
-    pass
-
-  def OneDefaultValue(self, a=1):
-    pass
-
-  def TwoDefaultValues(self, a, b, c=1, d=2):
-    pass
-
-  def Args(self, a, b, *args):
-    pass
-
-  def Kwargs(self, a, b=2, **kwargs):
-    pass
-
-  def ArgsAndKwargs(self, a, *args, **kwargs):
-    pass
-
-
-class MockObjectTest(unittest.TestCase):
-  """Verify that the MockObject class works as exepcted."""
-
-  def setUp(self):
-    self.mock_object = mox.MockObject(TestClass)
-
-  def testSetupModeWithValidCall(self):
-    """Verify the mock object properly mocks a basic method call."""
-    self.mock_object.ValidCall()
-    self.assert_(len(self.mock_object._expected_calls_queue) == 1)
-
-  def testSetupModeWithInvalidCall(self):
-    """UnknownMethodCallError should be raised if a non-member method is called.
-    """
-    # Note: assertRaises does not catch exceptions thrown by MockObject's
-    # __getattr__
-    try:
-      self.mock_object.InvalidCall()
-      self.fail("No exception thrown, expected UnknownMethodCallError")
-    except mox.UnknownMethodCallError:
-      pass
-    except Exception:
-      self.fail("Wrong exception type thrown, expected UnknownMethodCallError")
-
-  def testReplayWithInvalidCall(self):
-    """UnknownMethodCallError should be raised if a non-member method is called.
-    """
-    self.mock_object.ValidCall()          # setup method call
-    self.mock_object._Replay()             # start replay mode
-    # Note: assertRaises does not catch exceptions thrown by MockObject's
-    # __getattr__
-    try:
-      self.mock_object.InvalidCall()
-      self.fail("No exception thrown, expected UnknownMethodCallError")
-    except mox.UnknownMethodCallError:
-      pass
-    except Exception:
-      self.fail("Wrong exception type thrown, expected UnknownMethodCallError")
-
-  def testIsInstance(self):
-    """Mock should be able to pass as an instance of the mocked class."""
-    self.assert_(isinstance(self.mock_object, TestClass))
-
-  def testFindValidMethods(self):
-    """Mock should be able to mock all public methods."""
-    self.assert_('ValidCall' in self.mock_object._known_methods)
-    self.assert_('OtherValidCall' in self.mock_object._known_methods)
-    self.assert_('MyClassMethod' in self.mock_object._known_methods)
-    self.assert_('MyStaticMethod' in self.mock_object._known_methods)
-    self.assert_('_ProtectedCall' in self.mock_object._known_methods)
-    self.assert_('__PrivateCall' not in self.mock_object._known_methods)
-    self.assert_('_TestClass__PrivateCall' in self.mock_object._known_methods)
-
-  def testFindsSuperclassMethods(self):
-    """Mock should be able to mock superclasses methods."""
-    self.mock_object = mox.MockObject(ChildClass)
-    self.assert_('ValidCall' in self.mock_object._known_methods)
-    self.assert_('OtherValidCall' in self.mock_object._known_methods)
-    self.assert_('MyClassMethod' in self.mock_object._known_methods)
-    self.assert_('ChildValidCall' in self.mock_object._known_methods)
-
-  def testAccessClassVariables(self):
-    """Class variables should be accessible through the mock."""
-    self.assert_('SOME_CLASS_VAR' in self.mock_object._known_vars)
-    self.assert_('_PROTECTED_CLASS_VAR' in self.mock_object._known_vars)
-    self.assertEquals('test_value', self.mock_object.SOME_CLASS_VAR)
-
-  def testEquals(self):
-    """A mock should be able to compare itself to another object."""
-    self.mock_object._Replay()
-    self.assertEquals(self.mock_object, self.mock_object)
-
-  def testEqualsMockFailure(self):
-    """Verify equals identifies unequal objects."""
-    self.mock_object.ValidCall()
-    self.mock_object._Replay()
-    self.assertNotEquals(self.mock_object, mox.MockObject(TestClass))
-
-  def testEqualsInstanceFailure(self):
-    """Verify equals identifies that objects are different instances."""
-    self.mock_object._Replay()
-    self.assertNotEquals(self.mock_object, TestClass())
-
-  def testNotEquals(self):
-    """Verify not equals works."""
-    self.mock_object._Replay()
-    self.assertFalse(self.mock_object != self.mock_object)
-
-  def testMockSetItem_ExpectedSetItem_Success(self):
-    """Test that __setitem__() gets mocked in Dummy.
-
-    In this test, _Verify() succeeds.
-    """
-    dummy = mox.MockObject(TestClass)
-    dummy['X'] = 'Y'
-
-    dummy._Replay()
-
-    dummy['X'] = 'Y'
-
-    dummy._Verify()
-
-  def testMockSetItem_ExpectedSetItem_NoSuccess(self):
-    """Test that __setitem__() gets mocked in Dummy.
-
-    In this test, _Verify() fails.
-    """
-    dummy = mox.MockObject(TestClass)
-    dummy['X'] = 'Y'
-
-    dummy._Replay()
-
-    # NOT doing dummy['X'] = 'Y'
-
-    self.assertRaises(mox.ExpectedMethodCallsError, dummy._Verify)
-
-  def testMockSetItem_ExpectedNoSetItem_Success(self):
-    """Test that __setitem__() gets mocked in Dummy."""
-    dummy = mox.MockObject(TestClass)
-    # NOT doing dummy['X'] = 'Y'
-
-    dummy._Replay()
-
-    def call(): dummy['X'] = 'Y'
-    self.assertRaises(mox.UnexpectedMethodCallError, call)
-
-  def testMockSetItem_ExpectedNoSetItem_NoSuccess(self):
-    """Test that __setitem__() gets mocked in Dummy.
-
-    In this test, _Verify() fails.
-    """
-    dummy = mox.MockObject(TestClass)
-    # NOT doing dummy['X'] = 'Y'
-
-    dummy._Replay()
-
-    # NOT doing dummy['X'] = 'Y'
-
-    dummy._Verify()
-
-  def testMockSetItem_ExpectedSetItem_NonmatchingParameters(self):
-    """Test that __setitem__() fails if other parameters are expected."""
-    dummy = mox.MockObject(TestClass)
-    dummy['X'] = 'Y'
-
-    dummy._Replay()
-
-    def call(): dummy['wrong'] = 'Y'
-
-    self.assertRaises(mox.UnexpectedMethodCallError, call)
-
-    dummy._Verify()
-
-  def testMockSetItem_WithSubClassOfNewStyleClass(self):
-    class NewStyleTestClass(object):
-      def __init__(self):
-        self.my_dict = {}
-
-      def __setitem__(self, key, value):
-        self.my_dict[key], value
-
-    class TestSubClass(NewStyleTestClass):
-      pass
-
-    dummy = mox.MockObject(TestSubClass)
-    dummy[1] = 2
-    dummy._Replay()
-    dummy[1] = 2
-    dummy._Verify()
-
-  def testMockGetItem_ExpectedGetItem_Success(self):
-    """Test that __getitem__() gets mocked in Dummy.
-
-    In this test, _Verify() succeeds.
-    """
-    dummy = mox.MockObject(TestClass)
-    dummy['X'].AndReturn('value')
-
-    dummy._Replay()
-
-    self.assertEqual(dummy['X'], 'value')
-
-    dummy._Verify()
-
-  def testMockGetItem_ExpectedGetItem_NoSuccess(self):
-    """Test that __getitem__() gets mocked in Dummy.
-
-    In this test, _Verify() fails.
-    """
-    dummy = mox.MockObject(TestClass)
-    dummy['X'].AndReturn('value')
-
-    dummy._Replay()
-
-    # NOT doing dummy['X']
-
-    self.assertRaises(mox.ExpectedMethodCallsError, dummy._Verify)
-
-  def testMockGetItem_ExpectedNoGetItem_NoSuccess(self):
-    """Test that __getitem__() gets mocked in Dummy."""
-    dummy = mox.MockObject(TestClass)
-    # NOT doing dummy['X']
-
-    dummy._Replay()
-
-    def call(): return dummy['X']
-    self.assertRaises(mox.UnexpectedMethodCallError, call)
-
-  def testMockGetItem_ExpectedGetItem_NonmatchingParameters(self):
-    """Test that __getitem__() fails if other parameters are expected."""
-    dummy = mox.MockObject(TestClass)
-    dummy['X'].AndReturn('value')
-
-    dummy._Replay()
-
-    def call(): return dummy['wrong']
-
-    self.assertRaises(mox.UnexpectedMethodCallError, call)
-
-    dummy._Verify()
-
-  def testMockGetItem_WithSubClassOfNewStyleClass(self):
-    class NewStyleTestClass(object):
-      def __getitem__(self, key):
-        return {1: '1', 2: '2'}[key]
-
-    class TestSubClass(NewStyleTestClass):
-      pass
-
-    dummy = mox.MockObject(TestSubClass)
-    dummy[1].AndReturn('3')
-
-    dummy._Replay()
-    self.assertEquals('3', dummy.__getitem__(1))
-    dummy._Verify()
-
-  def testMockIter_ExpectedIter_Success(self):
-    """Test that __iter__() gets mocked in Dummy.
-
-    In this test, _Verify() succeeds.
-    """
-    dummy = mox.MockObject(TestClass)
-    iter(dummy).AndReturn(iter(['X', 'Y']))
-
-    dummy._Replay()
-
-    self.assertEqual([x for x in dummy], ['X', 'Y'])
-
-    dummy._Verify()
-  def testMockContains_ExpectedContains_Success(self):
-    """Test that __contains__ gets mocked in Dummy.
-
-    In this test, _Verify() succeeds.
-    """
-    dummy = mox.MockObject(TestClass)
-    dummy.__contains__('X').AndReturn(True)
-
-    dummy._Replay()
-
-    self.failUnless('X' in dummy)
-
-    dummy._Verify()
-
-  def testMockContains_ExpectedContains_NoSuccess(self):
-    """Test that __contains__() gets mocked in Dummy.
-
-    In this test, _Verify() fails.
-    """
-    dummy = mox.MockObject(TestClass)
-    dummy.__contains__('X').AndReturn('True')
-
-    dummy._Replay()
-
-    # NOT doing 'X' in dummy
-
-    self.assertRaises(mox.ExpectedMethodCallsError, dummy._Verify)
-
-  def testMockContains_ExpectedContains_NonmatchingParameter(self):
-    """Test that __contains__ fails if other parameters are expected."""
-    dummy = mox.MockObject(TestClass)
-    dummy.__contains__('X').AndReturn(True)
-
-    dummy._Replay()
-
-    def call(): return 'Y' in dummy
-
-    self.assertRaises(mox.UnexpectedMethodCallError, call)
-
-    dummy._Verify()
-
-  def testMockIter_ExpectedIter_NoSuccess(self):
-    """Test that __iter__() gets mocked in Dummy.
-
-    In this test, _Verify() fails.
-    """
-    dummy = mox.MockObject(TestClass)
-    iter(dummy).AndReturn(iter(['X', 'Y']))
-
-    dummy._Replay()
-
-    # NOT doing self.assertEqual([x for x in dummy], ['X', 'Y'])
-
-    self.assertRaises(mox.ExpectedMethodCallsError, dummy._Verify)
-
-  def testMockIter_ExpectedNoIter_NoSuccess(self):
-    """Test that __iter__() gets mocked in Dummy."""
-    dummy = mox.MockObject(TestClass)
-    # NOT doing iter(dummy)
-
-    dummy._Replay()
-
-    def call(): return [x for x in dummy]
-    self.assertRaises(mox.UnexpectedMethodCallError, call)
-
-  def testMockIter_ExpectedGetItem_Success(self):
-    """Test that __iter__() gets mocked in Dummy using getitem."""
-    dummy = mox.MockObject(SubscribtableNonIterableClass)
-    dummy[0].AndReturn('a')
-    dummy[1].AndReturn('b')
-    dummy[2].AndRaise(IndexError)
-
-    dummy._Replay()
-    self.assertEquals(['a', 'b'], [x for x in dummy])
-    dummy._Verify()
-
-  def testMockIter_ExpectedNoGetItem_NoSuccess(self):
-    """Test that __iter__() gets mocked in Dummy using getitem."""
-    dummy = mox.MockObject(SubscribtableNonIterableClass)
-    # NOT doing dummy[index]
-
-    dummy._Replay()
-    function = lambda: [x for x in dummy]
-    self.assertRaises(mox.UnexpectedMethodCallError, function)
-
-  def testMockGetIter_WithSubClassOfNewStyleClass(self):
-    class NewStyleTestClass(object):
-      def __iter__(self):
-        return iter([1, 2, 3])
-
-    class TestSubClass(NewStyleTestClass):
-      pass
-
-    dummy = mox.MockObject(TestSubClass)
-    iter(dummy).AndReturn(iter(['a', 'b']))
-    dummy._Replay()
-    self.assertEquals(['a', 'b'], [x for x in dummy])
-    dummy._Verify()
-
-
-class MoxTest(unittest.TestCase):
-  """Verify Mox works correctly."""
-
-  def setUp(self):
-    self.mox = mox.Mox()
-
-  def testCreateObject(self):
-    """Mox should create a mock object."""
-    mock_obj = self.mox.CreateMock(TestClass)
-
-  def testVerifyObjectWithCompleteReplay(self):
-    """Mox should replay and verify all objects it created."""
-    mock_obj = self.mox.CreateMock(TestClass)
-    mock_obj.ValidCall()
-    mock_obj.ValidCallWithArgs(mox.IsA(TestClass))
-    self.mox.ReplayAll()
-    mock_obj.ValidCall()
-    mock_obj.ValidCallWithArgs(TestClass("some_value"))
-    self.mox.VerifyAll()
-
-  def testVerifyObjectWithIncompleteReplay(self):
-    """Mox should raise an exception if a mock didn't replay completely."""
-    mock_obj = self.mox.CreateMock(TestClass)
-    mock_obj.ValidCall()
-    self.mox.ReplayAll()
-    # ValidCall() is never made
-    self.assertRaises(mox.ExpectedMethodCallsError, self.mox.VerifyAll)
-
-  def testEntireWorkflow(self):
-    """Test the whole work flow."""
-    mock_obj = self.mox.CreateMock(TestClass)
-    mock_obj.ValidCall().AndReturn("yes")
-    self.mox.ReplayAll()
-
-    ret_val = mock_obj.ValidCall()
-    self.assertEquals("yes", ret_val)
-    self.mox.VerifyAll()
-
-  def testCallableObject(self):
-    """Test recording calls to a callable object works."""
-    mock_obj = self.mox.CreateMock(CallableClass)
-    mock_obj("foo").AndReturn("qux")
-    self.mox.ReplayAll()
-
-    ret_val = mock_obj("foo")
-    self.assertEquals("qux", ret_val)
-    self.mox.VerifyAll()
-
-  def testInheritedCallableObject(self):
-    """Test recording calls to an object inheriting from a callable object."""
-    mock_obj = self.mox.CreateMock(InheritsFromCallable)
-    mock_obj("foo").AndReturn("qux")
-    self.mox.ReplayAll()
-
-    ret_val = mock_obj("foo")
-    self.assertEquals("qux", ret_val)
-    self.mox.VerifyAll()
-
-  def testCallOnNonCallableObject(self):
-    """Test that you cannot call a non-callable object."""
-    mock_obj = self.mox.CreateMock(TestClass)
-    self.assertRaises(TypeError, mock_obj)
-
-  def testCallableObjectWithBadCall(self):
-    """Test verifying calls to a callable object works."""
-    mock_obj = self.mox.CreateMock(CallableClass)
-    mock_obj("foo").AndReturn("qux")
-    self.mox.ReplayAll()
-
-    self.assertRaises(mox.UnexpectedMethodCallError, mock_obj, "ZOOBAZ")
-
-  def testUnorderedGroup(self):
-    """Test that using one unordered group works."""
-    mock_obj = self.mox.CreateMockAnything()
-    mock_obj.Method(1).InAnyOrder()
-    mock_obj.Method(2).InAnyOrder()
-    self.mox.ReplayAll()
-
-    mock_obj.Method(2)
-    mock_obj.Method(1)
-
-    self.mox.VerifyAll()
-
-  def testUnorderedGroupsInline(self):
-    """Unordered groups should work in the context of ordered calls."""
-    mock_obj = self.mox.CreateMockAnything()
-    mock_obj.Open()
-    mock_obj.Method(1).InAnyOrder()
-    mock_obj.Method(2).InAnyOrder()
-    mock_obj.Close()
-    self.mox.ReplayAll()
-
-    mock_obj.Open()
-    mock_obj.Method(2)
-    mock_obj.Method(1)
-    mock_obj.Close()
-
-    self.mox.VerifyAll()
-
-  def testMultipleUnorderdGroups(self):
-    """Multiple unoreded groups should work."""
-    mock_obj = self.mox.CreateMockAnything()
-    mock_obj.Method(1).InAnyOrder()
-    mock_obj.Method(2).InAnyOrder()
-    mock_obj.Foo().InAnyOrder('group2')
-    mock_obj.Bar().InAnyOrder('group2')
-    self.mox.ReplayAll()
-
-    mock_obj.Method(2)
-    mock_obj.Method(1)
-    mock_obj.Bar()
-    mock_obj.Foo()
-
-    self.mox.VerifyAll()
-
-  def testMultipleUnorderdGroupsOutOfOrder(self):
-    """Multiple unordered groups should maintain external order"""
-    mock_obj = self.mox.CreateMockAnything()
-    mock_obj.Method(1).InAnyOrder()
-    mock_obj.Method(2).InAnyOrder()
-    mock_obj.Foo().InAnyOrder('group2')
-    mock_obj.Bar().InAnyOrder('group2')
-    self.mox.ReplayAll()
-
-    mock_obj.Method(2)
-    self.assertRaises(mox.UnexpectedMethodCallError, mock_obj.Bar)
-
-  def testUnorderedGroupWithReturnValue(self):
-    """Unordered groups should work with return values."""
-    mock_obj = self.mox.CreateMockAnything()
-    mock_obj.Open()
-    mock_obj.Method(1).InAnyOrder().AndReturn(9)
-    mock_obj.Method(2).InAnyOrder().AndReturn(10)
-    mock_obj.Close()
-    self.mox.ReplayAll()
-
-    mock_obj.Open()
-    actual_two = mock_obj.Method(2)
-    actual_one = mock_obj.Method(1)
-    mock_obj.Close()
-
-    self.assertEquals(9, actual_one)
-    self.assertEquals(10, actual_two)
-
-    self.mox.VerifyAll()
-
-  def testUnorderedGroupWithComparator(self):
-    """Unordered groups should work with comparators"""
-
-    def VerifyOne(cmd):
-      if not isinstance(cmd, str):
-        self.fail('Unexpected type passed to comparator: ' + str(cmd))
-      return cmd == 'test'
-
-    def VerifyTwo(cmd):
-      return True
-
-    mock_obj = self.mox.CreateMockAnything()
-    mock_obj.Foo(['test'], mox.Func(VerifyOne), bar=1).InAnyOrder().\
-        AndReturn('yes test')
-    mock_obj.Foo(['test'], mox.Func(VerifyTwo), bar=1).InAnyOrder().\
-        AndReturn('anything')
-
-    self.mox.ReplayAll()
-
-    mock_obj.Foo(['test'], 'anything', bar=1)
-    mock_obj.Foo(['test'], 'test', bar=1)
-
-    self.mox.VerifyAll()
-
-  def testMultipleTimes(self):
-    """Test if MultipleTimesGroup works."""
-    mock_obj = self.mox.CreateMockAnything()
-    mock_obj.Method(1).MultipleTimes().AndReturn(9)
-    mock_obj.Method(2).AndReturn(10)
-    mock_obj.Method(3).MultipleTimes().AndReturn(42)
-    self.mox.ReplayAll()
-
-    actual_one = mock_obj.Method(1)
-    second_one = mock_obj.Method(1) # This tests MultipleTimes.
-    actual_two = mock_obj.Method(2)
-    actual_three = mock_obj.Method(3)
-    mock_obj.Method(3)
-    mock_obj.Method(3)
-
-    self.mox.VerifyAll()
-
-    self.assertEquals(9, actual_one)
-    self.assertEquals(9, second_one) # Repeated calls should return same number.
-    self.assertEquals(10, actual_two)
-    self.assertEquals(42, actual_three)
-
-  def testMultipleTimesUsingIsAParameter(self):
-    """Test if MultipleTimesGroup works with a IsA parameter."""
-    mock_obj = self.mox.CreateMockAnything()
-    mock_obj.Open()
-    mock_obj.Method(mox.IsA(str)).MultipleTimes("IsA").AndReturn(9)
-    mock_obj.Close()
-    self.mox.ReplayAll()
-
-    mock_obj.Open()
-    actual_one = mock_obj.Method("1")
-    second_one = mock_obj.Method("2") # This tests MultipleTimes.
-    mock_obj.Close()
-
-    self.mox.VerifyAll()
-
-    self.assertEquals(9, actual_one)
-    self.assertEquals(9, second_one) # Repeated calls should return same number.
-
-  def testMutlipleTimesUsingFunc(self):
-    """Test that the Func is not evaluated more times than necessary.
-
-    If a Func() has side effects, it can cause a passing test to fail.
-    """
-
-    self.counter = 0
-    def MyFunc(actual_str):
-      """Increment the counter if actual_str == 'foo'."""
-      if actual_str == 'foo':
-        self.counter += 1
-      return True
-
-    mock_obj = self.mox.CreateMockAnything()
-    mock_obj.Open()
-    mock_obj.Method(mox.Func(MyFunc)).MultipleTimes()
-    mock_obj.Close()
-    self.mox.ReplayAll()
-
-    mock_obj.Open()
-    mock_obj.Method('foo')
-    mock_obj.Method('foo')
-    mock_obj.Method('not-foo')
-    mock_obj.Close()
-
-    self.mox.VerifyAll()
-
-    self.assertEquals(2, self.counter)
-
-  def testMultipleTimesThreeMethods(self):
-    """Test if MultipleTimesGroup works with three or more methods."""
-    mock_obj = self.mox.CreateMockAnything()
-    mock_obj.Open()
-    mock_obj.Method(1).MultipleTimes().AndReturn(9)
-    mock_obj.Method(2).MultipleTimes().AndReturn(8)
-    mock_obj.Method(3).MultipleTimes().AndReturn(7)
-    mock_obj.Method(4).AndReturn(10)
-    mock_obj.Close()
-    self.mox.ReplayAll()
-
-    mock_obj.Open()
-    actual_three = mock_obj.Method(3)
-    mock_obj.Method(1)
-    actual_two = mock_obj.Method(2)
-    mock_obj.Method(3)
-    actual_one = mock_obj.Method(1)
-    actual_four = mock_obj.Method(4)
-    mock_obj.Close()
-
-    self.assertEquals(9, actual_one)
-    self.assertEquals(8, actual_two)
-    self.assertEquals(7, actual_three)
-    self.assertEquals(10, actual_four)
-
-    self.mox.VerifyAll()
-
-  def testMultipleTimesMissingOne(self):
-    """Test if MultipleTimesGroup fails if one method is missing."""
-    mock_obj = self.mox.CreateMockAnything()
-    mock_obj.Open()
-    mock_obj.Method(1).MultipleTimes().AndReturn(9)
-    mock_obj.Method(2).MultipleTimes().AndReturn(8)
-    mock_obj.Method(3).MultipleTimes().AndReturn(7)
-    mock_obj.Method(4).AndReturn(10)
-    mock_obj.Close()
-    self.mox.ReplayAll()
-
-    mock_obj.Open()
-    mock_obj.Method(3)
-    mock_obj.Method(2)
-    mock_obj.Method(3)
-    mock_obj.Method(3)
-    mock_obj.Method(2)
-
-    self.assertRaises(mox.UnexpectedMethodCallError, mock_obj.Method, 4)
-
-  def testMultipleTimesTwoGroups(self):
-    """Test if MultipleTimesGroup works with a group after a
-    MultipleTimesGroup.
-    """
-    mock_obj = self.mox.CreateMockAnything()
-    mock_obj.Open()
-    mock_obj.Method(1).MultipleTimes().AndReturn(9)
-    mock_obj.Method(3).MultipleTimes("nr2").AndReturn(42)
-    mock_obj.Close()
-    self.mox.ReplayAll()
-
-    mock_obj.Open()
-    actual_one = mock_obj.Method(1)
-    mock_obj.Method(1)
-    actual_three = mock_obj.Method(3)
-    mock_obj.Method(3)
-    mock_obj.Close()
-
-    self.assertEquals(9, actual_one)
-    self.assertEquals(42, actual_three)
-
-    self.mox.VerifyAll()
-
-  def testMultipleTimesTwoGroupsFailure(self):
-    """Test if MultipleTimesGroup fails with a group after a
-    MultipleTimesGroup.
-    """
-    mock_obj = self.mox.CreateMockAnything()
-    mock_obj.Open()
-    mock_obj.Method(1).MultipleTimes().AndReturn(9)
-    mock_obj.Method(3).MultipleTimes("nr2").AndReturn(42)
-    mock_obj.Close()
-    self.mox.ReplayAll()
-
-    mock_obj.Open()
-    actual_one = mock_obj.Method(1)
-    mock_obj.Method(1)
-    actual_three = mock_obj.Method(3)
-
-    self.assertRaises(mox.UnexpectedMethodCallError, mock_obj.Method, 1)
-
-  def testWithSideEffects(self):
-    """Test side effect operations actually modify their target objects."""
-    def modifier(mutable_list):
-      mutable_list[0] = 'mutated'
-    mock_obj = self.mox.CreateMockAnything()
-    mock_obj.ConfigureInOutParameter(['original']).WithSideEffects(modifier)
-    mock_obj.WorkWithParameter(['mutated'])
-    self.mox.ReplayAll()
-
-    local_list = ['original']
-    mock_obj.ConfigureInOutParameter(local_list)
-    mock_obj.WorkWithParameter(local_list)
-
-    self.mox.VerifyAll()
-
-  def testWithSideEffectsException(self):
-    """Test side effect operations actually modify their target objects."""
-    def modifier(mutable_list):
-      mutable_list[0] = 'mutated'
-    mock_obj = self.mox.CreateMockAnything()
-    method = mock_obj.ConfigureInOutParameter(['original'])
-    method.WithSideEffects(modifier).AndRaise(Exception('exception'))
-    mock_obj.WorkWithParameter(['mutated'])
-    self.mox.ReplayAll()
-
-    local_list = ['original']
-    self.failUnlessRaises(Exception,
-                          mock_obj.ConfigureInOutParameter,
-                          local_list)
-    mock_obj.WorkWithParameter(local_list)
-
-    self.mox.VerifyAll()
-
-  def testStubOutMethod(self):
-    """Test that a method is replaced with a MockAnything."""
-    test_obj = TestClass()
-    # Replace OtherValidCall with a mock.
-    self.mox.StubOutWithMock(test_obj, 'OtherValidCall')
-    self.assert_(isinstance(test_obj.OtherValidCall, mox.MockAnything))
-    test_obj.OtherValidCall().AndReturn('foo')
-    self.mox.ReplayAll()
-
-    actual = test_obj.OtherValidCall()
-
-    self.mox.VerifyAll()
-    self.mox.UnsetStubs()
-    self.assertEquals('foo', actual)
-    self.failIf(isinstance(test_obj.OtherValidCall, mox.MockAnything))
-
-  def testWarnsUserIfMockingMock(self):
-    """Test that user is warned if they try to stub out a MockAnything."""
-    self.mox.StubOutWithMock(TestClass, 'MyStaticMethod')
-    self.assertRaises(TypeError, self.mox.StubOutWithMock, TestClass,
-                      'MyStaticMethod')
-
-  def testStubOutObject(self):
-    """Test than object is replaced with a Mock."""
-
-    class Foo(object):
-      def __init__(self):
-        self.obj = TestClass()
-
-    foo = Foo()
-    self.mox.StubOutWithMock(foo, "obj")
-    self.assert_(isinstance(foo.obj, mox.MockObject))
-    foo.obj.ValidCall()
-    self.mox.ReplayAll()
-
-    foo.obj.ValidCall()
-
-    self.mox.VerifyAll()
-    self.mox.UnsetStubs()
-    self.failIf(isinstance(foo.obj, mox.MockObject))
-
-  def testForgotReplayHelpfulMessage(self):
-    """If there is an AttributeError on a MockMethod, give users a helpful msg.
-    """
-    foo = self.mox.CreateMockAnything()
-    bar = self.mox.CreateMockAnything()
-    foo.GetBar().AndReturn(bar)
-    bar.ShowMeTheMoney()
-    # Forgot to replay!
-    try:
-      foo.GetBar().ShowMeTheMoney()
-    except AttributeError, e:
-      self.assertEquals('MockMethod has no attribute "ShowMeTheMoney". '
-          'Did you remember to put your mocks in replay mode?', str(e))
-
-
-class ReplayTest(unittest.TestCase):
-  """Verify Replay works properly."""
-
-  def testReplay(self):
-    """Replay should put objects into replay mode."""
-    mock_obj = mox.MockObject(TestClass)
-    self.assertFalse(mock_obj._replay_mode)
-    mox.Replay(mock_obj)
-    self.assertTrue(mock_obj._replay_mode)
-
-
-class MoxTestBaseTest(unittest.TestCase):
-  """Verify that all tests in a class derived from MoxTestBase are wrapped."""
-
-  def setUp(self):
-    self.mox = mox.Mox()
-    self.test_mox = mox.Mox()
-    self.result = unittest.TestResult()
-
-  def tearDown(self):
-    # In case one of our tests fail before UnsetStubs is called.
-    self.mox.UnsetStubs()
-    self.test_mox.UnsetStubs()
-
-  def _setUpTestClass(self):
-    """Replacement for setUp in the test class instance.
-
-    Assigns a mox.Mox instance as the mox attribute of the test class instance.
-    This replacement Mox instance is under our control before setUp is called
-    in the test class instance.
-    """
-    self.test.mox = self.test_mox
-
-  def _CreateTest(self, test_name):
-    """Create a test from our example mox class.
-
-    The created test instance is assigned to this instances test attribute.
-    """
-    self.test = mox_test_helper.ExampleMoxTest(test_name)
-    self.mox.stubs.Set(self.test, 'setUp', self._setUpTestClass)
-
-  def _VerifySuccess(self):
-    """Run the checks to confirm test method completed successfully."""
-    self.mox.StubOutWithMock(self.test_mox, 'UnsetStubs')
-    self.mox.StubOutWithMock(self.test_mox, 'VerifyAll')
-    self.test_mox.UnsetStubs()
-    self.test_mox.VerifyAll()
-    self.mox.ReplayAll()
-    self.test.run(result=self.result)
-    self.assertTrue(self.result.wasSuccessful())
-    self.mox.UnsetStubs()
-    self.mox.VerifyAll()
-    self.test_mox.UnsetStubs()
-    self.test_mox.VerifyAll()
-
-  def testSuccess(self):
-    """Successful test method execution test."""
-    self._CreateTest('testSuccess')
-    self._VerifySuccess()
-
-  def testExpectedNotCalled(self):
-    """Stubbed out method is not called."""
-    self._CreateTest('testExpectedNotCalled')
-    self.mox.StubOutWithMock(self.test_mox, 'UnsetStubs')
-    # Dont stub out VerifyAll - that's what causes the test to fail
-    self.test_mox.UnsetStubs()
-    self.test_mox.VerifyAll()
-    self.mox.ReplayAll()
-    self.test.run(result=self.result)
-    self.failIf(self.result.wasSuccessful())
-    self.mox.UnsetStubs()
-    self.mox.VerifyAll()
-    self.test_mox.UnsetStubs()
-
-  def testUnexpectedCall(self):
-    """Stubbed out method is called with unexpected arguments."""
-    self._CreateTest('testUnexpectedCall')
-    self.mox.StubOutWithMock(self.test_mox, 'UnsetStubs')
-    # Ensure no calls are made to VerifyAll()
-    self.mox.StubOutWithMock(self.test_mox, 'VerifyAll')
-    self.test_mox.UnsetStubs()
-    self.mox.ReplayAll()
-    self.test.run(result=self.result)
-    self.failIf(self.result.wasSuccessful())
-    self.mox.UnsetStubs()
-    self.mox.VerifyAll()
-    self.test_mox.UnsetStubs()
-
-  def testFailure(self):
-    """Failing assertion in test method."""
-    self._CreateTest('testFailure')
-    self.mox.StubOutWithMock(self.test_mox, 'UnsetStubs')
-    # Ensure no calls are made to VerifyAll()
-    self.mox.StubOutWithMock(self.test_mox, 'VerifyAll')
-    self.test_mox.UnsetStubs()
-    self.mox.ReplayAll()
-    self.test.run(result=self.result)
-    self.failIf(self.result.wasSuccessful())
-    self.mox.UnsetStubs()
-    self.mox.VerifyAll()
-    self.test_mox.UnsetStubs()
-
-  def testMixin(self):
-    """Run test from mix-in test class, ensure it passes."""
-    self._CreateTest('testStat')
-    self._VerifySuccess()
-
-  def testMixinAgain(self):
-    """Run same test as above but from the current test class.
-
-    This ensures metaclass properly wrapped test methods from all base classes.
-    If unsetting of stubs doesn't happen, this will fail.
-    """
-    self._CreateTest('testStatOther')
-    self._VerifySuccess()
-
-
-class VerifyTest(unittest.TestCase):
-  """Verify Verify works properly."""
-
-  def testVerify(self):
-    """Verify should be called for all objects.
-
-    This should throw an exception because the expected behavior did not occur.
-    """
-    mock_obj = mox.MockObject(TestClass)
-    mock_obj.ValidCall()
-    mock_obj._Replay()
-    self.assertRaises(mox.ExpectedMethodCallsError, mox.Verify, mock_obj)
-
-
-class ResetTest(unittest.TestCase):
-  """Verify Reset works properly."""
-
-  def testReset(self):
-    """Should empty all queues and put mocks in record mode."""
-    mock_obj = mox.MockObject(TestClass)
-    mock_obj.ValidCall()
-    self.assertFalse(mock_obj._replay_mode)
-    mock_obj._Replay()
-    self.assertTrue(mock_obj._replay_mode)
-    self.assertEquals(1, len(mock_obj._expected_calls_queue))
-
-    mox.Reset(mock_obj)
-    self.assertFalse(mock_obj._replay_mode)
-    self.assertEquals(0, len(mock_obj._expected_calls_queue))
-
-
-class MyTestCase(unittest.TestCase):
-  """Simulate the use of a fake wrapper around Python's unittest library."""
-
-  def setUp(self):
-    super(MyTestCase, self).setUp()
-    self.critical_variable = 42
-
-
-class MoxTestBaseMultipleInheritanceTest(mox.MoxTestBase, MyTestCase):
-  """Test that multiple inheritance can be used with MoxTestBase."""
-
-  def setUp(self):
-    super(MoxTestBaseMultipleInheritanceTest, self).setUp()
-
-  def testMultipleInheritance(self):
-    """Should be able to access members created by all parent setUp()."""
-    self.assert_(isinstance(self.mox, mox.Mox))
-    self.assertEquals(42, self.critical_variable)
-
-
-class TestClass:
-  """This class is used only for testing the mock framework"""
-
-  SOME_CLASS_VAR = "test_value"
-  _PROTECTED_CLASS_VAR = "protected value"
-
-  def __init__(self, ivar=None):
-    self.__ivar = ivar
-
-  def __eq__(self, rhs):
-    return self.__ivar == rhs
-
-  def __ne__(self, rhs):
-    return not self.__eq__(rhs)
-
-  def ValidCall(self):
-    pass
-
-  def OtherValidCall(self):
-    pass
-
-  def ValidCallWithArgs(self, *args, **kwargs):
-    pass
-
-  @classmethod
-  def MyClassMethod(cls):
-    pass
-
-  @staticmethod
-  def MyStaticMethod():
-    pass
-
-  def _ProtectedCall(self):
-    pass
-
-  def __PrivateCall(self):
-    pass
-
-  def __getitem__(self, key):
-    pass
-
-  def __DoNotMock(self):
-    pass
-
-  def __getitem__(self, key):
-    """Return the value for key."""
-    return self.d[key]
-
-  def __setitem__(self, key, value):
-    """Set the value for key to value."""
-    self.d[key] = value
-
-  def __contains__(self, key):
-     """Returns True if d contains the key."""
-     return key in self.d
-
-  def __iter__(self):
-    pass
-
-class ChildClass(TestClass):
-  """This inherits from TestClass."""
-  def __init__(self):
-    TestClass.__init__(self)
-
-  def ChildValidCall(self):
-    pass
-
-
-class CallableClass(object):
-  """This class is callable, and that should be mockable!"""
-
-  def __init__(self):
-    pass
-
-  def __call__(self, param):
-    return param
-
-
-class SubscribtableNonIterableClass(object):
-  def __getitem__(self, index):
-    raise IndexError
-
-
-class InheritsFromCallable(CallableClass):
-  """This class should also be mockable; it inherits from a callable class."""
-
-  pass
-
-
-if __name__ == '__main__':
-  unittest.main()