Fixed #93 and #121

1 files changed, 0 insertions, 648 deletions

diff --git a/tests/UnitTests/simpletest/test/simple_mock_test.php b/tests/UnitTests/simpletest/test/simple_mock_test.php
deleted file mode 100644
index cdae14f9..00000000
--- a/tests/UnitTests/simpletest/test/simple_mock_test.php
+++ /dev/null
@@ -1,648 +0,0 @@
-<?php

-    // $Id: simple_mock_test.php,v 1.41 2005/01/23 22:20:52 lastcraft Exp $

-    

-    require_once(dirname(__FILE__) . '/../expectation.php');

-    

-    class TestOfWildcardExpectation extends UnitTestCase {

-        

-        function testSimpleInteger() {

-            $expectation = new WildcardExpectation();

-            $this->assertTrue($expectation->test(33));

-            $this->assertWantedPattern(

-                    '/matches.*33/i',

-                    $expectation->testMessage(33));

-        }

-    }

-    

-    class TestOfParametersExpectation extends UnitTestCase {

-        

-        function testEmptyMatch() {

-            $expectation = new ParametersExpectation(array());

-            $this->assertTrue($expectation->test(array()));

-            $this->assertFalse($expectation->test(array(33)));

-        }

-        

-        function testSingleMatch() {

-            $expectation = new ParametersExpectation(array(0));

-            $this->assertFalse($expectation->test(array(1)));

-            $this->assertTrue($expectation->test(array(0)));

-        }

-        

-        function testAnyMatch() {

-            $expectation = new ParametersExpectation(false);

-            $this->assertTrue($expectation->test(array()));

-            $this->assertTrue($expectation->test(array(1, 2)));

-        }

-        

-        function testMissingParameter() {

-            $expectation = new ParametersExpectation(array(0));

-            $this->assertFalse($expectation->test(array()));

-        }

-        

-        function testNullParameter() {

-            $expectation = new ParametersExpectation(array(null));

-            $this->assertTrue($expectation->test(array(null)));

-            $this->assertFalse($expectation->test(array()));

-        }

-        

-        function testWildcardExpectations() {

-            $expectation = new ParametersExpectation(array(new WildcardExpectation()));

-            $this->assertFalse($expectation->test(array()));

-            $this->assertIdentical($expectation->test(array(null)), true);

-            $this->assertIdentical($expectation->test(array(13)), true);

-        }

-        

-        function testOtherExpectations() {

-            $expectation = new ParametersExpectation(

-                    array(new WantedPatternExpectation('/hello/i')));

-            $this->assertFalse($expectation->test(array('Goodbye')));

-            $this->assertTrue($expectation->test(array('hello')));

-            $this->assertTrue($expectation->test(array('Hello')));

-        }

-        

-        function testIdentityOnly() {

-            $expectation = new ParametersExpectation(array("0"));

-            $this->assertFalse($expectation->test(array(0)));

-            $this->assertTrue($expectation->test(array("0")));

-        }

-        

-        function testLongList() {

-            $expectation = new ParametersExpectation(

-                    array("0", 0, new WildcardExpectation(), false));

-            $this->assertTrue($expectation->test(array("0", 0, 37, false)));

-            $this->assertFalse($expectation->test(array("0", 0, 37, true)));

-            $this->assertFalse($expectation->test(array("0", 0, 37)));

-        }

-    }

-    

