648 lines
25 KiB
PHP
648 lines
25 KiB
PHP
<?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();
|
|
}
|
|
}
|
|
?>
|