# 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.
#
# This is a fork of the pymox library intended to work with Python 3.
# The file was modified by quermit@gmail.com and dawid.fatyga@gmail.com

import io
import re

from mox3 import mox
from mox3.tests import mox_helper

import testtools


OS_LISTDIR = mox_helper.os.listdir


class ExpectedMethodCallsErrorTest(testtools.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(testtools.TestCase):
    """Test Or correctly chains Comparators."""

    def testValidOr(self):
        """Or should be True if either Comparator returns True."""
        self.assertTrue(mox.Or(mox.IsA(dict), mox.IsA(str)) == {})
        self.assertTrue(mox.Or(mox.IsA(dict), mox.IsA(str)) == 'test')
        self.assertTrue(mox.Or(mox.IsA(str), mox.IsA(str)) == 'test')

    def testInvalidOr(self):
        """Or should be False if both Comparators return False."""
        self.assertFalse(mox.Or(mox.IsA(dict), mox.IsA(str)) == 0)


class AndTest(testtools.TestCase):
    """Test And correctly chains Comparators."""

    def testValidAnd(self):
        """And should be True if both Comparators return True."""
        self.assertTrue(mox.And(mox.IsA(str), mox.IsA(str)) == '1')

    def testClauseOneFails(self):
        """And should be False if the first Comparator returns False."""

        self.assertFalse(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.assertTrue(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.assertFalse(mox.And(mox.In("NOTFOUND"),
                         mox.ContainsKeyValue("mock", "obj")) == test_dict)


class FuncTest(testtools.TestCase):
    """Test Func correctly evaluates based upon true-false return."""

    def testFuncTrueFalseEvaluation(self):
        """Should return True if the validating function returns True."""

        def equals_one(x):
            return x == 1

        def always_none(x):
            return None

        self.assertTrue(mox.Func(equals_one) == 1)
        self.assertFalse(mox.Func(equals_one) == 0)

        self.assertFalse(mox.Func(always_none) == 1)
        self.assertFalse(mox.Func(always_none) == 0)
        self.assertFalse(mox.Func(always_none) is None)

    def testFuncExceptionPropagation(self):
        """Exceptions within the validating function should propagate."""
        class TestException(Exception):
            pass

        def raiseExceptionOnNotOne(value):
            if value != 1:
                raise TestException
            else:
                return True

        self.assertTrue(mox.Func(raiseExceptionOnNotOne) == 1)
        self.assertRaises(
            TestException, mox.Func(raiseExceptionOnNotOne).__eq__, 2)


class SameElementsAsTest(testtools.TestCase):
    """SameElementsAs correctly identifies sequences with same elements."""

    def testSortedLists(self):
        """Should return True if two lists are exactly equal."""
        self.assertTrue(mox.SameElementsAs([1, 2.0, 'c']) == [1, 2.0, 'c'])

    def testUnsortedLists(self):
        """Should return True if lists are unequal but have same elements."""
        self.assertTrue(mox.SameElementsAs([1, 2.0, 'c']) == [2.0, 'c', 1])

    def testUnhashableLists(self):
        """Should return True if lists have the same unhashable elements."""
        self.assertTrue(mox.SameElementsAs([{'a': 1}, {2: 'b'}]) ==
                        [{2: 'b'}, {'a': 1}])

    def testEmptyLists(self):
        """Should return True for two empty lists."""
        self.assertTrue(mox.SameElementsAs([]) == [])

    def testUnequalLists(self):
        """Should return False if the lists are not equal."""
        self.assertFalse(mox.SameElementsAs([1, 2.0, 'c']) == [2.0, 'c'])

    def testUnequalUnhashableLists(self):
        """Should return False if lists with unhashable items are unequal."""
        self.assertFalse(mox.SameElementsAs(
            [{'a': 1}, {2: 'b'}]) == [{2: 'b'}])

    def testActualIsNotASequence(self):
        """Should return False if the actual object is not a sequence."""
        self.assertFalse(mox.SameElementsAs([1]) == object())

    def testOneUnhashableObjectInActual(self):
        """Store the entire iterator for a correct comparison.

        In a previous version of SameElementsAs, iteration stopped when an
        unhashable object was encountered and then was restarted, so the actual
        list appeared smaller than it was.
        """
        self.assertFalse(mox.SameElementsAs([1, 2]) == iter([{}, 1, 2]))


class ContainsKeyValueTest(testtools.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.assertTrue(mox.ContainsKeyValue("key", 1) == {"key": 1})

    def testInvalidValue(self):
        """Should return False if the value is not correct."""
        self.assertFalse(mox.ContainsKeyValue("key", 1) == {"key": 2})

    def testInvalidKey(self):
        """Should return False if they key is not in the dict."""
        self.assertFalse(mox.ContainsKeyValue("qux", 1) == {"key": 2})


class ContainsAttributeValueTest(testtools.TestCase):
    """Test ContainsAttributeValue identifies properties in an object."""

    def setUp(self):
        """Create an object to test with."""

        class TestObject(object):
            key = 1

        super(ContainsAttributeValueTest, self).setUp()
        self.test_object = TestObject()

    def testValidPair(self):
        """Return True if the object has the key attribute that matches."""
        self.assertTrue(mox.ContainsAttributeValue("key", 1) ==
                        self.test_object)

    def testInvalidValue(self):
        """Should return False if the value is not correct."""
        self.assertFalse(mox.ContainsKeyValue("key", 2) == self.test_object)

    def testInvalidKey(self):
        """Should return False if they the object doesn't have the property."""
        self.assertFalse(mox.ContainsKeyValue("qux", 1) == self.test_object)


class InTest(testtools.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.assertTrue(mox.In(1) == [1, 2, 3])

    def testKeyInDict(self):
        """Should return True if the item is a key in a dict."""
        self.assertTrue(mox.In("test") == {"test": "module"})

    def testItemInTuple(self):
        """Should return True if the item is in the list."""
        self.assertTrue(mox.In(1) == (1, 2, 3))

    def testTupleInTupleOfTuples(self):
        self.assertTrue(mox.In((1, 2, 3)) == ((1, 2, 3), (1, 2)))

    def testItemNotInList(self):
        self.assertFalse(mox.In(1) == [2, 3])

    def testTupleNotInTupleOfTuples(self):
        self.assertFalse(mox.In((1, 2)) == ((1, 2, 3), (4, 5)))


class NotTest(testtools.TestCase):
    """Test Not correctly identifies False predicates."""

    def testItemInList(self):
        """Should return True if the item is NOT in the list."""
        self.assertTrue(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.assertTrue(mox.Not(mox.In("foo")) == {"key": 42})

    def testInvalidKeyWithNot(self):
        """Should return False if they key is NOT in the dict."""
        self.assertTrue(mox.Not(mox.ContainsKeyValue("qux", 1)) == {"key": 2})


class StrContainsTest(testtools.TestCase):
    """Test StrContains checks for substring occurrence of a parameter."""

    def testValidSubstringAtStart(self):
        """Should return True if substring is at the start of the string."""
        self.assertTrue(mox.StrContains("hello") == "hello world")

    def testValidSubstringInMiddle(self):
        """Should return True if substring is in the middle of the string."""
        self.assertTrue(mox.StrContains("lo wo") == "hello world")

    def testValidSubstringAtEnd(self):
        """Should return True if the substring is at the end of the string."""
        self.assertTrue(mox.StrContains("ld") == "hello world")

    def testInvaildSubstring(self):
        """Should return False if the substring is not in the string."""
        self.assertFalse(mox.StrContains("AAA") == "hello world")

    def testMultipleMatches(self):
        """Should return True if there are multiple occurrences of substring"""
        self.assertTrue(mox.StrContains("abc") == "ababcabcabcababc")


class RegexTest(testtools.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):
        """Return True if the pattern matches at the middle of the string.

        This ensures that re.search is used (instead of re.find).
        """
        self.assertTrue(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.assertFalse(mox.Regex(r"a\s+b") == "x y z")

    def testFlagsPassedCorrectly(self):
        """Should return True as we pass IGNORECASE flag."""
        self.assertTrue(mox.Regex(r"A", re.IGNORECASE) == "a")

    def testReprWithoutFlags(self):
        """repr should return the regular expression pattern."""
        self.assertTrue(
            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.assertTrue(repr(mox.Regex(r"a\s+b", flags=4)) ==
                        "<regular expression 'a\s+b', flags=4>")


class IsTest(testtools.TestCase):
    """Verify Is correctly checks equality based upon identity, not value."""

    class AlwaysComparesTrue(object):
        def __eq__(self, other):
            return True

        def __cmp__(self, other):
            return 0

        def __ne__(self, other):
            return False

    def testEqualityValid(self):
        o1 = self.AlwaysComparesTrue()
        self.assertTrue(mox.Is(o1), o1)

    def testEqualityInvalid(self):
        o1 = self.AlwaysComparesTrue()
        o2 = self.AlwaysComparesTrue()
        self.assertTrue(o1 == o2)
        # but...
        self.assertFalse(mox.Is(o1) == o2)

    def testInequalityValid(self):
        o1 = self.AlwaysComparesTrue()
        o2 = self.AlwaysComparesTrue()
        self.assertTrue(mox.Is(o1) != o2)

    def testInequalityInvalid(self):
        o1 = self.AlwaysComparesTrue()
        self.assertFalse(mox.Is(o1) != o1)

    def testEqualityInListValid(self):
        o1 = self.AlwaysComparesTrue()
        o2 = self.AlwaysComparesTrue()
        isa_list = [mox.Is(o1), mox.Is(o2)]
        str_list = [o1, o2]
        self.assertTrue(isa_list == str_list)

    def testEquailtyInListInvalid(self):
        o1 = self.AlwaysComparesTrue()
        o2 = self.AlwaysComparesTrue()
        isa_list = [mox.Is(o1), mox.Is(o2)]
        mixed_list = [o2, o1]
        self.assertFalse(isa_list == mixed_list)


class IsATest(testtools.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.assertTrue(mox.IsA(str) == 'test')

    def testEqualityInvalid(self):
        """Verify that == correctly identifies objects of different types."""
        self.assertFalse(mox.IsA(str) == 10)

    def testInequalityValid(self):
        """Verify that != identifies objects of different type."""
        self.assertTrue(mox.IsA(str) != 10)

    def testInequalityInvalid(self):
        """Verify that != correctly identifies objects of the same type."""
        self.assertFalse(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.assertTrue(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.assertFalse(isa_list == mixed_list)

    def testSpecialTypes(self):
        """Verify that IsA can handle objects like io.StringIO."""
        isA = mox.IsA(io.StringIO())
        stringIO = io.StringIO()
        self.assertTrue(isA == stringIO)


class IsAlmostTest(testtools.TestCase):
    """Verify IsAlmost correctly checks equality of floating point numbers."""

    def testEqualityValid(self):
        """Verify that == correctly identifies nearly equivalent floats."""
        self.assertEqual(mox.IsAlmost(1.8999999999), 1.9)

    def testEqualityInvalid(self):
        """Verify that == correctly identifies non-equivalent floats."""
        self.assertNotEqual(mox.IsAlmost(1.899), 1.9)

    def testEqualityWithPlaces(self):
        """Verify that specifying places has the desired effect."""
        self.assertNotEqual(mox.IsAlmost(1.899), 1.9)
        self.assertEqual(mox.IsAlmost(1.899, places=2), 1.9)

    def testNonNumericTypes(self):
        """Verify that IsAlmost handles non-numeric types properly."""

        self.assertNotEqual(mox.IsAlmost(1.8999999999), '1.9')
        self.assertNotEqual(mox.IsAlmost('1.8999999999'), 1.9)
        self.assertNotEqual(mox.IsAlmost('1.8999999999'), '1.9')


class ValueRememberTest(testtools.TestCase):
    """Verify comparing argument against remembered value."""

    def testValueEquals(self):
        """Verify that value will compare to stored value."""
        value = mox.Value()
        value.store_value('hello world')
        self.assertEqual(value, 'hello world')

    def testNoValue(self):
        """Verify that uninitialized value does not compare to empty values."""
        value = mox.Value()
        self.assertNotEqual(value, None)
        self.assertNotEqual(value, False)
        self.assertNotEqual(value, 0)
        self.assertNotEqual(value, '')
        self.assertNotEqual(value, ())
        self.assertNotEqual(value, [])
        self.assertNotEqual(value, {})
        self.assertNotEqual(value, object())
        self.assertNotEqual(value, set())

    def testRememberValue(self):
        """Verify that comparing against remember will store argument."""
        value = mox.Value()
        remember = mox.Remember(value)
        self.assertNotEqual(value, 'hello world')  # value not yet stored.
        self.assertEqual(remember, 'hello world')  # store value here.
        self.assertEqual(value, 'hello world')  # compare against stored value.


class MockMethodTest(testtools.TestCase):
    """Test class to verify that the MockMethod class is working correctly."""

    def setUp(self):
        super(MockMethodTest, self).setUp()
        self.expected_method = mox.MockMethod(
            "testMethod", [], False)(['original'])
        self.mock_method = mox.MockMethod(
            "testMethod", [self.expected_method], True)

    def testNameAttribute(self):
        """Should provide a __name__ attribute."""
        self.assertEqual('testMethod', self.mock_method.__name__)

    def testAndReturnNoneByDefault(self):
        """Should return None by default."""
        return_value = self.mock_method(['original'])
        self.assertTrue(return_value is 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.assertTrue(return_value == expected_return_value)

    def testAndRaiseException(self):
        """Should raise a specified exception."""
        class TestException(Exception):
            pass

        expected_exception = TestException('test exception')
        self.expected_method.AndRaise(expected_exception)
        self.assertRaises(TestException, self.mock_method, ['original'])

    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.assertEqual('mutation', local_list[0])

    def testWithReturningSideEffects(self):
        """Should call state modifier and propagate its return value."""
        local_list = ['original']
        expected_return = 'expected_return'

        def modifier_with_return(mutable_list):
            self.assertTrue(local_list is mutable_list)
            mutable_list[0] = 'mutation'
            return expected_return

        self.expected_method.WithSideEffects(modifier_with_return)
        actual_return = self.mock_method(local_list)
        self.assertEqual('mutation', local_list[0])
        self.assertEqual(expected_return, actual_return)

    def testWithReturningSideEffectsWithAndReturn(self):
        """Should call state modifier and ignore its return value."""
        local_list = ['original']
        expected_return = 'expected_return'
        unexpected_return = 'unexpected_return'

        def modifier_with_return(mutable_list):
            self.assertTrue(local_list is mutable_list)
            mutable_list[0] = 'mutation'
            return unexpected_return

        self.expected_method.WithSideEffects(modifier_with_return).AndReturn(
            expected_return)
        actual_return = self.mock_method(local_list)
        self.assertEqual('mutation', local_list[0])
        self.assertEqual(expected_return, actual_return)

    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 without params should not be equal."""
        expected_method = mox.MockMethod("otherMethod", [], False)
        self.assertNotEqual(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 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.assertNotEqual(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 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.assertNotEqual(self.mock_method, expected_method)

    def testEqualityWrongType(self):
        """Method should not be equal to an object of a different type."""
        self.assertNotEqual(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(testtools.TestCase):
    """Verify that the MockAnything class works as expected."""

    def setUp(self):
        super(MockAnythingTest, self).setUp()
        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 testCanMockStr(self):
        self.mock_object.__str__().AndReturn("foo")
        self.mock_object._Replay()
        actual = str(self.mock_object)
        self.mock_object._Verify()
        self.assertEqual("foo", actual)

    def testSetupMode(self):
        """Verify the mock will accept any call."""
        self.mock_object.NonsenseCall()
        self.assertTrue(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 exception when special methods are used."""
        self.mock_object[1].AndReturn(True)
        self.mock_object._Replay()
        returned_val = self.mock_object[1]
        self.assertTrue(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.assertEqual(self.mock_object, self.mock_object)

    def testEqualsMockFailure(self):
        """Verify equals identifies unequal objects."""
        self.mock_object.SillyCall()
        self.mock_object._Replay()
        self.assertNotEqual(self.mock_object, mox.MockAnything())

    def testEqualsInstanceFailure(self):
        """Verify equals identifies that objects are different instances."""
        self.mock_object._Replay()
        self.assertNotEqual(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.assertEqual('mox0rd', self.mock_object())

        self.mock_object._Verify()

    def testIsReprable(self):
        """Test that MockAnythings can be repr'd without causing a failure."""
        self.assertIn('MockAnything', repr(self.mock_object))


class MethodCheckerTest(testtools.TestCase):
    """Tests MockMethod's use of MethodChecker method."""

    def testNoParameters(self):
        method = mox.MockMethod('NoParameters', [], False,
                                CheckCallTestClass.NoParameters,
                                class_to_bind=CheckCallTestClass)
        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,
                                class_to_bind=CheckCallTestClass)
        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,
                                class_to_bind=CheckCallTestClass)
        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,
                                class_to_bind=CheckCallTestClass)
        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,
                                class_to_bind=CheckCallTestClass)
        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,
                                class_to_bind=CheckCallTestClass)
        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,
                                class_to_bind=CheckCallTestClass)
        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,
                                class_to_bind=CheckCallTestClass)
        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(testtools.TestCase):
    """Verify that the MockObject class works as exepcted."""

    def setUp(self):
        super(MockObjectTest, self).setUp()
        self.mock_object = mox.MockObject(TestClass)

    def testSetupModeWithValidCall(self):
        """Verify the mock object properly mocks a basic method call."""
        self.mock_object.ValidCall()
        self.assertTrue(len(self.mock_object._expected_calls_queue) == 1)

    def testSetupModeWithInvalidCall(self):
        """Rase UnknownMethodCallError for a non-member method call.
        """
        # 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):
        """Rase UnknownMethodCallError for a non-member method call.
        """
        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.assertTrue(isinstance(self.mock_object, TestClass))

    def testFindValidMethods(self):
        """Mock should be able to mock all public methods."""
        self.assertIn('ValidCall', self.mock_object._known_methods)
        self.assertIn('OtherValidCall', self.mock_object._known_methods)
        self.assertIn('MyClassMethod', self.mock_object._known_methods)
        self.assertIn('MyStaticMethod', self.mock_object._known_methods)
        self.assertIn('_ProtectedCall', self.mock_object._known_methods)
        self.assertNotIn('__PrivateCall', self.mock_object._known_methods)
        self.assertIn(
            '_TestClass__PrivateCall', self.mock_object._known_methods)

    def testFindsSuperclassMethods(self):
        """Mock should be able to mock superclasses methods."""
        self.mock_object = mox.MockObject(ChildClass)
        self.assertIn('ValidCall', self.mock_object._known_methods)
        self.assertIn('OtherValidCall', self.mock_object._known_methods)
        self.assertIn('MyClassMethod', self.mock_object._known_methods)
        self.assertIn('ChildValidCall', self.mock_object._known_methods)

    def testAccessClassVariables(self):
        """Class variables should be accessible through the mock."""
        self.assertIn('SOME_CLASS_VAR', self.mock_object._known_vars)
        self.assertIn('_PROTECTED_CLASS_VAR', self.mock_object._known_vars)
        self.assertEqual('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.assertEqual(self.mock_object, self.mock_object)

    def testEqualsMockFailure(self):
        """Verify equals identifies unequal objects."""
        self.mock_object.ValidCall()
        self.mock_object._Replay()
        self.assertNotEqual(self.mock_object, mox.MockObject(TestClass))

    def testEqualsInstanceFailure(self):
        """Verify equals identifies that objects are different instances."""
        self.mock_object._Replay()
        self.assertNotEqual(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.assertEqual('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.assertIn('X', 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.assertEqual(['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()
        self.assertRaises(mox.UnexpectedMethodCallError,
                          lambda: [x for x in dummy])

    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.assertEqual(['a', 'b'], [x for x in dummy])
        dummy._Verify()

    def testInstantiationWithAdditionalAttributes(self):
        mock_object = mox.MockObject(TestClass, attrs={"attr1": "value"})
        self.assertEqual(mock_object.attr1, "value")

    def testCantOverrideMethodsWithAttributes(self):
        self.assertRaises(ValueError, mox.MockObject, TestClass,
                          attrs={"ValidCall": "value"})

    def testCantMockNonPublicAttributes(self):
        self.assertRaises(mox.PrivateAttributeError, mox.MockObject, TestClass,
                          attrs={"_protected": "value"})
        self.assertRaises(mox.PrivateAttributeError, mox.MockObject, TestClass,
                          attrs={"__private": "value"})


class MoxTest(testtools.TestCase):
    """Verify Mox works correctly."""

    def setUp(self):
        super(MoxTest, self).setUp()
        self.mox = mox.Mox()

    def testCreateObject(self):
        """Mox should create a mock object."""
        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.assertEqual("yes", ret_val)
        self.mox.VerifyAll()

    def testSignatureMatchingWithComparatorAsFirstArg(self):
        """Test that the first argument can be a comparator."""

        def VerifyLen(val):
            """This will raise an exception when not given a list.

            This exception will be raised when trying to infer/validate the
            method signature.
            """
            return len(val) != 1

        mock_obj = self.mox.CreateMock(TestClass)
        # This intentionally does not name the 'nine' param so it triggers
        # deeper inspection.
        mock_obj.MethodWithArgs(mox.Func(VerifyLen), mox.IgnoreArg(), None)
        self.mox.ReplayAll()

        mock_obj.MethodWithArgs([1, 2], "foo", None)

        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.assertEqual("qux", ret_val)
        self.mox.VerifyAll()

    def testInheritedCallableObject(self):
        """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.assertEqual("qux", ret_val)
        self.mox.VerifyAll()

    def testCallOnNonCallableObject(self):
        """Test that you cannot call a non-callable object."""
        mock_obj = self.mox.CreateMock("string is not callable")
        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 testCallableObjectVerifiesSignature(self):
        mock_obj = self.mox.CreateMock(CallableClass)
        # Too many arguments
        self.assertRaises(AttributeError, mock_obj, "foo", "bar")

    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.assertEqual(9, actual_one)
        self.assertEqual(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.assertEqual(9, actual_one)
        # Repeated calls should return same number.
        self.assertEqual(9, second_one)
        self.assertEqual(10, actual_two)
        self.assertEqual(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.assertEqual(9, actual_one)
        # Repeated calls should return same number.
        self.assertEqual(9, second_one)

    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.assertEqual(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.assertEqual(9, actual_one)
        self.assertEqual(8, actual_two)
        self.assertEqual(7, actual_three)
        self.assertEqual(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.assertEqual(9, actual_one)
        self.assertEqual(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()
        mock_obj.Method(1)
        mock_obj.Method(1)
        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."""
        class TestException(Exception):
            pass

        def modifier(mutable_list):
            mutable_list[0] = 'mutated'
        mock_obj = self.mox.CreateMockAnything()
        method = mock_obj.ConfigureInOutParameter(['original'])
        method.WithSideEffects(modifier).AndRaise(TestException('exception'))
        mock_obj.WorkWithParameter(['mutated'])
        self.mox.ReplayAll()

        local_list = ['original']
        self.assertRaises(TestException,
                          mock_obj.ConfigureInOutParameter,
                          local_list)
        mock_obj.WorkWithParameter(local_list)

        self.mox.VerifyAll()

    def testStubOutMethod(self):
        """Test that a method is replaced with a MockObject."""
        test_obj = TestClass()
        method_type = type(test_obj.OtherValidCall)
        # Replace OtherValidCall with a mock.
        self.mox.StubOutWithMock(test_obj, 'OtherValidCall')
        self.assertTrue(isinstance(test_obj.OtherValidCall, mox.MockObject))
        self.assertFalse(type(test_obj.OtherValidCall) is method_type)

        test_obj.OtherValidCall().AndReturn('foo')
        self.mox.ReplayAll()

        actual = test_obj.OtherValidCall()

        self.mox.VerifyAll()
        self.mox.UnsetStubs()
        self.assertEqual('foo', actual)
        self.assertTrue(type(test_obj.OtherValidCall) is method_type)

    def testStubOutMethod_Unbound_Comparator(self):
        instance = TestClass()
        self.mox.StubOutWithMock(TestClass, 'OtherValidCall')

        TestClass.OtherValidCall(mox.IgnoreArg()).AndReturn('foo')
        self.mox.ReplayAll()

        actual = TestClass.OtherValidCall(instance)

        self.mox.VerifyAll()
        self.mox.UnsetStubs()
        self.assertEqual('foo', actual)

    def testStubOutMethod_Unbound_Subclass_Comparator(self):
        self.mox.StubOutWithMock(
            mox_helper.TestClassFromAnotherModule, 'Value')
        mox_helper.TestClassFromAnotherModule.Value(
            mox.IsA(mox_helper.ChildClassFromAnotherModule)).AndReturn('foo')
        self.mox.ReplayAll()

        instance = mox_helper.ChildClassFromAnotherModule()
        actual = mox_helper.TestClassFromAnotherModule.Value(instance)

        self.mox.VerifyAll()
        self.mox.UnsetStubs()
        self.assertEqual('foo', actual)

    def testStubOuMethod_Unbound_WithOptionalParams(self):
        self.mox = mox.Mox()
        self.mox.StubOutWithMock(TestClass, 'OptionalArgs')
        TestClass.OptionalArgs(mox.IgnoreArg(), foo=2)
        self.mox.ReplayAll()

        t = TestClass()
        TestClass.OptionalArgs(t, foo=2)

        self.mox.VerifyAll()
        self.mox.UnsetStubs()

    def testStubOutMethod_Unbound_ActualInstance(self):
        instance = TestClass()
        self.mox.StubOutWithMock(TestClass, 'OtherValidCall')

        TestClass.OtherValidCall(instance).AndReturn('foo')
        self.mox.ReplayAll()

        actual = TestClass.OtherValidCall(instance)

        self.mox.VerifyAll()
        self.mox.UnsetStubs()
        self.assertEqual('foo', actual)

    def testStubOutMethod_Unbound_DifferentInstance(self):
        instance = TestClass()
        self.mox.StubOutWithMock(TestClass, 'OtherValidCall')

        TestClass.OtherValidCall(instance).AndReturn('foo')
        self.mox.ReplayAll()

        # This should fail, since the instances are different
        self.assertRaises(mox.UnexpectedMethodCallError,
                          TestClass.OtherValidCall, "wrong self")

        self.mox.VerifyAll()
        self.mox.UnsetStubs()

    def testStubOutMethod_Unbound_NamedUsingPositional(self):
        """Check positional parameters can be matched to keyword arguments."""
        self.mox.StubOutWithMock(mox_helper.ExampleClass, 'NamedParams')
        instance = mox_helper.ExampleClass()
        mox_helper.ExampleClass.NamedParams(instance, 'foo', baz=None)
        self.mox.ReplayAll()

        mox_helper.ExampleClass.NamedParams(instance, 'foo', baz=None)

        self.mox.VerifyAll()
        self.mox.UnsetStubs()

    def testStubOutMethod_Unbound_NamedUsingPositional_SomePositional(self):
        """Check positional parameters can be matched to keyword arguments."""
        self.mox.StubOutWithMock(mox_helper.ExampleClass, 'TestMethod')
        instance = mox_helper.ExampleClass()
        mox_helper.ExampleClass.TestMethod(instance, 'one', 'two', 'nine')
        self.mox.ReplayAll()

        mox_helper.ExampleClass.TestMethod(instance, 'one', 'two', 'nine')

        self.mox.VerifyAll()
        self.mox.UnsetStubs()

    def testStubOutMethod_Unbound_SpecialArgs(self):
        self.mox.StubOutWithMock(mox_helper.ExampleClass, 'SpecialArgs')
        instance = mox_helper.ExampleClass()
        mox_helper.ExampleClass.SpecialArgs(instance, 'foo', None, bar='bar')
        self.mox.ReplayAll()

        mox_helper.ExampleClass.SpecialArgs(instance, 'foo', None, bar='bar')

        self.mox.VerifyAll()
        self.mox.UnsetStubs()

    def testStubOutMethod_Bound_SimpleTest(self):
        t = self.mox.CreateMock(TestClass)

        t.MethodWithArgs(mox.IgnoreArg(), mox.IgnoreArg()).AndReturn('foo')
        self.mox.ReplayAll()

        actual = t.MethodWithArgs(None, None)

        self.mox.VerifyAll()
        self.mox.UnsetStubs()
        self.assertEqual('foo', actual)

    def testStubOutMethod_Bound_NamedUsingPositional(self):
        """Check positional parameters can be matched to keyword arguments."""
        self.mox.StubOutWithMock(mox_helper.ExampleClass, 'NamedParams')
        instance = mox_helper.ExampleClass()
        instance.NamedParams('foo', baz=None)
        self.mox.ReplayAll()

        instance.NamedParams('foo', baz=None)

        self.mox.VerifyAll()
        self.mox.UnsetStubs()

    def testStubOutMethod_Bound_NamedUsingPositional_SomePositional(self):
        """Check positional parameters can be matched to keyword arguments."""
        self.mox.StubOutWithMock(mox_helper.ExampleClass, 'TestMethod')
        instance = mox_helper.ExampleClass()
        instance.TestMethod(instance, 'one', 'two', 'nine')
        self.mox.ReplayAll()

        instance.TestMethod(instance, 'one', 'two', 'nine')

        self.mox.VerifyAll()
        self.mox.UnsetStubs()

    def testStubOutMethod_Bound_SpecialArgs(self):
        self.mox.StubOutWithMock(mox_helper.ExampleClass, 'SpecialArgs')
        instance = mox_helper.ExampleClass()
        instance.SpecialArgs(instance, 'foo', None, bar='bar')
        self.mox.ReplayAll()

        instance.SpecialArgs(instance, 'foo', None, bar='bar')

        self.mox.VerifyAll()
        self.mox.UnsetStubs()

    def testStubOutMethod_Func_PropgatesExceptions(self):
        """Errors in Func comparator should propagate to the calling method."""
        class TestException(Exception):
            pass

        def raiseExceptionOnNotOne(value):
            if value == 1:
                return True
            else:
                raise TestException

        test_obj = TestClass()
        self.mox.StubOutWithMock(test_obj, 'MethodWithArgs')
        test_obj.MethodWithArgs(
            mox.IgnoreArg(), mox.Func(raiseExceptionOnNotOne)).AndReturn(1)
        test_obj.MethodWithArgs(
            mox.IgnoreArg(), mox.Func(raiseExceptionOnNotOne)).AndReturn(1)
        self.mox.ReplayAll()

        self.assertEqual(test_obj.MethodWithArgs('ignored', 1), 1)
        self.assertRaises(TestException,
                          test_obj.MethodWithArgs, 'ignored', 2)

        self.mox.VerifyAll()
        self.mox.UnsetStubs()

    def testStubOut_SignatureMatching_init_(self):
        self.mox.StubOutWithMock(mox_helper.ExampleClass, '__init__')
        mox_helper.ExampleClass.__init__(mox.IgnoreArg())
        self.mox.ReplayAll()

        # Create an instance of a child class, which calls the parent
        # __init__
        mox_helper.ChildExampleClass()

        self.mox.VerifyAll()
        self.mox.UnsetStubs()

    # FIXME(dhellmann): Skip this test until someone can debug why it
    # fails on python 3.4.

    def testStubOutClass_OldStyle(self):
        """Test a mocked class whose __init__ returns a Mock."""
        self.mox.StubOutWithMock(mox_helper, 'TestClassFromAnotherModule')
        self.assertTrue(isinstance(mox_helper.TestClassFromAnotherModule,
                                   mox.MockObject))

        mock_instance = self.mox.CreateMock(
            mox_helper.TestClassFromAnotherModule)
        mox_helper.TestClassFromAnotherModule().AndReturn(mock_instance)
        mock_instance.Value().AndReturn('mock instance')

        self.mox.ReplayAll()

        a_mock = mox_helper.TestClassFromAnotherModule()
        actual = a_mock.Value()

        self.mox.VerifyAll()
        self.mox.UnsetStubs()
        self.assertEqual('mock instance', actual)

    def testStubOutClass(self):
        self.mox.StubOutClassWithMocks(mox_helper, 'CallableClass')

        # Instance one
        mock_one = mox_helper.CallableClass(1, 2)
        mock_one.Value().AndReturn('mock')

        # Instance two
        mock_two = mox_helper.CallableClass(8, 9)
        mock_two('one').AndReturn('called mock')

        self.mox.ReplayAll()

        one = mox_helper.CallableClass(1, 2)
        actual_one = one.Value()

        two = mox_helper.CallableClass(8, 9)
        actual_two = two('one')

        self.mox.VerifyAll()
        self.mox.UnsetStubs()

        # Verify the correct mocks were returned
        self.assertEqual(mock_one, one)
        self.assertEqual(mock_two, two)

        # Verify
        self.assertEqual('mock', actual_one)
        self.assertEqual('called mock', actual_two)

    def testStubOutClass_NotAClass(self):
        self.assertRaises(TypeError, self.mox.StubOutClassWithMocks,
                          mox_helper, 'MyTestFunction')

    def testStubOutClassNotEnoughCreated(self):
        self.mox.StubOutClassWithMocks(mox_helper, 'CallableClass')

        mox_helper.CallableClass(1, 2)
        mox_helper.CallableClass(8, 9)

        self.mox.ReplayAll()
        mox_helper.CallableClass(1, 2)

        self.assertRaises(mox.ExpectedMockCreationError, self.mox.VerifyAll)
        self.mox.UnsetStubs()

    def testStubOutClassWrongSignature(self):
        self.mox.StubOutClassWithMocks(mox_helper, 'CallableClass')

        self.assertRaises(AttributeError, mox_helper.CallableClass)

        self.mox.UnsetStubs()

    def testStubOutClassWrongParameters(self):
        self.mox.StubOutClassWithMocks(mox_helper, 'CallableClass')

        mox_helper.CallableClass(1, 2)

        self.mox.ReplayAll()

        self.assertRaises(mox.UnexpectedMethodCallError,
                          mox_helper.CallableClass, 8, 9)
        self.mox.UnsetStubs()

    def testStubOutClassTooManyCreated(self):
        self.mox.StubOutClassWithMocks(mox_helper, 'CallableClass')

        mox_helper.CallableClass(1, 2)

        self.mox.ReplayAll()
        mox_helper.CallableClass(1, 2)
        self.assertRaises(mox.UnexpectedMockCreationError,
                          mox_helper.CallableClass, 8, 9)

        self.mox.UnsetStubs()

    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 testStubOutFirstClassMethodVerifiesSignature(self):
        self.mox.StubOutWithMock(mox_helper, 'MyTestFunction')

        # Wrong number of arguments
        self.assertRaises(AttributeError, mox_helper.MyTestFunction, 1)
        self.mox.UnsetStubs()

    def _testMethodSignatureVerification(self, stubClass):
        # If stubClass is true, the test is run against an a stubbed out class,
        # else the test is run against a stubbed out instance.
        if stubClass:
            self.mox.StubOutWithMock(mox_helper.ExampleClass, "TestMethod")
            obj = mox_helper.ExampleClass()
        else:
            obj = mox_helper.ExampleClass()
            self.mox.StubOutWithMock(mox_helper.ExampleClass, "TestMethod")
        self.assertRaises(AttributeError, obj.TestMethod)
        self.assertRaises(AttributeError, obj.TestMethod, 1)
        self.assertRaises(AttributeError, obj.TestMethod, nine=2)
        obj.TestMethod(1, 2)
        obj.TestMethod(1, 2, 3)
        obj.TestMethod(1, 2, nine=3)
        self.assertRaises(AttributeError, obj.TestMethod, 1, 2, 3, 4)
        self.mox.UnsetStubs()

    def testStubOutClassMethodVerifiesSignature(self):
        self._testMethodSignatureVerification(stubClass=True)

    def testStubOutObjectMethodVerifiesSignature(self):
        self._testMethodSignatureVerification(stubClass=False)

    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.assertTrue(isinstance(foo.obj, mox.MockObject))
        foo.obj.ValidCall()
        self.mox.ReplayAll()

        foo.obj.ValidCall()

        self.mox.VerifyAll()
        self.mox.UnsetStubs()
        self.assertFalse(isinstance(foo.obj, mox.MockObject))

    def testForgotReplayHelpfulMessage(self):
        """If there is an AttributeError on a MockMethod, give 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 as e:
            self.assertEqual(
                'MockMethod has no attribute "ShowMeTheMoney". '
                'Did you remember to put your mocks in replay mode?', str(e))


class ReplayTest(testtools.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(testtools.TestCase):
    """Verify that all tests in class derived from MoxTestBase are wrapped."""

    def setUp(self):
        super(MoxTestBaseTest, self).setUp()
        self.mox = mox.Mox()
        self.addCleanup(self.mox.UnsetStubs)
        self.test_mox = mox.Mox()
        self.addCleanup(self.test_mox.UnsetStubs)
        self.test_stubs = mox.stubout.StubOutForTesting()
        self.addCleanup(self.test_stubs.UnsetAll)
        self.addCleanup(self.test_stubs.SmartUnsetAll)
        self.result = testtools.TestResult()

    def _setUpTestClass(self):
        """Replacement for setUp in the test class instance.

        Assigns a mox.Mox instance as the mox attribute of the test instance.
        Replacement Mox instance is under our control before setUp is called
        in the test class instance.
        """
        self.test.mox = self.test_mox
        self.test.stubs = self.test_stubs

    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_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.mox.StubOutWithMock(self.test_stubs, 'UnsetAll')
        self.mox.StubOutWithMock(self.test_stubs, 'SmartUnsetAll')
        self.test_mox.UnsetStubs()
        self.test_mox.VerifyAll()
        self.test_stubs.UnsetAll()
        self.test_stubs.SmartUnsetAll()
        self.mox.ReplayAll()
        self.test.run(result=self.result)
        self.assertTrue(self.result.wasSuccessful())
        self.mox.VerifyAll()
        self.mox.UnsetStubs()    # Needed to call the real VerifyAll() below.
        self.test_mox.VerifyAll()

    def testSuccess(self):
        """Successful test method execution test."""
        self._CreateTest('testSuccess')
        self._VerifySuccess()

    def testSuccessNoMocks(self):
        """testSuccess() unsets all the mocks. Vverify they've been unset."""
        self._CreateTest('testSuccess')
        self.test.run(result=self.result)
        self.assertTrue(self.result.wasSuccessful())
        self.assertEqual(OS_LISTDIR, mox_helper.os.listdir)

    def testStubs(self):
        """Test that "self.stubs" is provided as is useful."""
        self._CreateTest('testHasStubs')
        self._VerifySuccess()

    def testStubsNoMocks(self):
        """Let testHasStubs() unset the stubs by itself."""
        self._CreateTest('testHasStubs')
        self.test.run(result=self.result)
        self.assertTrue(self.result.wasSuccessful())
        self.assertEqual(OS_LISTDIR, mox_helper.os.listdir)

    def testExpectedNotCalled(self):
        """Stubbed out method is not called."""
        self._CreateTest('testExpectedNotCalled')
        self.mox.StubOutWithMock(self.test_mox, 'UnsetStubs')
        self.mox.StubOutWithMock(self.test_stubs, 'UnsetAll')
        self.mox.StubOutWithMock(self.test_stubs, 'SmartUnsetAll')
        # Don't stub out VerifyAll - that's what causes the test to fail
        self.test_mox.UnsetStubs()
        self.test_stubs.UnsetAll()
        self.test_stubs.SmartUnsetAll()
        self.mox.ReplayAll()
        self.test.run(result=self.result)
        self.assertFalse(self.result.wasSuccessful())
        self.mox.VerifyAll()

    def testExpectedNotCalledNoMocks(self):
        """Let testExpectedNotCalled() unset all the mocks by itself."""
        self._CreateTest('testExpectedNotCalled')
        self.test.run(result=self.result)
        self.assertFalse(self.result.wasSuccessful())
        self.assertEqual(OS_LISTDIR, mox_helper.os.listdir)

    def testUnexpectedCall(self):
        """Stubbed out method is called with unexpected arguments."""
        self._CreateTest('testUnexpectedCall')
        self.mox.StubOutWithMock(self.test_mox, 'UnsetStubs')
        self.mox.StubOutWithMock(self.test_stubs, 'UnsetAll')
        self.mox.StubOutWithMock(self.test_stubs, 'SmartUnsetAll')
        # Ensure no calls are made to VerifyAll()
        self.mox.StubOutWithMock(self.test_mox, 'VerifyAll')
        self.test_mox.UnsetStubs()
        self.test_stubs.UnsetAll()
        self.test_stubs.SmartUnsetAll()
        self.mox.ReplayAll()
        self.test.run(result=self.result)
        self.assertFalse(self.result.wasSuccessful())
        self.mox.VerifyAll()

    def testFailure(self):
        """Failing assertion in test method."""
        self._CreateTest('testFailure')
        self.mox.StubOutWithMock(self.test_mox, 'UnsetStubs')
        self.mox.StubOutWithMock(self.test_stubs, 'UnsetAll')
        self.mox.StubOutWithMock(self.test_stubs, 'SmartUnsetAll')
        # Ensure no calls are made to VerifyAll()
        self.mox.StubOutWithMock(self.test_mox, 'VerifyAll')
        self.test_mox.UnsetStubs()
        self.test_stubs.UnsetAll()
        self.test_stubs.SmartUnsetAll()
        self.mox.ReplayAll()
        self.test.run(result=self.result)
        self.assertFalse(self.result.wasSuccessful())
        self.mox.VerifyAll()

    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.

        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(testtools.TestCase):
    """Verify Verify works properly."""

    def testVerify(self):
        """Verify should be called for all objects.

        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(testtools.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.assertEqual(1, len(mock_obj._expected_calls_queue))

        mox.Reset(mock_obj)
        self.assertFalse(mock_obj._replay_mode)
        self.assertEqual(0, len(mock_obj._expected_calls_queue))


class MyTestCase(testtools.TestCase):
    """Simulate the use of a fake wrapper around Python's unittest library."""

    def setUp(self):
        super(MyTestCase, self).setUp()
        self.critical_variable = 42
        self.another_critical_variable = 42

    def testMethodOverride(self):
        """Should be properly overridden in a derived class."""
        self.assertEqual(42, self.another_critical_variable)
        self.another_critical_variable += 1


class MoxTestBaseMultipleInheritanceTest(mox.MoxTestBase, MyTestCase):
    """Test that multiple inheritance can be used with MoxTestBase."""

    def setUp(self):
        super(MoxTestBaseMultipleInheritanceTest, self).setUp()
        self.another_critical_variable = 99

    def testMultipleInheritance(self):
        """Should be able to access members created by all parent setUp()."""
        self.assertTrue(isinstance(self.mox, mox.Mox))
        self.assertEqual(42, self.critical_variable)

    def testMethodOverride(self):
        """Should run before MyTestCase.testMethodOverride."""
        self.assertEqual(99, self.another_critical_variable)
        self.another_critical_variable = 42
        super(MoxTestBaseMultipleInheritanceTest, self).testMethodOverride()
        self.assertEqual(43, self.another_critical_variable)


class MoxTestDontMockProperties(MoxTestBaseTest):
        def testPropertiesArentMocked(self):
                mock_class = self.mox.CreateMock(ClassWithProperties)
                self.assertRaises(mox.UnknownMethodCallError,
                                  lambda: mock_class.prop_attr)


class TestClass(object):
    """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 MethodWithArgs(self, one, two, nine=None):
        pass

    def OtherValidCall(self):
        pass

    def OptionalArgs(self, foo='boom'):
        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 __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 ClassWithProperties(object):
        def setter_attr(self, value):
                pass

        def getter_attr(self):
                pass

        prop_attr = property(getter_attr, setter_attr)


class SubscribtableNonIterableClass(object):
    def __getitem__(self, index):
        raise IndexError


class InheritsFromCallable(CallableClass):
    """This class should be mockable; it inherits from a callable class."""

    pass


if __name__ == '__main__':
    testtools.main()
