You are here

Home » API reference » Zircon Profile 8 » MockObjectTest.php

class Framework_MockObjectTest in Zircon Profile 8

Same name and namespace in other branches
  1. 8.0 vendor/phpunit/phpunit-mock-objects/tests/MockObjectTest.php \Framework_MockObjectTest

@since Class available since Release 3.0.0

Hierarchy

Expanded class hierarchy of Framework_MockObjectTest

File

vendor/phpunit/phpunit-mock-objects/tests/MockObjectTest.php, line 16

View source 
class Framework_MockObjectTest extends PHPUnit_Framework_TestCase {
  public function testMockedMethodIsNeverCalled() {
    $mock = $this
      ->getMock('AnInterface');
    $mock
      ->expects($this
      ->never())
      ->method('doSomething');
  }
  public function testMockedMethodIsNeverCalledWithParameter() {
    $mock = $this
      ->getMock('SomeClass');
    $mock
      ->expects($this
      ->never())
      ->method('doSomething')
      ->with('someArg');
  }
  public function testMockedMethodIsNotCalledWhenExpectsAnyWithParameter() {
    $mock = $this
      ->getMock('SomeClass');
    $mock
      ->expects($this
      ->any())
      ->method('doSomethingElse')
      ->with('someArg');
  }
  public function testMockedMethodIsNotCalledWhenMethodSpecifiedDirectlyWithParameter() {
    $mock = $this
      ->getMock('SomeClass');
    $mock
      ->method('doSomethingElse')
      ->with('someArg');
  }
  public function testMockedMethodIsCalledAtLeastOnce() {
    $mock = $this
      ->getMock('AnInterface');
    $mock
      ->expects($this
      ->atLeastOnce())
      ->method('doSomething');
    $mock
      ->doSomething();
  }
  public function testMockedMethodIsCalledAtLeastOnce2() {
    $mock = $this
      ->getMock('AnInterface');
    $mock
      ->expects($this
      ->atLeastOnce())
      ->method('doSomething');
    $mock
      ->doSomething();
    $mock
      ->doSomething();
  }
  public function testMockedMethodIsCalledAtLeastTwice() {
    $mock = $this
      ->getMock('AnInterface');
    $mock
      ->expects($this
      ->atLeast(2))
      ->method('doSomething');
    $mock
      ->doSomething();
    $mock
      ->doSomething();
  }
  public function testMockedMethodIsCalledAtLeastTwice2() {
    $mock = $this
      ->getMock('AnInterface');
    $mock
      ->expects($this
      ->atLeast(2))
      ->method('doSomething');
    $mock
      ->doSomething();
    $mock
      ->doSomething();
    $mock
      ->doSomething();
  }
  public function testMockedMethodIsCalledAtMostTwice() {
    $mock = $this
      ->getMock('AnInterface');
    $mock
      ->expects($this
      ->atMost(2))
      ->method('doSomething');
    $mock
      ->doSomething();
    $mock
      ->doSomething();
  }
  public function testMockedMethodIsCalledAtMosttTwice2() {
    $mock = $this
      ->getMock('AnInterface');
    $mock
      ->expects($this
      ->atMost(2))
      ->method('doSomething');
    $mock
      ->doSomething();
  }
  public function testMockedMethodIsCalledOnce() {
    $mock = $this
      ->getMock('AnInterface');
    $mock
      ->expects($this
      ->once())
      ->method('doSomething');
    $mock
      ->doSomething();
  }
  public function testMockedMethodIsCalledOnceWithParameter() {
    $mock = $this
      ->getMock('SomeClass');
    $mock
      ->expects($this
      ->once())
      ->method('doSomethingElse')
      ->with($this
      ->equalTo('something'));
    $mock
      ->doSomethingElse('something');
  }
  public function testMockedMethodIsCalledExactly() {
    $mock = $this
      ->getMock('AnInterface');
    $mock
      ->expects($this
      ->exactly(2))
      ->method('doSomething');
    $mock
      ->doSomething();
    $mock
      ->doSomething();
  }
  public function testStubbedException() {
    $mock = $this
      ->getMock('AnInterface');
    $mock
      ->expects($this
      ->any())
      ->method('doSomething')
      ->will($this
      ->throwException(new Exception()));
    try {
      $mock
        ->doSomething();
    } catch (Exception $e) {
      return;
    }
    $this
      ->fail();
  }
  public function testStubbedWillThrowException() {
    $mock = $this
      ->getMock('AnInterface');
    $mock
      ->expects($this
      ->any())
      ->method('doSomething')
      ->willThrowException(new Exception());
    try {
      $mock
        ->doSomething();
    } catch (Exception $e) {
      return;
    }
    $this
      ->fail();
  }
  public function testStubbedReturnValue() {
    $mock = $this
      ->getMock('AnInterface');
    $mock
      ->expects($this
      ->any())
      ->method('doSomething')
      ->will($this
      ->returnValue('something'));
    $this
      ->assertEquals('something', $mock
      ->doSomething());
    $mock = $this
      ->getMock('AnInterface');
    $mock
      ->expects($this
      ->any())
      ->method('doSomething')
      ->willReturn('something');
    $this
      ->assertEquals('something', $mock
      ->doSomething());
  }
  public function testStubbedReturnValueMap() {
    $map = array(
      array(
        'a',
        'b',
        'c',
        'd',
      ),
      array(
        'e',
        'f',
        'g',
        'h',
      ),
    );
    $mock = $this
      ->getMock('AnInterface');
    $mock
      ->expects($this
      ->any())
      ->method('doSomething')
      ->will($this
      ->returnValueMap($map));
    $this
      ->assertEquals('d', $mock
      ->doSomething('a', 'b', 'c'));
    $this
      ->assertEquals('h', $mock
      ->doSomething('e', 'f', 'g'));
    $this
      ->assertEquals(null, $mock
      ->doSomething('foo', 'bar'));
    $mock = $this
      ->getMock('AnInterface');
    $mock
      ->expects($this
      ->any())
      ->method('doSomething')
      ->willReturnMap($map);
    $this
      ->assertEquals('d', $mock
      ->doSomething('a', 'b', 'c'));
    $this
      ->assertEquals('h', $mock
      ->doSomething('e', 'f', 'g'));
    $this
      ->assertEquals(null, $mock
      ->doSomething('foo', 'bar'));
  }
  public function testStubbedReturnArgument() {
    $mock = $this
      ->getMock('AnInterface');
    $mock
      ->expects($this
      ->any())
      ->method('doSomething')
      ->will($this
      ->returnArgument(1));
    $this
      ->assertEquals('b', $mock
      ->doSomething('a', 'b'));
    $mock = $this
      ->getMock('AnInterface');
    $mock
      ->expects($this
      ->any())
      ->method('doSomething')
      ->willReturnArgument(1);
    $this
      ->assertEquals('b', $mock
      ->doSomething('a', 'b'));
  }
  public function testFunctionCallback() {
    $mock = $this
      ->getMock('SomeClass', array(
      'doSomething',
    ), array(), '', false);
    $mock
      ->expects($this
      ->once())
      ->method('doSomething')
      ->will($this
      ->returnCallback('functionCallback'));
    $this
      ->assertEquals('pass', $mock
      ->doSomething('foo', 'bar'));
    $mock = $this
      ->getMock('SomeClass', array(
      'doSomething',
    ), array(), '', false);
    $mock
      ->expects($this
      ->once())
      ->method('doSomething')
      ->willReturnCallback('functionCallback');
    $this
      ->assertEquals('pass', $mock
      ->doSomething('foo', 'bar'));
  }
  public function testStubbedReturnSelf() {
    $mock = $this
      ->getMock('AnInterface');
    $mock
      ->expects($this
      ->any())
      ->method('doSomething')
      ->will($this
      ->returnSelf());
    $this
      ->assertEquals($mock, $mock
      ->doSomething());
    $mock = $this
      ->getMock('AnInterface');
    $mock
      ->expects($this
      ->any())
      ->method('doSomething')
      ->willReturnSelf();
    $this
      ->assertEquals($mock, $mock
      ->doSomething());
  }
  public function testStubbedReturnOnConsecutiveCalls() {
    $mock = $this
      ->getMock('AnInterface');
    $mock
      ->expects($this
      ->any())
      ->method('doSomething')
      ->will($this
      ->onConsecutiveCalls('a', 'b', 'c'));
    $this
      ->assertEquals('a', $mock
      ->doSomething());
    $this
      ->assertEquals('b', $mock
      ->doSomething());
    $this
      ->assertEquals('c', $mock
      ->doSomething());
    $mock = $this
      ->getMock('AnInterface');
    $mock
      ->expects($this
      ->any())
      ->method('doSomething')
      ->willReturnOnConsecutiveCalls('a', 'b', 'c');
    $this
      ->assertEquals('a', $mock
      ->doSomething());
    $this
      ->assertEquals('b', $mock
      ->doSomething());
    $this
      ->assertEquals('c', $mock
      ->doSomething());
  }
  public function testStaticMethodCallback() {
    $mock = $this
      ->getMock('SomeClass', array(
      'doSomething',
    ), array(), '', false);
    $mock
      ->expects($this
      ->once())
      ->method('doSomething')
      ->will($this
      ->returnCallback(array(
      'MethodCallback',
      'staticCallback',
    )));
    $this
      ->assertEquals('pass', $mock
      ->doSomething('foo', 'bar'));
  }
  public function testPublicMethodCallback() {
    $mock = $this
      ->getMock('SomeClass', array(
      'doSomething',
    ), array(), '', false);
    $mock
      ->expects($this
      ->once())
      ->method('doSomething')
      ->will($this
      ->returnCallback(array(
      new MethodCallback(),
      'nonStaticCallback',
    )));
    $this
      ->assertEquals('pass', $mock
      ->doSomething('foo', 'bar'));
  }
  public function testMockClassOnlyGeneratedOnce() {
    $mock1 = $this
      ->getMock('AnInterface');
    $mock2 = $this
      ->getMock('AnInterface');
    $this
      ->assertEquals(get_class($mock1), get_class($mock2));
  }
  public function testMockClassDifferentForPartialMocks() {
    $mock1 = $this
      ->getMock('PartialMockTestClass');
    $mock2 = $this
      ->getMock('PartialMockTestClass', array(
      'doSomething',
    ));
    $mock3 = $this
      ->getMock('PartialMockTestClass', array(
      'doSomething',
    ));
    $mock4 = $this
      ->getMock('PartialMockTestClass', array(
      'doAnotherThing',
    ));
    $mock5 = $this
      ->getMock('PartialMockTestClass', array(
      'doAnotherThing',
    ));
    $this
      ->assertNotEquals(get_class($mock1), get_class($mock2));
    $this
      ->assertNotEquals(get_class($mock1), get_class($mock3));
    $this
      ->assertNotEquals(get_class($mock1), get_class($mock4));
    $this
      ->assertNotEquals(get_class($mock1), get_class($mock5));
    $this
      ->assertEquals(get_class($mock2), get_class($mock3));
    $this
      ->assertNotEquals(get_class($mock2), get_class($mock4));
    $this
      ->assertNotEquals(get_class($mock2), get_class($mock5));
    $this
      ->assertEquals(get_class($mock4), get_class($mock5));
  }
  public function testMockClassStoreOverrulable() {
    $mock1 = $this
      ->getMock('PartialMockTestClass');
    $mock2 = $this
      ->getMock('PartialMockTestClass', array(), array(), 'MyMockClassNameForPartialMockTestClass1');
    $mock3 = $this
      ->getMock('PartialMockTestClass');
    $mock4 = $this
      ->getMock('PartialMockTestClass', array(
      'doSomething',
    ), array(), 'AnotherMockClassNameForPartialMockTestClass');
    $mock5 = $this
      ->getMock('PartialMockTestClass', array(), array(), 'MyMockClassNameForPartialMockTestClass2');
    $this
      ->assertNotEquals(get_class($mock1), get_class($mock2));
    $this
      ->assertEquals(get_class($mock1), get_class($mock3));
    $this
      ->assertNotEquals(get_class($mock1), get_class($mock4));
    $this
      ->assertNotEquals(get_class($mock2), get_class($mock3));
    $this
      ->assertNotEquals(get_class($mock2), get_class($mock4));
    $this
      ->assertNotEquals(get_class($mock2), get_class($mock5));
    $this
      ->assertNotEquals(get_class($mock3), get_class($mock4));
    $this
      ->assertNotEquals(get_class($mock3), get_class($mock5));
    $this
      ->assertNotEquals(get_class($mock4), get_class($mock5));
  }