-    class TestOfCallMap extends UnitTestCase {

-        

-        function testEmpty() {

-            $map = new CallMap();

-            $this->assertFalse($map->isMatch("any", array()));

-            $this->assertNull($map->findFirstMatch("any", array()));

-        }

-        

-        function testExactValue() {

-            $map = new CallMap();

-            $map->addValue(array(0), "Fred");

-            $map->addValue(array(1), "Jim");

-            $map->addValue(array("1"), "Tom");

-            $this->assertTrue($map->isMatch(array(0)));

-            $this->assertEqual($map->findFirstMatch(array(0)), "Fred");

-            $this->assertTrue($map->isMatch(array(1)));

-            $this->assertEqual($map->findFirstMatch(array(1)), "Jim");

-            $this->assertEqual($map->findFirstMatch(array("1")), "Tom");

-        }

-        

-        function testExactReference() {

-            $map = new CallMap();

-            $ref = "Fred";

-            $map->addReference(array(0), $ref);

-            $this->assertEqual($map->findFirstMatch(array(0)), "Fred");

-            $ref2 = &$map->findFirstMatch(array(0));

-            $this->assertReference($ref2, $ref);

-        }

-        

-        function testWildcard() {

-            $map = new CallMap();

-            $map->addValue(array(new WildcardExpectation(), 1, 3), "Fred");

-            $this->assertTrue($map->isMatch(array(2, 1, 3)));

-            $this->assertEqual($map->findFirstMatch(array(2, 1, 3)), "Fred");

-        }

-        

-        function testAllWildcard() {

-            $map = new CallMap();

-            $this->assertFalse($map->isMatch(array(2, 1, 3)));

-            $map->addValue("", "Fred");

-            $this->assertTrue($map->isMatch(array(2, 1, 3)));

-            $this->assertEqual($map->findFirstMatch(array(2, 1, 3)), "Fred");

-        }

-        

-        function testOrdering() {

-            $map = new CallMap();

-            $map->addValue(array(1, 2), "1, 2");

-            $map->addValue(array(1, 3), "1, 3");

-            $map->addValue(array(1), "1");

-            $map->addValue(array(1, 4), "1, 4");

-            $map->addValue(array(new WildcardExpectation()), "Any");

-            $map->addValue(array(2), "2");

-            $map->addValue("", "Default");

-            $map->addValue(array(), "None");

-            $this->assertEqual($map->findFirstMatch(array(1, 2)), "1, 2");

-            $this->assertEqual($map->findFirstMatch(array(1, 3)), "1, 3");

-            $this->assertEqual($map->findFirstMatch(array(1, 4)), "1, 4");

-            $this->assertEqual($map->findFirstMatch(array(1)), "1");

-            $this->assertEqual($map->findFirstMatch(array(2)), "Any");

-            $this->assertEqual($map->findFirstMatch(array(3)), "Any");

-            $this->assertEqual($map->findFirstMatch(array()), "Default");

-        }

-    }

-    

-    class Dummy {

-        function Dummy() {

-        }

-        

-        function aMethod($parameter) {

-            return $parameter;

-        }

-        

-        function anotherMethod() {

-            return true;

-        }

-    }

-    

-    Stub::generate("Dummy");

-    Stub::generate("Dummy", "AnotherStubDummy");

-    Stub::generate("Dummy", "StubDummyWithExtraMethods", array("extraMethod"));

-    

-    class SpecialSimpleStub extends SimpleStub {

-        function SpecialSimpleStub($wildcard) {

-            $this->SimpleStub($wildcard);

-        }

-    }

-    SimpleTestOptions::setStubBaseClass("SpecialSimpleStub");

-    Stub::generate("Dummy", "SpecialStubDummy");

-    SimpleTestOptions::setStubBaseClass("SimpleStub");

-    

-    class TestOfStubGeneration extends UnitTestCase {

-        

-        function testCloning() {

-            $stub = &new StubDummy();

-            $this->assertTrue(method_exists($stub, "aMethod"));

-            $this->assertNull($stub->aMethod());

-        }

-        

-        function testCloningWithExtraMethod() {

-            $stub = &new StubDummyWithExtraMethods();

-            $this->assertTrue(method_exists($stub, "extraMethod"));

-        }

-        

-        function testCloningWithChosenClassName() {

-            $stub = &new AnotherStubDummy();

-            $this->assertTrue(method_exists($stub, "aMethod"));

-        }

-        

-        function testCloningWithDifferentBaseClass() {

-            $stub = &new SpecialStubDummy();

-            $this->assertIsA($stub, "SpecialSimpleStub");

-            $this->assertTrue(method_exists($stub, "aMethod"));

-        }

-    }

-    

-    class TestOfServerStubReturns extends UnitTestCase {

-        

-        function testDefaultReturn() {

-            $stub = &new StubDummy();

-            $stub->setReturnValue("aMethod", "aaa");

-            $this->assertIdentical($stub->aMethod(), "aaa");

-            $this->assertIdentical($stub->aMethod(), "aaa");

-        }

-        

-        function testParameteredReturn() {

-            $stub = &new StubDummy();

-            $stub->setReturnValue("aMethod", "aaa", array(1, 2, 3));

-            $this->assertNull($stub->aMethod());

-            $this->assertIdentical($stub->aMethod(1, 2, 3), "aaa");

-        }

-        

-        function testReferenceReturned() {

-            $stub = &new StubDummy();

-            $object = new Dummy();

-            $stub->setReturnReference("aMethod", $object, array(1, 2, 3));

-            $this->assertReference($stub->aMethod(1, 2, 3), $object);

-        }

-        

-        function testWildcardReturn() {

-            $stub = &new StubDummy("wild");

-            $stub->setReturnValue("aMethod", "aaa", array(1, "wild", 3));

-            $this->assertIdentical($stub->aMethod(1, "something", 3), "aaa");

-            $this->assertIdentical($stub->aMethod(1, "anything", 3), "aaa");

-        }

-        

-        function testAllWildcardReturn() {

-            $stub = &new StubDummy("wild");

-            $stub->setReturnValue("aMethod", "aaa");

-            $this->assertIdentical($stub->aMethod(1, 2, 3), "aaa");

-            $this->assertIdentical($stub->aMethod(), "aaa");

-        }

-        

-        function testCallCount() {

-            $stub = &new StubDummy();

-            $this->assertEqual($stub->getCallCount("aMethod"), 0);

-            $stub->aMethod();

-            $this->assertEqual($stub->getCallCount("aMethod"), 1);

-            $stub->aMethod();

-            $this->assertEqual($stub->getCallCount("aMethod"), 2);

-        }

-        

-        function testMultipleMethods() {

-            $stub = &new StubDummy();

-            $stub->setReturnValue("aMethod", 100, array(1));

-            $stub->setReturnValue("aMethod", 200, array(2));

-            $stub->setReturnValue("anotherMethod", 10, array(1));

-            $stub->setReturnValue("anotherMethod", 20, array(2));

-            $this->assertIdentical($stub->aMethod(1), 100);

-            $this->assertIdentical($stub->anotherMethod(1), 10);

-            $this->assertIdentical($stub->aMethod(2), 200);

-            $this->assertIdentical($stub->anotherMethod(2), 20);

-        }

-        

-        function testReturnSequence() {

-            $stub = &new StubDummy();

-            $stub->setReturnValueAt(0, "aMethod", "aaa");

-            $stub->setReturnValueAt(1, "aMethod", "bbb");

-            $stub->setReturnValueAt(3, "aMethod", "ddd");

-            $this->assertIdentical($stub->aMethod(), "aaa");

-            $this->assertIdentical($stub->aMethod(), "bbb");

-            $this->assertNull($stub->aMethod());

-            $this->assertIdentical($stub->aMethod(), "ddd");

-        }

-        

-        function testReturnReferenceSequence() {

-            $stub = &new StubDummy();

-            $object = new Dummy();

-            $stub->setReturnReferenceAt(1, "aMethod", $object);

-            $this->assertNull($stub->aMethod());

-            $this->assertReference($stub->aMethod(), $object);

-            $this->assertNull($stub->aMethod());

-        }

-        

-        function testComplicatedReturnSequence() {

-            $stub = &new StubDummy("wild");

-            $object = new Dummy();

-            $stub->setReturnValueAt(1, "aMethod", "aaa", array("a"));

-            $stub->setReturnValueAt(1, "aMethod", "bbb");

-            $stub->setReturnReferenceAt(2, "aMethod", $object, array("wild", 2));

-            $stub->setReturnValueAt(2, "aMethod", "value", array("wild", 3));

-            $stub->setReturnValue("aMethod", 3, array(3));

-            $this->assertNull($stub->aMethod());

-            $this->assertEqual($stub->aMethod("a"), "aaa");

-            $this->assertReference($stub->aMethod(1, 2), $object);

-            $this->assertEqual($stub->aMethod(3), 3);

-            $this->assertNull($stub->aMethod());

-        }

-        

-        function testMultipleMethodSequences() {

-            $stub = &new StubDummy();

-            $stub->setReturnValueAt(0, "aMethod", "aaa");

-            $stub->setReturnValueAt(1, "aMethod", "bbb");

-            $stub->setReturnValueAt(0, "anotherMethod", "ccc");

-            $stub->setReturnValueAt(1, "anotherMethod", "ddd");

-            $this->assertIdentical($stub->aMethod(), "aaa");

-            $this->assertIdentical($stub->anotherMethod(), "ccc");

-            $this->assertIdentical($stub->aMethod(), "bbb");

-            $this->assertIdentical($stub->anotherMethod(), "ddd");

-        }

-        

-        function testSequenceFallback() {

-            $stub = &new StubDummy();

-            $stub->setReturnValueAt(0, "aMethod", "aaa", array('a'));

-            $stub->setReturnValueAt(1, "aMethod", "bbb", array('a'));

-            $stub->setReturnValue("aMethod", "AAA");

-            $this->assertIdentical($stub->aMethod('a'), "aaa");

-            $this->assertIdentical($stub->aMethod('b'), "AAA");

-        }

-        

-        function testMethodInterference() {

-            $stub = &new StubDummy();

-            $stub->setReturnValueAt(0, "anotherMethod", "aaa");

-            $stub->setReturnValue("aMethod", "AAA");

-            $this->assertIdentical($stub->aMethod(), "AAA");

-            $this->assertIdentical($stub->anotherMethod(), "aaa");

-        }

-    }