  /**
   * @covers PHPUnit_Framework_MockObject_Generator::getMock
   */
  public function testGetMockWithFixedClassNameCanProduceTheSameMockTwice() {
    $mock = $this
      ->getMockBuilder('StdClass')
      ->setMockClassName('FixedName')
      ->getMock();
    $mock = $this
      ->getMockBuilder('StdClass')
      ->setMockClassName('FixedName')
      ->getMock();
    $this
      ->assertInstanceOf('StdClass', $mock);
  }
  public function testOriginalConstructorSettingConsidered() {
    $mock1 = $this
      ->getMock('PartialMockTestClass');
    $mock2 = $this
      ->getMock('PartialMockTestClass', array(), array(), '', false);
    $this
      ->assertTrue($mock1->constructorCalled);
    $this
      ->assertFalse($mock2->constructorCalled);
  }
  public function testOriginalCloneSettingConsidered() {
    $mock1 = $this
      ->getMock('PartialMockTestClass');
    $mock2 = $this
      ->getMock('PartialMockTestClass', array(), array(), '', true, false);
    $this
      ->assertNotEquals(get_class($mock1), get_class($mock2));
  }
  public function testGetMockForAbstractClass() {
    $mock = $this
      ->getMock('AbstractMockTestClass');
    $mock
      ->expects($this
      ->never())
      ->method('doSomething');
  }
  public function traversableProvider() {
    return array(
      array(
        'Traversable',
      ),
      array(
        '\\Traversable',
      ),
      array(
        'TraversableMockTestInterface',
      ),
      array(
        array(
          'Traversable',
        ),
      ),
      array(
        array(
          'Iterator',
          'Traversable',
        ),
      ),
      array(
        array(
          '\\Iterator',
          '\\Traversable',
        ),
      ),
    );
  }

  /**
   * @dataProvider traversableProvider
   */
  public function testGetMockForTraversable($type) {
    $mock = $this
      ->getMock($type);
    $this
      ->assertInstanceOf('Traversable', $mock);
  }
  public function testMultipleInterfacesCanBeMockedInSingleObject() {
    $mock = $this
      ->getMock(array(
      'AnInterface',
      'AnotherInterface',
    ));
    $this
      ->assertInstanceOf('AnInterface', $mock);
    $this
      ->assertInstanceOf('AnotherInterface', $mock);
  }