-    

-    Mock::generate("Dummy");

-    Mock::generate("Dummy", "AnotherMockDummy");

-    Mock::generate("Dummy", "MockDummyWithExtraMethods", array("extraMethod"));

-    

-    class SpecialSimpleMock extends SimpleMock {

-        function SpecialSimpleMock(&$test, $wildcard) {

-            $this->SimpleMock($test, $wildcard);

-        }

-    }

-    SimpleTestOptions::setMockBaseClass("SpecialSimpleMock");

-    Mock::generate("Dummy", "SpecialMockDummy");

-    SimpleTestOptions::setMockBaseClass("SimpleMock");

-    

-    class TestOfMockGeneration extends UnitTestCase {

-        

-        function testCloning() {

-            $mock = &new MockDummy($this);

-            $this->assertTrue(method_exists($mock, "aMethod"));

-            $this->assertNull($mock->aMethod());

-        }

-        

-        function testCloningWithExtraMethod() {

-            $mock = &new MockDummyWithExtraMethods($this);

-            $this->assertTrue(method_exists($mock, "extraMethod"));

-        }

-        

-        function testCloningWithChosenClassName() {

-            $mock = &new AnotherMockDummy($this);

-            $this->assertTrue(method_exists($mock, "aMethod"));

-        }

-        

-        function testCloningWithDifferentBaseClass() {

-            $mock = &new SpecialMockDummy($this);

-            $this->assertIsA($mock, "SpecialSimpleMock");

-            $this->assertTrue(method_exists($mock, "aMethod"));

-        }

-    }

-    

-    class TestOfMockReturns extends UnitTestCase {

-        

-        function testNoUnitTesterSetThrowsError() {

-            $mock = &new MockDummy();

-            $this->assertErrorPattern('/missing argument/i');

-            $this->assertErrorPattern('/no unit tester/i');

-        }

-        

-        function testParameteredReturn() {

-            $mock = &new MockDummy($this);

-            $mock->setReturnValue("aMethod", "aaa", array(1, 2, 3));

-            $this->assertNull($mock->aMethod());

-            $this->assertIdentical($mock->aMethod(1, 2, 3), "aaa");

-        }

-        

-        function testReferenceReturned() {

-            $mock = &new MockDummy($this);

-            $object = new Dummy();

-            $mock->setReturnReference("aMethod", $object, array(1, 2, 3));

-            $this->assertReference($mock->aMethod(1, 2, 3), $object);

-        }

-        

-        function testWildcardReturn() {

-            $mock = &new MockDummy($this, "wild");

-            $mock->setReturnValue("aMethod", "aaa", array(1, "wild", 3));

-            $this->assertIdentical($mock->aMethod(1, "something", 3), "aaa");

-            $this->assertIdentical($mock->aMethod(1, "anything", 3), "aaa");

-        }

-        

-        function testPatternMatchReturn() {

-            $mock = &new MockDummy($this);

-            $mock->setReturnValue(

-                    "aMethod",

-                    "aaa",

-                    array(new wantedPatternExpectation('/hello/i')));

-            $this->assertIdentical($mock->aMethod('Hello'), "aaa");

-            $this->assertNull($mock->aMethod('Goodbye'));

-        }

-        

-        function testCallCount() {

-            $mock = &new MockDummy($this);

-            $this->assertEqual($mock->getCallCount("aMethod"), 0);

-            $mock->aMethod();

-            $this->assertEqual($mock->getCallCount("aMethod"), 1);

-            $mock->aMethod();

-            $this->assertEqual($mock->getCallCount("aMethod"), 2);

-        }

-        

-        function testReturnReferenceSequence() {

-            $mock = &new MockDummy($this);

-            $object = new Dummy();

-            $mock->setReturnReferenceAt(1, "aMethod", $object);

-            $this->assertNull($mock->aMethod());

-            $this->assertReference($mock->aMethod(), $object);

-            $this->assertNull($mock->aMethod());

-            $this->swallowErrors();

-        }

-    }

-    

-    Mock::generate("SimpleTestCase");

-    

-    class TestOfMockTally extends UnitTestCase {

-        

-        function testZeroCallCount() {

-            $mock = &new MockDummy($this);

-            $mock->expectCallCount("aMethod", 0);

-            $mock->tally();

-        }

-        

-        function testExpectedCallCount() {

-            $mock = &new MockDummy($this);

-            $mock->expectCallCount("aMethod", 2);

-            $mock->aMethod();

-            $mock->aMethod();

-            $mock->tally();

-        }

-    }

-    

-    class TestOfMockExpectations extends UnitTestCase {

-        var $_test;

-        

-        function TestOfMockExpectations() {

-            $this->UnitTestCase();

-        }

-        

-        function setUp() {

-            $this->_test = &new MockSimpleTestCase($this);

-        }

-        

-        function tearDown() {

-            $this->_test->tally();

-        }

-        

-        function testSettingExpectationOnNonMethodThrowsError() {

-            $mock = &new MockDummy($this);

-            $mock->expectMaximumCallCount("aMissingMethod", 2);

-            $this->assertError();

-        }

-        

-        function testMaxCallsDetectsOverrun() {

-            $this->_test->expectOnce("assertTrue", array(false, '*'));

-            $mock = &new MockDummy($this->_test);

-            $mock->expectMaximumCallCount("aMethod", 2);

-            $mock->aMethod();

-            $mock->aMethod();

-            $mock->aMethod();

-        }

-        

-        function testTallyOnMaxCallsSendsPassOnUnderrun() {

-            $this->_test->expectOnce("assertTrue", array(true, '*'));

-            $mock = &new MockDummy($this->_test);

-            $mock->expectMaximumCallCount("aMethod", 2);

-            $mock->aMethod();

-            $mock->aMethod();

-            $mock->tally();

-        }

-        

-        function testExpectNeverDetectsOverrun() {

-            $this->_test->expectOnce("assertTrue", array(false, '*'));

-            $mock = &new MockDummy($this->_test);

-            $mock->expectNever("aMethod");

-            $mock->aMethod();

-        }

-        

-        function testTallyOnExpectNeverSendsPassOnUnderrun() {

-            $this->_test->expectOnce("assertTrue", array(true, '*'));

-            $mock = &new MockDummy($this->_test);

-            $mock->expectNever("aMethod");

-            $mock->tally();

-        }

-        

-        function testMinCalls() {

-            $this->_test->expectOnce("assertTrue", array(true, '*'));

-            $mock = &new MockDummy($this->_test);

-            $mock->expectMinimumCallCount("aMethod", 2);

-            $mock->aMethod();

-            $mock->aMethod();

-            $mock->tally();

-        }

-        

-        function testFailedNever() {

-            $this->_test->expectOnce("assertTrue", array(false, '*'));

-            $mock = &new MockDummy($this->_test);

-            $mock->expectNever("aMethod");

-            $mock->aMethod();

-        }

-        

-        function testUnderOnce() {

-            $this->_test->expectOnce("assertTrue", array(false, '*'));

-            $mock = &new MockDummy($this->_test);

-            $mock->expectOnce("aMethod");

-            $mock->tally();

-        }

-        

-        function testOverOnce() {

-            $this->_test->expectOnce("assertTrue", array(false, '*'));

-            $mock = &new MockDummy($this->_test);

-            $mock->expectOnce("aMethod");

-            $mock->aMethod();

-            $mock->aMethod();

-            $mock->tally();

-            $this->swallowErrors();

-        }

-        

-        function testUnderAtLeastOnce() {

-            $this->_test->expectOnce("assertTrue", array(false, '*'));

-            $mock = &new MockDummy($this->_test);

-            $mock->expectAtLeastOnce("aMethod");

-            $mock->tally();

-        }

-        

-        function testZeroArguments() {

-            $mock = &new MockDummy($this);

-            $mock->expectArguments("aMethod", array());

-            $mock->aMethod();

-        }

-        

-        function testExpectedArguments() {

-            $mock = &new MockDummy($this);

-            $mock->expectArguments("aMethod", array(1, 2, 3));

-            $mock->aMethod(1, 2, 3);

-        }

-        

-        function testFailedArguments() {

-            $this->_test->expectOnce("assertTrue", array(false, "*"));

-            $mock = &new MockDummy($this->_test);

-            $mock->expectArguments("aMethod", array("this"));

-            $mock->aMethod("that");

-        }

-        

-        function testWildcardArguments() {

-            $mock = &new MockDummy($this, "wild");

-            $mock->expectArguments("aMethod", array("wild", 123, "wild"));

-            $mock->aMethod(100, 123, 101);

-        }

-        

-        function testSpecificSequence() {

-            $mock = &new MockDummy($this);

-            $mock->expectArgumentsAt(1, "aMethod", array(1, 2, 3));

-            $mock->expectArgumentsAt(2, "aMethod", array("Hello"));

-            $mock->aMethod();

-            $mock->aMethod(1, 2, 3);

-            $mock->aMethod("Hello");

-            $mock->aMethod();

-        }

-        

-        function testFailedSequence() {

-            $this->_test->expectArguments("assertTrue", array(false, "*"));

-            $this->_test->expectCallCount("assertTrue", 2);

-            $mock = &new MockDummy($this->_test);

-            $mock->expectArgumentsAt(0, "aMethod", array(1, 2, 3));

-            $mock->expectArgumentsAt(1, "aMethod", array("Hello"));

-            $mock->aMethod(1, 2);

-            $mock->aMethod("Goodbye");

-        }

-        

-        function testBadArgParameter() {

-            $mock = &new MockDummy($this);

-            $mock->expectArguments("aMethod", "foo");

-            $this->assertErrorPattern('/\$args.*not an array/i');

-            $mock->aMethod();

-            $mock->tally();

-       }

-    }