  /**
   * @requires PHP 5.4.0
   */
  public function testGetMockForTrait() {
    $mock = $this
      ->getMockForTrait('AbstractTrait');
    $mock
      ->expects($this
      ->never())
      ->method('doSomething');
    $parent = get_parent_class($mock);
    $traits = class_uses($parent, false);
    $this
      ->assertContains('AbstractTrait', $traits);
  }
  public function testClonedMockObjectShouldStillEqualTheOriginal() {
    $a = $this
      ->getMock('stdClass');
    $b = clone $a;
    $this
      ->assertEquals($a, $b);
  }
  public function testMockObjectsConstructedIndepentantlyShouldBeEqual() {
    $a = $this
      ->getMock('stdClass');
    $b = $this
      ->getMock('stdClass');
    $this
      ->assertEquals($a, $b);
  }
  public function testMockObjectsConstructedIndepentantlyShouldNotBeTheSame() {
    $a = $this
      ->getMock('stdClass');
    $b = $this
      ->getMock('stdClass');
    $this
      ->assertNotSame($a, $b);
  }
  public function testClonedMockObjectCanBeUsedInPlaceOfOriginalOne() {
    $x = $this
      ->getMock('stdClass');
    $y = clone $x;
    $mock = $this
      ->getMock('stdClass', array(
      'foo',
    ));
    $mock
      ->expects($this
      ->once())
      ->method('foo')
      ->with($this
      ->equalTo($x));
    $mock
      ->foo($y);
  }
  public function testClonedMockObjectIsNotIdenticalToOriginalOne() {
    $x = $this
      ->getMock('stdClass');
    $y = clone $x;
    $mock = $this
      ->getMock('stdClass', array(
      'foo',
    ));
    $mock
      ->expects($this
      ->once())
      ->method('foo')
      ->with($this
      ->logicalNot($this
      ->identicalTo($x)));
    $mock
      ->foo($y);
  }
  public function testObjectMethodCallWithArgumentCloningEnabled() {
    $expectedObject = new StdClass();
    $mock = $this
      ->getMockBuilder('SomeClass')
      ->setMethods(array(
      'doSomethingElse',
    ))
      ->enableArgumentCloning()
      ->getMock();
    $actualArguments = array();
    $mock
      ->expects($this
      ->any())
      ->method('doSomethingElse')
      ->will($this
      ->returnCallback(function () use (&$actualArguments) {
      $actualArguments = func_get_args();
    }));
    $mock
      ->doSomethingElse($expectedObject);
    $this
      ->assertEquals(1, count($actualArguments));
    $this
      ->assertEquals($expectedObject, $actualArguments[0]);
    $this
      ->assertNotSame($expectedObject, $actualArguments[0]);
  }
  public function testObjectMethodCallWithArgumentCloningDisabled() {
    $expectedObject = new StdClass();
    $mock = $this
      ->getMockBuilder('SomeClass')
      ->setMethods(array(
      'doSomethingElse',
    ))
      ->disableArgumentCloning()
      ->getMock();
    $actualArguments = array();
    $mock
      ->expects($this
      ->any())
      ->method('doSomethingElse')
      ->will($this
      ->returnCallback(function () use (&$actualArguments) {
      $actualArguments = func_get_args();
    }));
    $mock
      ->doSomethingElse($expectedObject);
    $this
      ->assertEquals(1, count($actualArguments));
    $this
      ->assertSame($expectedObject, $actualArguments[0]);
  }
  public function testArgumentCloningOptionGeneratesUniqueMock() {
    $mockWithCloning = $this
      ->getMockBuilder('SomeClass')
      ->setMethods(array(
      'doSomethingElse',
    ))
      ->enableArgumentCloning()
      ->getMock();
    $mockWithoutCloning = $this
      ->getMockBuilder('SomeClass')
      ->setMethods(array(
      'doSomethingElse',
    ))
      ->disableArgumentCloning()
      ->getMock();
    $this
      ->assertNotEquals($mockWithCloning, $mockWithoutCloning);
  }
  public function testVerificationOfMethodNameFailsWithoutParameters() {
    $mock = $this
      ->getMock('SomeClass', array(
      'right',
      'wrong',
    ), array(), '', true, true, true);
    $mock
      ->expects($this
      ->once())
      ->method('right');
    $mock
      ->wrong();
    try {
      $mock
        ->__phpunit_verify();
      $this
        ->fail('Expected exception');
    } catch (PHPUnit_Framework_ExpectationFailedException $e) {
      $this
        ->assertSame("Expectation failed for method name is equal to <string:right> when invoked 1 time(s).\n" . "Method was expected to be called 1 times, actually called 0 times.\n", $e
        ->getMessage());
    }
    $this
      ->resetMockObjects();
  }
  public function testVerificationOfMethodNameFailsWithParameters() {
    $mock = $this
      ->getMock('SomeClass', array(
      'right',
      'wrong',
    ), array(), '', true, true, true);
    $mock
      ->expects($this
      ->once())
      ->method('right');
    $mock
      ->wrong();
    try {
      $mock
        ->__phpunit_verify();
      $this
        ->fail('Expected exception');
    } catch (PHPUnit_Framework_ExpectationFailedException $e) {
      $this
        ->assertSame("Expectation failed for method name is equal to <string:right> when invoked 1 time(s).\n" . "Method was expected to be called 1 times, actually called 0 times.\n", $e
        ->getMessage());
    }
    $this
      ->resetMockObjects();
  }
  public function testVerificationOfMethodNameFailsWithWrongParameters() {
    $mock = $this
      ->getMock('SomeClass', array(
      'right',
      'wrong',
    ), array(), '', true, true, true);
    $mock
      ->expects($this
      ->once())
      ->method('right')
      ->with(array(
      'first',
      'second',
    ));
    try {
      $mock
        ->right(array(
        'second',
      ));
    } catch (PHPUnit_Framework_ExpectationFailedException $e) {
      $this
        ->assertSame("Expectation failed for method name is equal to <string:right> when invoked 1 time(s)\n" . "Parameter 0 for invocation SomeClass::right(Array (...)) does not match expected value.\n" . "Failed asserting that two arrays are equal.", $e
        ->getMessage());
    }
    try {
      $mock
        ->__phpunit_verify();
      $this
        ->fail('Expected exception');
    } catch (PHPUnit_Framework_ExpectationFailedException $e) {
      $this
        ->assertSame("Expectation failed for method name is equal to <string:right> when invoked 1 time(s).\n" . "Parameter 0 for invocation SomeClass::right(Array (...)) does not match expected value.\n" . "Failed asserting that two arrays are equal.\n" . "--- Expected\n" . "+++ Actual\n" . "@@ @@\n" . " Array (\n" . "-    0 => 'first'\n" . "-    1 => 'second'\n" . "+    0 => 'second'\n" . " )\n", $e
        ->getMessage());
    }
    $this
      ->resetMockObjects();
  }
  public function testVerificationOfNeverFailsWithEmptyParameters() {
    $mock = $this
      ->getMock('SomeClass', array(
      'right',
      'wrong',
    ), array(), '', true, true, true);
    $mock
      ->expects($this
      ->never())
      ->method('right')
      ->with();
    try {
      $mock
        ->right();
      $this
        ->fail('Expected exception');
    } catch (PHPUnit_Framework_ExpectationFailedException $e) {
      $this
        ->assertSame('SomeClass::right() was not expected to be called.', $e
        ->getMessage());
    }
    $this
      ->resetMockObjects();
  }
  public function testVerificationOfNeverFailsWithAnyParameters() {
    $mock = $this
      ->getMock('SomeClass', array(
      'right',
      'wrong',
    ), array(), '', true, true, true);
    $mock
      ->expects($this
      ->never())
      ->method('right')
      ->withAnyParameters();
    try {
      $mock
        ->right();
      $this
        ->fail('Expected exception');
    } catch (PHPUnit_Framework_ExpectationFailedException $e) {
      $this
        ->assertSame('SomeClass::right() was not expected to be called.', $e
        ->getMessage());
    }
    $this
      ->resetMockObjects();
  }

  /**
   * @ticket 199
   */
  public function testWithAnythingInsteadOfWithAnyParameters() {
    $mock = $this
      ->getMock('SomeClass', array(
      'right',
    ), array(), '', true, true, true);
    $mock
      ->expects($this
      ->once())
      ->method('right')
      ->with($this
      ->anything());
    try {
      $mock
        ->right();
      $this
        ->fail('Expected exception');
    } catch (PHPUnit_Framework_ExpectationFailedException $e) {
      $this
        ->assertSame("Expectation failed for method name is equal to <string:right> when invoked 1 time(s)\n" . "Parameter count for invocation SomeClass::right() is too low.\n" . "To allow 0 or more parameters with any value, omit ->with() or use ->withAnyParameters() instead.", $e
        ->getMessage());
    }
    $this
      ->resetMockObjects();
  }