-    

-    class TestOfMockComparisons extends UnitTestCase {

-        

-        function testTestCaseRegistry() {

-            $test = &new MockSimpleTestCase($this);

-            $class = SimpleMock::registerTest($test);

-            $this->assertReference($test, SimpleMock::injectTest($class));

-        }

-        

-        function testEqualComparisonOfMocksDoesNotCrash() {

-            $expectation = &new EqualExpectation(new MockDummy($this));

-            $this->assertTrue($expectation->test(new MockDummy($this), true));

-        }

-        

-        function testIdenticalComparisonOfMocksDoesNotCrash() {

-            $expectation = &new IdenticalExpectation(new MockDummy($this));

-            $this->assertTrue($expectation->test(new MockDummy($this)));

-        }

-    }

-    

-    SimpleTestOptions::addPartialMockCode('function sayHello() { return "Hello"; }');

-    Mock::generatePartial("Dummy", "TestDummy", array("anotherMethod"));

-    SimpleTestOptions::addPartialMockCode();

-    

-    class TestOfPartialMocks extends UnitTestCase {

-        

-        function testMethodReplacement() {

-            $mock = &new TestDummy($this);

-            $this->assertEqual($mock->aMethod(99), 99);

-            $this->assertNull($mock->anotherMethod());

-        }

-        

-        function testSettingReturns() {

-            $mock = &new TestDummy($this);

-            $mock->setReturnValue("anotherMethod", 33, array(3));

-            $mock->setReturnValue("anotherMethod", 22);

-            $mock->setReturnValueAt(2, "anotherMethod", 44, array(3));

-            $this->assertEqual($mock->anotherMethod(), 22);

-            $this->assertEqual($mock->anotherMethod(3), 33);

-            $this->assertEqual($mock->anotherMethod(3), 44);

-        }

-        

-        function testReferences() {

-            $mock = &new TestDummy($this);

-            $object = new Dummy();

-            $mock->setReturnReferenceAt(0, "anotherMethod", $object, array(3));

-            $this->assertReference($mock->anotherMethod(3), $object);

-        }

-        

-        function testExpectations() {

-            $mock = &new TestDummy($this);

-            $mock->expectCallCount("anotherMethod", 2);

-            $mock->expectArguments("anotherMethod", array(77));

-            $mock->expectArgumentsAt(1, "anotherMethod", array(66));

-            $mock->anotherMethod(77);

-            $mock->anotherMethod(66);

-            $mock->tally();

-        }

-        

-        function testAdditionalPartialMockCode() {

-            $dummy = &new TestDummy($this);

-            $this->assertEqual($dummy->sayHello(), 'Hello');

-        }

-        

-        function testSettingExpectationOnMissingMethodThrowsError() {

-            $mock = &new TestDummy($this);

-            $mock->expectCallCount("aMissingMethod", 2);

-            $this->assertError();

-        }

-    }

-?>
\ No newline at end of file