  /**
   * See https://github.com/sebastianbergmann/phpunit-mock-objects/issues/81
   */
  public function testMockArgumentsPassedByReference() {
    $foo = $this
      ->getMockBuilder('MethodCallbackByReference')
      ->setMethods(array(
      'bar',
    ))
      ->disableOriginalConstructor()
      ->disableArgumentCloning()
      ->getMock();
    $foo
      ->expects($this
      ->any())
      ->method('bar')
      ->will($this
      ->returnCallback(array(
      $foo,
      'callback',
    )));
    $a = $b = $c = 0;
    $foo
      ->bar($a, $b, $c);
    $this
      ->assertEquals(1, $b);
  }

  /**
   * See https://github.com/sebastianbergmann/phpunit-mock-objects/issues/81
   */
  public function testMockArgumentsPassedByReference2() {
    $foo = $this
      ->getMockBuilder('MethodCallbackByReference')
      ->disableOriginalConstructor()
      ->disableArgumentCloning()
      ->getMock();
    $foo
      ->expects($this
      ->any())
      ->method('bar')
      ->will($this
      ->returnCallback(function (&$a, &$b, $c) {
      $b = 1;
    }));
    $a = $b = $c = 0;
    $foo
      ->bar($a, $b, $c);
    $this
      ->assertEquals(1, $b);
  }

  /**
   * https://github.com/sebastianbergmann/phpunit-mock-objects/issues/116
   */
  public function testMockArgumentsPassedByReference3() {
    $foo = $this
      ->getMockBuilder('MethodCallbackByReference')
      ->setMethods(array(
      'bar',
    ))
      ->disableOriginalConstructor()
      ->disableArgumentCloning()
      ->getMock();
    $a = new stdClass();
    $b = $c = 0;
    $foo
      ->expects($this
      ->any())
      ->method('bar')
      ->with($a, $b, $c)
      ->will($this
      ->returnCallback(array(
      $foo,
      'callback',
    )));
    $foo
      ->bar($a, $b, $c);
  }

  /**
   * https://github.com/sebastianbergmann/phpunit/issues/796
   */
  public function testMockArgumentsPassedByReference4() {
    $foo = $this
      ->getMockBuilder('MethodCallbackByReference')
      ->setMethods(array(
      'bar',
    ))
      ->disableOriginalConstructor()
      ->disableArgumentCloning()
      ->getMock();
    $a = new stdClass();
    $b = $c = 0;
    $foo
      ->expects($this
      ->any())
      ->method('bar')
      ->with($this
      ->isInstanceOf("stdClass"), $b, $c)
      ->will($this
      ->returnCallback(array(
      $foo,
      'callback',
    )));
    $foo
      ->bar($a, $b, $c);
  }

  /**
   * @requires extension soap
   */
  public function testCreateMockFromWsdl() {
    $mock = $this
      ->getMockFromWsdl(__DIR__ . '/_fixture/GoogleSearch.wsdl', 'WsdlMock');
    $this
      ->assertStringStartsWith('Mock_WsdlMock_', get_class($mock));
  }

  /**
   * @requires extension soap
   */
  public function testCreateNamespacedMockFromWsdl() {
    $mock = $this
      ->getMockFromWsdl(__DIR__ . '/_fixture/GoogleSearch.wsdl', 'My\\Space\\WsdlMock');
    $this
      ->assertStringStartsWith('Mock_WsdlMock_', get_class($mock));
  }

  /**
   * @requires extension soap
   */
  public function testCreateTwoMocksOfOneWsdlFile() {
    $mock = $this
      ->getMockFromWsdl(__DIR__ . '/_fixture/GoogleSearch.wsdl');
    $mock = $this
      ->getMockFromWsdl(__DIR__ . '/_fixture/GoogleSearch.wsdl');
  }

  /**
   * @see    https://github.com/sebastianbergmann/phpunit-mock-objects/issues/156
   * @ticket 156
   */
  public function testInterfaceWithStaticMethodCanBeStubbed() {
    $this
      ->assertInstanceOf('InterfaceWithStaticMethod', $this
      ->getMock('InterfaceWithStaticMethod'));
  }

  /**
   * @expectedException PHPUnit_Framework_MockObject_BadMethodCallException
   */
  public function testInvokingStubbedStaticMethodRaisesException() {
    $mock = $this
      ->getMock('ClassWithStaticMethod');
    $mock
      ->staticMethod();
  }

  /**
   * @see    https://github.com/sebastianbergmann/phpunit-mock-objects/issues/171
   * @ticket 171
   */
  public function testStubForClassThatImplementsSerializableCanBeCreatedWithoutInvokingTheConstructor() {
    $this
      ->assertInstanceOf('ClassThatImplementsSerializable', $this
      ->getMockBuilder('ClassThatImplementsSerializable')
      ->disableOriginalConstructor()
      ->getMock());
  }
  private function resetMockObjects() {
    $refl = new ReflectionObject($this);
    $refl = $refl
      ->getParentClass();
    $prop = $refl
      ->getProperty('mockObjects');
    $prop
      ->setAccessible(true);
    $prop
      ->setValue($this, array());
  }

}

Members

Namesort descending Modifiers Type Description Overrides
Framework_MockObjectTest::resetMockObjects private function
Framework_MockObjectTest::testArgumentCloningOptionGeneratesUniqueMock public function
Framework_MockObjectTest::testClonedMockObjectCanBeUsedInPlaceOfOriginalOne public function
Framework_MockObjectTest::testClonedMockObjectIsNotIdenticalToOriginalOne public function
Framework_MockObjectTest::testClonedMockObjectShouldStillEqualTheOriginal public function
Framework_MockObjectTest::testCreateMockFromWsdl public function @requires extension soap
Framework_MockObjectTest::testCreateNamespacedMockFromWsdl public function @requires extension soap
Framework_MockObjectTest::testCreateTwoMocksOfOneWsdlFile public function @requires extension soap
Framework_MockObjectTest::testFunctionCallback public function
Framework_MockObjectTest::testGetMockForAbstractClass public function
Framework_MockObjectTest::testGetMockForTrait public function @requires PHP 5.4.0
Framework_MockObjectTest::testGetMockForTraversable public function @dataProvider traversableProvider
Framework_MockObjectTest::testGetMockWithFixedClassNameCanProduceTheSameMockTwice public function @covers PHPUnit_Framework_MockObject_Generator::getMock
Framework_MockObjectTest::testInterfaceWithStaticMethodCanBeStubbed public function @ticket 156
Framework_MockObjectTest::testInvokingStubbedStaticMethodRaisesException public function @expectedException PHPUnit_Framework_MockObject_BadMethodCallException
Framework_MockObjectTest::testMockArgumentsPassedByReference public function See https://github.com/sebastianbergmann/phpunit-mock-objects/issues/81
Framework_MockObjectTest::testMockArgumentsPassedByReference2 public function See https://github.com/sebastianbergmann/phpunit-mock-objects/issues/81
Framework_MockObjectTest::testMockArgumentsPassedByReference3 public function https://github.com/sebastianbergmann/phpunit-mock-objects/issues/116
Framework_MockObjectTest::testMockArgumentsPassedByReference4 public function https://github.com/sebastianbergmann/phpunit/issues/796
Framework_MockObjectTest::testMockClassDifferentForPartialMocks public function
Framework_MockObjectTest::testMockClassOnlyGeneratedOnce public function
Framework_MockObjectTest::testMockClassStoreOverrulable public function
Framework_MockObjectTest::testMockedMethodIsCalledAtLeastOnce public function
Framework_MockObjectTest::testMockedMethodIsCalledAtLeastOnce2 public function
Framework_MockObjectTest::testMockedMethodIsCalledAtLeastTwice public function
Framework_MockObjectTest::testMockedMethodIsCalledAtLeastTwice2 public function
Framework_MockObjectTest::testMockedMethodIsCalledAtMosttTwice2 public function
Framework_MockObjectTest::testMockedMethodIsCalledAtMostTwice public function
Framework_MockObjectTest::testMockedMethodIsCalledExactly public function
Framework_MockObjectTest::testMockedMethodIsCalledOnce public function
Framework_MockObjectTest::testMockedMethodIsCalledOnceWithParameter public function
Framework_MockObjectTest::testMockedMethodIsNeverCalled public function
Framework_MockObjectTest::testMockedMethodIsNeverCalledWithParameter public function
Framework_MockObjectTest::testMockedMethodIsNotCalledWhenExpectsAnyWithParameter public function
Framework_MockObjectTest::testMockedMethodIsNotCalledWhenMethodSpecifiedDirectlyWithParameter public function
Framework_MockObjectTest::testMockObjectsConstructedIndepentantlyShouldBeEqual public function
Framework_MockObjectTest::testMockObjectsConstructedIndepentantlyShouldNotBeTheSame public function
Framework_MockObjectTest::testMultipleInterfacesCanBeMockedInSingleObject public function
Framework_MockObjectTest::testObjectMethodCallWithArgumentCloningDisabled public function
Framework_MockObjectTest::testObjectMethodCallWithArgumentCloningEnabled public function
Framework_MockObjectTest::testOriginalCloneSettingConsidered public function
Framework_MockObjectTest::testOriginalConstructorSettingConsidered public function
Framework_MockObjectTest::testPublicMethodCallback public function
Framework_MockObjectTest::testStaticMethodCallback public function
Framework_MockObjectTest::testStubbedException public function
Framework_MockObjectTest::testStubbedReturnArgument public function
Framework_MockObjectTest::testStubbedReturnOnConsecutiveCalls public function
Framework_MockObjectTest::testStubbedReturnSelf public function
Framework_MockObjectTest::testStubbedReturnValue public function
Framework_MockObjectTest::testStubbedReturnValueMap public function
Framework_MockObjectTest::testStubbedWillThrowException public function
Framework_MockObjectTest::testStubForClassThatImplementsSerializableCanBeCreatedWithoutInvokingTheConstructor public function @ticket 171
Framework_MockObjectTest::testVerificationOfMethodNameFailsWithoutParameters public function
Framework_MockObjectTest::testVerificationOfMethodNameFailsWithParameters public function
Framework_MockObjectTest::testVerificationOfMethodNameFailsWithWrongParameters public function
Framework_MockObjectTest::testVerificationOfNeverFailsWithAnyParameters public function
Framework_MockObjectTest::testVerificationOfNeverFailsWithEmptyParameters public function
Framework_MockObjectTest::testWithAnythingInsteadOfWithAnyParameters public function @ticket 199
Framework_MockObjectTest::traversableProvider public function
PHPUnit_Framework_Assert::$count private static property
PHPUnit_Framework_Assert::anything public static function Returns a PHPUnit_Framework_Constraint_IsAnything matcher object.
PHPUnit_Framework_Assert::arrayHasKey public static function Returns a PHPUnit_Framework_Constraint_ArrayHasKey matcher object.
PHPUnit_Framework_Assert::assertArrayHasKey public static function Asserts that an array has a specified key.
PHPUnit_Framework_Assert::assertArrayNotHasKey public static function Asserts that an array does not have a specified key.
PHPUnit_Framework_Assert::assertArraySubset public static function Asserts that an array has a specified subset.
PHPUnit_Framework_Assert::assertAttributeContains public static function Asserts that a haystack that is stored in a static attribute of a class or an attribute of an object contains a needle.
PHPUnit_Framework_Assert::assertAttributeContainsOnly public static function Asserts that a haystack that is stored in a static attribute of a class or an attribute of an object contains only values of a given type.
PHPUnit_Framework_Assert::assertAttributeCount public static function Asserts the number of elements of an array, Countable or Traversable that is stored in an attribute.
PHPUnit_Framework_Assert::assertAttributeEmpty public static function Asserts that a static attribute of a class or an attribute of an object is empty.
PHPUnit_Framework_Assert::assertAttributeEquals public static function Asserts that a variable is equal to an attribute of an object.
PHPUnit_Framework_Assert::assertAttributeGreaterThan public static function Asserts that an attribute is greater than another value.
PHPUnit_Framework_Assert::assertAttributeGreaterThanOrEqual public static function Asserts that an attribute is greater than or equal to another value.
PHPUnit_Framework_Assert::assertAttributeInstanceOf public static function Asserts that an attribute is of a given type.
PHPUnit_Framework_Assert::assertAttributeInternalType public static function Asserts that an attribute is of a given type.
PHPUnit_Framework_Assert::assertAttributeLessThan public static function Asserts that an attribute is smaller than another value.
PHPUnit_Framework_Assert::assertAttributeLessThanOrEqual public static function Asserts that an attribute is smaller than or equal to another value.
PHPUnit_Framework_Assert::assertAttributeNotContains public static function Asserts that a haystack that is stored in a static attribute of a class or an attribute of an object does not contain a needle.
PHPUnit_Framework_Assert::assertAttributeNotContainsOnly public static function Asserts that a haystack that is stored in a static attribute of a class or an attribute of an object does not contain only values of a given type.
PHPUnit_Framework_Assert::assertAttributeNotCount public static function Asserts the number of elements of an array, Countable or Traversable that is stored in an attribute.
PHPUnit_Framework_Assert::assertAttributeNotEmpty public static function Asserts that a static attribute of a class or an attribute of an object is not empty.
PHPUnit_Framework_Assert::assertAttributeNotEquals public static function Asserts that a variable is not equal to an attribute of an object.
PHPUnit_Framework_Assert::assertAttributeNotInstanceOf public static function Asserts that an attribute is of a given type.
PHPUnit_Framework_Assert::assertAttributeNotInternalType public static function Asserts that an attribute is of a given type.
PHPUnit_Framework_Assert::assertAttributeNotSame public static function Asserts that a variable and an attribute of an object do not have the same type and value.
PHPUnit_Framework_Assert::assertAttributeSame public static function Asserts that a variable and an attribute of an object have the same type and value.
PHPUnit_Framework_Assert::assertClassHasAttribute public static function Asserts that a class has a specified attribute.
PHPUnit_Framework_Assert::assertClassHasStaticAttribute public static function Asserts that a class has a specified static attribute.
PHPUnit_Framework_Assert::assertClassNotHasAttribute public static function Asserts that a class does not have a specified attribute.
PHPUnit_Framework_Assert::assertClassNotHasStaticAttribute public static function Asserts that a class does not have a specified static attribute.
PHPUnit_Framework_Assert::assertContains public static function Asserts that a haystack contains a needle.
PHPUnit_Framework_Assert::assertContainsOnly public static function Asserts that a haystack contains only values of a given type.
PHPUnit_Framework_Assert::assertContainsOnlyInstancesOf public static function Asserts that a haystack contains only instances of a given classname
PHPUnit_Framework_Assert::assertCount public static function Asserts the number of elements of an array, Countable or Traversable.
PHPUnit_Framework_Assert::assertEmpty public static function Asserts that a variable is empty.
PHPUnit_Framework_Assert::assertEquals public static function Asserts that two variables are equal.
PHPUnit_Framework_Assert::assertEqualXMLStructure public static function Asserts that a hierarchy of DOMElements matches.
PHPUnit_Framework_Assert::assertFalse public static function Asserts that a condition is false.
PHPUnit_Framework_Assert::assertFileEquals public static function Asserts that the contents of one file is equal to the contents of another file.
PHPUnit_Framework_Assert::assertFileExists public static function Asserts that a file exists.
PHPUnit_Framework_Assert::assertFileNotEquals public static function Asserts that the contents of one file is not equal to the contents of another file.
PHPUnit_Framework_Assert::assertFileNotExists public static function Asserts that a file does not exist.
PHPUnit_Framework_Assert::assertGreaterThan public static function Asserts that a value is greater than another value.
PHPUnit_Framework_Assert::assertGreaterThanOrEqual public static function Asserts that a value is greater than or equal to another value.
PHPUnit_Framework_Assert::assertInstanceOf public static function Asserts that a variable is of a given type.
PHPUnit_Framework_Assert::assertInternalType public static function Asserts that a variable is of a given type.
PHPUnit_Framework_Assert::assertJson public static function Asserts that a string is a valid JSON string.
PHPUnit_Framework_Assert::assertJsonFileEqualsJsonFile public static function Asserts that two JSON files are equal.
PHPUnit_Framework_Assert::assertJsonFileNotEqualsJsonFile public static function Asserts that two JSON files are not equal.
PHPUnit_Framework_Assert::assertJsonStringEqualsJsonFile public static function Asserts that the generated JSON encoded object and the content of the given file are equal.
PHPUnit_Framework_Assert::assertJsonStringEqualsJsonString public static function Asserts that two given JSON encoded objects or arrays are equal.
PHPUnit_Framework_Assert::assertJsonStringNotEqualsJsonFile public static function Asserts that the generated JSON encoded object and the content of the given file are not equal.
PHPUnit_Framework_Assert::assertJsonStringNotEqualsJsonString public static function Asserts that two given JSON encoded objects or arrays are not equal.
PHPUnit_Framework_Assert::assertLessThan public static function Asserts that a value is smaller than another value.
PHPUnit_Framework_Assert::assertLessThanOrEqual public static function Asserts that a value is smaller than or equal to another value.
PHPUnit_Framework_Assert::assertNotContains public static function Asserts that a haystack does not contain a needle.
PHPUnit_Framework_Assert::assertNotContainsOnly public static function Asserts that a haystack does not contain only values of a given type.
PHPUnit_Framework_Assert::assertNotCount public static function Asserts the number of elements of an array, Countable or Traversable.
PHPUnit_Framework_Assert::assertNotEmpty public static function Asserts that a variable is not empty.
PHPUnit_Framework_Assert::assertNotEquals public static function Asserts that two variables are not equal.
PHPUnit_Framework_Assert::assertNotFalse public static function Asserts that a condition is not false.
PHPUnit_Framework_Assert::assertNotInstanceOf public static function Asserts that a variable is not of a given type.
PHPUnit_Framework_Assert::assertNotInternalType public static function Asserts that a variable is not of a given type.
PHPUnit_Framework_Assert::assertNotNull public static function Asserts that a variable is not null.
PHPUnit_Framework_Assert::assertNotRegExp public static function Asserts that a string does not match a given regular expression.
PHPUnit_Framework_Assert::assertNotSame public static function Asserts that two variables do not have the same type and value. Used on objects, it asserts that two variables do not reference the same object.
PHPUnit_Framework_Assert::assertNotSameSize public static function Assert that the size of two arrays (or `Countable` or `Traversable` objects) is not the same.
PHPUnit_Framework_Assert::assertNotTag Deprecated public static function This assertion is the exact opposite of assertTag().
PHPUnit_Framework_Assert::assertNotTrue public static function Asserts that a condition is not true.
PHPUnit_Framework_Assert::assertNull public static function Asserts that a variable is null.
PHPUnit_Framework_Assert::assertObjectHasAttribute public static function Asserts that an object has a specified attribute.
PHPUnit_Framework_Assert::assertObjectNotHasAttribute public static function Asserts that an object does not have a specified attribute.
PHPUnit_Framework_Assert::assertRegExp public static function Asserts that a string matches a given regular expression.
PHPUnit_Framework_Assert::assertSame public static function Asserts that two variables have the same type and value. Used on objects, it asserts that two variables reference the same object.
PHPUnit_Framework_Assert::assertSameSize public static function Assert that the size of two arrays (or `Countable` or `Traversable` objects) is the same.
PHPUnit_Framework_Assert::assertSelectCount Deprecated public static function Assert the presence, absence, or count of elements in a document matching the CSS $selector, regardless of the contents of those elements.
PHPUnit_Framework_Assert::assertSelectEquals Deprecated public static function assertSelectEquals("#binder .name", "Chuck", true, $xml); // any? assertSelectEquals("#binder .name", "Chuck", false, $xml); // none?
PHPUnit_Framework_Assert::assertSelectRegExp Deprecated public static function assertSelectRegExp("#binder .name", "/Mike|Derek/", true, $xml); // any? assertSelectRegExp("#binder .name", "/Mike|Derek/", 3, $xml); // 3?
PHPUnit_Framework_Assert::assertStringEndsNotWith public static function Asserts that a string ends not with a given suffix.
PHPUnit_Framework_Assert::assertStringEndsWith public static function Asserts that a string ends with a given suffix.
PHPUnit_Framework_Assert::assertStringEqualsFile public static function Asserts that the contents of a string is equal to the contents of a file.
PHPUnit_Framework_Assert::assertStringMatchesFormat public static function Asserts that a string matches a given format string.
PHPUnit_Framework_Assert::assertStringMatchesFormatFile public static function Asserts that a string matches a given format file.
PHPUnit_Framework_Assert::assertStringNotEqualsFile public static function Asserts that the contents of a string is not equal to the contents of a file.
PHPUnit_Framework_Assert::assertStringNotMatchesFormat public static function Asserts that a string does not match a given format string.
PHPUnit_Framework_Assert::assertStringNotMatchesFormatFile public static function Asserts that a string does not match a given format string.
PHPUnit_Framework_Assert::assertStringStartsNotWith public static function Asserts that a string starts not with a given prefix.
PHPUnit_Framework_Assert::assertStringStartsWith public static function Asserts that a string starts with a given prefix.
PHPUnit_Framework_Assert::assertTag Deprecated public static function Evaluate an HTML or XML string and assert its structure and/or contents.
PHPUnit_Framework_Assert::assertThat public static function Evaluates a PHPUnit_Framework_Constraint matcher object.
PHPUnit_Framework_Assert::assertTrue public static function Asserts that a condition is true.
PHPUnit_Framework_Assert::assertXmlFileEqualsXmlFile public static function Asserts that two XML files are equal.
PHPUnit_Framework_Assert::assertXmlFileNotEqualsXmlFile public static function Asserts that two XML files are not equal.
PHPUnit_Framework_Assert::assertXmlStringEqualsXmlFile public static function Asserts that two XML documents are equal.
PHPUnit_Framework_Assert::assertXmlStringEqualsXmlString public static function Asserts that two XML documents are equal.
PHPUnit_Framework_Assert::assertXmlStringNotEqualsXmlFile public static function Asserts that two XML documents are not equal.
PHPUnit_Framework_Assert::assertXmlStringNotEqualsXmlString public static function Asserts that two XML documents are not equal.
PHPUnit_Framework_Assert::attribute public static function Returns a PHPUnit_Framework_Constraint_Attribute matcher object.
PHPUnit_Framework_Assert::attributeEqualTo public static function Returns a PHPUnit_Framework_Constraint_IsEqual matcher object that is wrapped in a PHPUnit_Framework_Constraint_Attribute matcher object.
PHPUnit_Framework_Assert::callback public static function Returns a PHPUnit_Framework_Constraint_Callback matcher object.
PHPUnit_Framework_Assert::classHasAttribute public static function Returns a PHPUnit_Framework_Constraint_ClassHasAttribute matcher object.
PHPUnit_Framework_Assert::classHasStaticAttribute public static function Returns a PHPUnit_Framework_Constraint_ClassHasStaticAttribute matcher object.
PHPUnit_Framework_Assert::contains public static function Returns a PHPUnit_Framework_Constraint_TraversableContains matcher object.
PHPUnit_Framework_Assert::containsOnly public static function Returns a PHPUnit_Framework_Constraint_TraversableContainsOnly matcher object.
PHPUnit_Framework_Assert::containsOnlyInstancesOf public static function Returns a PHPUnit_Framework_Constraint_TraversableContainsOnly matcher object.
PHPUnit_Framework_Assert::countOf public static function Returns a PHPUnit_Framework_Constraint_Count matcher object.
PHPUnit_Framework_Assert::equalTo public static function Returns a PHPUnit_Framework_Constraint_IsEqual matcher object.
PHPUnit_Framework_Assert::fail public static function Fails a test with the given message.
PHPUnit_Framework_Assert::fileExists public static function Returns a PHPUnit_Framework_Constraint_FileExists matcher object.
PHPUnit_Framework_Assert::getCount public static function Return the current assertion count.
PHPUnit_Framework_Assert::getObjectAttribute public static function Returns the value of an object's attribute. This also works for attributes that are declared protected or private.
PHPUnit_Framework_Assert::getStaticAttribute public static function Returns the value of a static attribute. This also works for attributes that are declared protected or private.
PHPUnit_Framework_Assert::greaterThan public static function Returns a PHPUnit_Framework_Constraint_GreaterThan matcher object.
PHPUnit_Framework_Assert::greaterThanOrEqual public static function Returns a PHPUnit_Framework_Constraint_Or matcher object that wraps a PHPUnit_Framework_Constraint_IsEqual and a PHPUnit_Framework_Constraint_GreaterThan matcher object.
PHPUnit_Framework_Assert::identicalTo public static function Returns a PHPUnit_Framework_Constraint_IsIdentical matcher object.
PHPUnit_Framework_Assert::isEmpty public static function Returns a PHPUnit_Framework_Constraint_IsEmpty matcher object.
PHPUnit_Framework_Assert::isFalse public static function Returns a PHPUnit_Framework_Constraint_IsFalse matcher object.
PHPUnit_Framework_Assert::isInstanceOf public static function Returns a PHPUnit_Framework_Constraint_IsInstanceOf matcher object.
PHPUnit_Framework_Assert::isJson public static function Returns a PHPUnit_Framework_Constraint_IsJson matcher object.
PHPUnit_Framework_Assert::isNull public static function Returns a PHPUnit_Framework_Constraint_IsNull matcher object.
PHPUnit_Framework_Assert::isTrue public static function Returns a PHPUnit_Framework_Constraint_IsTrue matcher object.
PHPUnit_Framework_Assert::isType public static function Returns a PHPUnit_Framework_Constraint_IsType matcher object.
PHPUnit_Framework_Assert::lessThan public static function Returns a PHPUnit_Framework_Constraint_LessThan matcher object.
PHPUnit_Framework_Assert::lessThanOrEqual public static function Returns a PHPUnit_Framework_Constraint_Or matcher object that wraps a PHPUnit_Framework_Constraint_IsEqual and a PHPUnit_Framework_Constraint_LessThan matcher object.
PHPUnit_Framework_Assert::logicalAnd public static function Returns a PHPUnit_Framework_Constraint_And matcher object.
PHPUnit_Framework_Assert::logicalNot public static function Returns a PHPUnit_Framework_Constraint_Not matcher object.
PHPUnit_Framework_Assert::logicalOr public static function Returns a PHPUnit_Framework_Constraint_Or matcher object.
PHPUnit_Framework_Assert::logicalXor public static function Returns a PHPUnit_Framework_Constraint_Xor matcher object.
PHPUnit_Framework_Assert::markTestIncomplete public static function Mark the test as incomplete.
PHPUnit_Framework_Assert::markTestSkipped public static function Mark the test as skipped.
PHPUnit_Framework_Assert::matches public static function Returns a PHPUnit_Framework_Constraint_StringMatches matcher object.
PHPUnit_Framework_Assert::matchesRegularExpression public static function Returns a PHPUnit_Framework_Constraint_PCREMatch matcher object.
PHPUnit_Framework_Assert::objectHasAttribute public static function Returns a PHPUnit_Framework_Constraint_ObjectHasAttribute matcher object.
PHPUnit_Framework_Assert::readAttribute public static function Returns the value of an attribute of a class or an object. This also works for attributes that are declared protected or private.
PHPUnit_Framework_Assert::resetCount public static function Reset the assertion counter.
PHPUnit_Framework_Assert::stringContains public static function Returns a PHPUnit_Framework_Constraint_StringContains matcher object.
PHPUnit_Framework_Assert::stringEndsWith public static function Returns a PHPUnit_Framework_Constraint_StringEndsWith matcher object.
PHPUnit_Framework_Assert::stringStartsWith public static function Returns a PHPUnit_Framework_Constraint_StringStartsWith matcher object.
PHPUnit_Framework_TestCase::$backupGlobals protected property Enable or disable the backup and restoration of the $GLOBALS array. Overwrite this attribute in a child class of TestCase. Setting this attribute in setUp() has no effect! 3
PHPUnit_Framework_TestCase::$backupGlobalsBlacklist protected property 1
PHPUnit_Framework_TestCase::$backupStaticAttributes protected property Enable or disable the backup and restoration of static attributes. Overwrite this attribute in a child class of TestCase. Setting this attribute in setUp() has no effect! 3
PHPUnit_Framework_TestCase::$backupStaticAttributesBlacklist protected property
PHPUnit_Framework_TestCase::$data private property
PHPUnit_Framework_TestCase::$dataName private property
PHPUnit_Framework_TestCase::$dependencies private property
PHPUnit_Framework_TestCase::$dependencyInput private property
PHPUnit_Framework_TestCase::$disallowChangesToGlobalState private property
PHPUnit_Framework_TestCase::$expectedException private property The name of the expected Exception.
PHPUnit_Framework_TestCase::$expectedExceptionCode private property The code of the expected Exception.
PHPUnit_Framework_TestCase::$expectedExceptionMessage private property The message of the expected Exception.
PHPUnit_Framework_TestCase::$expectedExceptionMessageRegExp private property The regex pattern to validate the expected Exception message.
PHPUnit_Framework_TestCase::$iniSettings private property
PHPUnit_Framework_TestCase::$inIsolation private property Whether or not this test is running in a separate PHP process.
PHPUnit_Framework_TestCase::$locale private property
PHPUnit_Framework_TestCase::$mockObjectGenerator private property
PHPUnit_Framework_TestCase::$mockObjects private property
PHPUnit_Framework_TestCase::$name private property The name of the test case.
PHPUnit_Framework_TestCase::$numAssertions private property
PHPUnit_Framework_TestCase::$output private property
PHPUnit_Framework_TestCase::$outputBufferingActive private property
PHPUnit_Framework_TestCase::$outputBufferingLevel private property
PHPUnit_Framework_TestCase::$outputCallback private property
PHPUnit_Framework_TestCase::$outputExpectedRegex private property
PHPUnit_Framework_TestCase::$outputExpectedString private property
PHPUnit_Framework_TestCase::$preserveGlobalState protected property Whether or not this test should preserve the global state when running in a separate PHP process. 1
PHPUnit_Framework_TestCase::$prophet private property
PHPUnit_Framework_TestCase::$result private property 3
PHPUnit_Framework_TestCase::$runTestInSeparateProcess protected property Whether or not this test is to be run in a separate PHP process. 3
PHPUnit_Framework_TestCase::$snapshot private property
PHPUnit_Framework_TestCase::$status private property
PHPUnit_Framework_TestCase::$statusMessage private property
PHPUnit_Framework_TestCase::$testResult private property
PHPUnit_Framework_TestCase::$useErrorHandler private property 3
PHPUnit_Framework_TestCase::addToAssertionCount public function Adds a value to the assertion counter.
PHPUnit_Framework_TestCase::any public static function Returns a matcher that matches when the method is executed zero or more times.
PHPUnit_Framework_TestCase::assertPostConditions protected function Performs assertions shared by all tests of a test case. 6
PHPUnit_Framework_TestCase::assertPreConditions protected function Performs assertions shared by all tests of a test case. 6
PHPUnit_Framework_TestCase::at public static function Returns a matcher that matches when the method is executed at the given index.
PHPUnit_Framework_TestCase::atLeast public static function Returns a matcher that matches when the method is executed at least N times.
PHPUnit_Framework_TestCase::atLeastOnce public static function Returns a matcher that matches when the method is executed at least once.
PHPUnit_Framework_TestCase::atMost public static function Returns a matcher that matches when the method is executed at most N times.
PHPUnit_Framework_TestCase::checkRequirements protected function @since Method available since Release 3.6.0
PHPUnit_Framework_TestCase::compareGlobalStateSnapshotPart private function
PHPUnit_Framework_TestCase::compareGlobalStateSnapshots private function
PHPUnit_Framework_TestCase::count public function Counts the number of test cases executed by run(TestResult result).
PHPUnit_Framework_TestCase::createGlobalStateSnapshot private function
PHPUnit_Framework_TestCase::createResult protected function Creates a default TestResult object.
PHPUnit_Framework_TestCase::exactly public static function Returns a matcher that matches when the method is executed exactly $count times.
PHPUnit_Framework_TestCase::expectOutputRegex public function @since Method available since Release 3.6.0
PHPUnit_Framework_TestCase::expectOutputString public function @since Method available since Release 3.6.0
PHPUnit_Framework_TestCase::getActualOutput public function @since Method available since Release 3.6.0
PHPUnit_Framework_TestCase::getAnnotations public function Returns the annotations for this test.
PHPUnit_Framework_TestCase::getDataSetAsString protected function Gets the data set description of a TestCase.
PHPUnit_Framework_TestCase::getExpectedException public function @since Method available since Release 3.2.0
PHPUnit_Framework_TestCase::getMock public function Returns a mock object for the specified class.
PHPUnit_Framework_TestCase::getMockBuilder public function Returns a builder object to create mock objects using a fluent interface.
PHPUnit_Framework_TestCase::getMockClass protected function Mocks the specified class and returns the name of the mocked class.
PHPUnit_Framework_TestCase::getMockForAbstractClass public function Returns a mock object for the specified abstract class with all abstract methods of the class mocked. Concrete methods are not mocked by default. To mock concrete methods, use the 7th parameter ($mockedMethods).
PHPUnit_Framework_TestCase::getMockForTrait public function Returns a mock object for the specified trait with all abstract methods of the trait mocked. Concrete methods to mock can be specified with the `$mockedMethods` parameter.
PHPUnit_Framework_TestCase::getMockFromWsdl protected function Returns a mock object based on the given WSDL file.
PHPUnit_Framework_TestCase::getMockObjectGenerator protected function Get the mock object generator, creating it if it doesn't exist.
PHPUnit_Framework_TestCase::getName public function Gets the name of a TestCase.
PHPUnit_Framework_TestCase::getNumAssertions public function Returns the number of assertions performed by this test.
PHPUnit_Framework_TestCase::getObjectForTrait protected function Returns an object for the specified trait.
PHPUnit_Framework_TestCase::getProphet private function @since Method available since Release 4.5.0
PHPUnit_Framework_TestCase::getResult public function @since Method available since Release 3.4.0
PHPUnit_Framework_TestCase::getSize public function Returns the size of the test.
PHPUnit_Framework_TestCase::getStatus public function Returns the status of this test.
PHPUnit_Framework_TestCase::getStatusMessage public function Returns the status message of this test.
PHPUnit_Framework_TestCase::getTestResultObject public function @since Method available since Release 3.5.7
PHPUnit_Framework_TestCase::handleDependencies protected function @since Method available since Release 3.5.4
PHPUnit_Framework_TestCase::hasDependencies public function Returns true if the tests has dependencies
PHPUnit_Framework_TestCase::hasExpectationOnOutput public function @since Method available since Release 4.3.3
PHPUnit_Framework_TestCase::hasFailed public function Returns whether or not this test has failed.
PHPUnit_Framework_TestCase::hasOutput public function @since Method available since Release 3.6.0
PHPUnit_Framework_TestCase::hasPerformedExpectationsOnOutput public function @since Method available since Release 3.6.5
PHPUnit_Framework_TestCase::iniSet protected function This method is a wrapper for the ini_set() function that automatically resets the modified php.ini setting to its original value after the test is run.
PHPUnit_Framework_TestCase::isInIsolation public function @since Method available since Release 4.3.0
PHPUnit_Framework_TestCase::never public static function Returns a matcher that matches when the method is never executed.
PHPUnit_Framework_TestCase::once public static function Returns a matcher that matches when the method is executed exactly once.
PHPUnit_Framework_TestCase::onConsecutiveCalls public static function @since Method available since Release 3.0.0
PHPUnit_Framework_TestCase::onNotSuccessfulTest protected function This method is called when a test method did not execute successfully. 1
PHPUnit_Framework_TestCase::prepareTemplate protected function Performs custom preparations on the process isolation template.
PHPUnit_Framework_TestCase::prophesize protected function @since Method available since Release 4.5.0
PHPUnit_Framework_TestCase::restoreGlobalState private function
PHPUnit_Framework_TestCase::returnArgument public static function @since Method available since Release 3.3.0
PHPUnit_Framework_TestCase::returnCallback public static function @since Method available since Release 3.3.0
PHPUnit_Framework_TestCase::returnSelf public static function Returns the current object.
PHPUnit_Framework_TestCase::returnValue public static function @since Method available since Release 3.0.0
PHPUnit_Framework_TestCase::returnValueMap public static function @since Method available since Release 3.6.0
PHPUnit_Framework_TestCase::run public function Runs the test case and collects the results in a TestResult object. If no TestResult object is passed a new one will be created. Overrides PHPUnit_Framework_Test::run
PHPUnit_Framework_TestCase::runBare public function Runs the bare test sequence.
PHPUnit_Framework_TestCase::runTest protected function Override to run the test and assert its state. 9
PHPUnit_Framework_TestCase::setBackupGlobals public function Calling this method in setUp() has no effect!
PHPUnit_Framework_TestCase::setBackupStaticAttributes public function Calling this method in setUp() has no effect!
PHPUnit_Framework_TestCase::setDependencies public function Sets the dependencies of a TestCase.
PHPUnit_Framework_TestCase::setDependencyInput public function Sets
PHPUnit_Framework_TestCase::setDisallowChangesToGlobalState public function @since Method available since Release 4.6.0
PHPUnit_Framework_TestCase::setExpectedException public function @since Method available since Release 3.2.0
PHPUnit_Framework_TestCase::setExpectedExceptionFromAnnotation protected function @since Method available since Release 3.4.0
PHPUnit_Framework_TestCase::setExpectedExceptionRegExp public function @since Method available since Release 4.3.0
PHPUnit_Framework_TestCase::setInIsolation public function @since Method available since Release 3.4.0
PHPUnit_Framework_TestCase::setLocale protected function This method is a wrapper for the setlocale() function that automatically resets the locale to its original value after the test is run.
PHPUnit_Framework_TestCase::setName public function Sets the name of a TestCase.
PHPUnit_Framework_TestCase::setOutputCallback public function @since Method available since Release 3.6.0
PHPUnit_Framework_TestCase::setPreserveGlobalState public function @since Method available since Release 3.4.0
PHPUnit_Framework_TestCase::setResult public function @since Method available since Release 3.4.0
PHPUnit_Framework_TestCase::setRunTestInSeparateProcess public function @since Method available since Release 3.4.0
PHPUnit_Framework_TestCase::setTestResultObject public function @since Method available since Release 3.6.0
PHPUnit_Framework_TestCase::setUp protected function Sets up the fixture, for example, open a network connection. This method is called before a test is executed. 40
PHPUnit_Framework_TestCase::setUpBeforeClass public static function This method is called before the first test of this test class is run. 2
PHPUnit_Framework_TestCase::setUseErrorHandler public function @since Method available since Release 3.4.0
PHPUnit_Framework_TestCase::setUseErrorHandlerFromAnnotation protected function @since Method available since Release 3.4.0
PHPUnit_Framework_TestCase::snapshotGlobalState private function
PHPUnit_Framework_TestCase::startOutputBuffering private function @since Method available since Release 4.2.0
PHPUnit_Framework_TestCase::stopOutputBuffering private function @since Method available since Release 4.2.0
PHPUnit_Framework_TestCase::tearDown protected function Tears down the fixture, for example, close a network connection. This method is called after a test is executed. 10
PHPUnit_Framework_TestCase::tearDownAfterClass public static function This method is called after the last test of this test class is run. 2
PHPUnit_Framework_TestCase::throwException public static function @since Method available since Release 3.1.0
PHPUnit_Framework_TestCase::toString public function Returns a string representation of the test case. Overrides PHPUnit_Framework_SelfDescribing::toString 3
PHPUnit_Framework_TestCase::verifyMockObjects protected function Verifies the mock object expectations.
PHPUnit_Framework_TestCase::__construct public function Constructs a test case with the given name. 4