You are here

class Framework_AssertTest in Zircon Profile 8.0

Same name and namespace in other branches
  1. 8 vendor/phpunit/phpunit/tests/Framework/AssertTest.php \Framework_AssertTest

@since Class available since Release 2.0.0

Hierarchy

Expanded class hierarchy of Framework_AssertTest

File

vendor/phpunit/phpunit/tests/Framework/AssertTest.php, line 14

View source
class Framework_AssertTest extends PHPUnit_Framework_TestCase {

  /**
   * @var string
   */
  private $filesDirectory;
  protected function setUp() {
    $this->filesDirectory = dirname(__DIR__) . DIRECTORY_SEPARATOR . '_files' . DIRECTORY_SEPARATOR;
  }

  /**
   * @covers PHPUnit_Framework_Assert::fail
   */
  public function testFail() {
    try {
      $this
        ->fail();
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    throw new PHPUnit_Framework_AssertionFailedError('Fail did not throw fail exception');
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertContains
   */
  public function testAssertSplObjectStorageContainsObject() {
    $a = new stdClass();
    $b = new stdClass();
    $c = new SplObjectStorage();
    $c
      ->attach($a);
    $this
      ->assertContains($a, $c);
    try {
      $this
        ->assertContains($b, $c);
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertContains
   */
  public function testAssertArrayContainsObject() {
    $a = new stdClass();
    $b = new stdClass();
    $this
      ->assertContains($a, array(
      $a,
    ));
    try {
      $this
        ->assertContains($a, array(
        $b,
      ));
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertContains
   */
  public function testAssertArrayContainsString() {
    $this
      ->assertContains('foo', array(
      'foo',
    ));
    try {
      $this
        ->assertContains('foo', array(
        'bar',
      ));
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertContains
   */
  public function testAssertArrayContainsNonObject() {
    $this
      ->assertContains('foo', array(
      true,
    ));
    try {
      $this
        ->assertContains('foo', array(
        true,
      ), '', false, true, true);
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertContainsOnlyInstancesOf
   */
  public function testAssertContainsOnlyInstancesOf() {
    $test = array(
      new Book(),
      new Book(),
    );
    $this
      ->assertContainsOnlyInstancesOf('Book', $test);
    $this
      ->assertContainsOnlyInstancesOf('stdClass', array(
      new stdClass(),
    ));
    $test2 = array(
      new Author('Test'),
    );
    try {
      $this
        ->assertContainsOnlyInstancesOf('Book', $test2);
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers            PHPUnit_Framework_Assert::assertArrayHasKey
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testAssertArrayHasKeyThrowsExceptionForInvalidFirstArgument() {
    $this
      ->assertArrayHasKey(null, array());
  }

  /**
   * @covers            PHPUnit_Framework_Assert::assertArrayHasKey
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testAssertArrayHasKeyThrowsExceptionForInvalidSecondArgument() {
    $this
      ->assertArrayHasKey(0, null);
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertArrayHasKey
   */
  public function testAssertArrayHasIntegerKey() {
    $this
      ->assertArrayHasKey(0, array(
      'foo',
    ));
    try {
      $this
        ->assertArrayHasKey(1, array(
        'foo',
      ));
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertArraySubset
   * @covers PHPUnit_Framework_Constraint_ArraySubset
   */
  public function testAssertArraySubset() {
    $array = array(
      'a' => 'item a',
      'b' => 'item b',
      'c' => array(
        'a2' => 'item a2',
        'b2' => 'item b2',
      ),
      'd' => array(
        'a2' => array(
          'a3' => 'item a3',
          'b3' => 'item b3',
        ),
      ),
    );
    $this
      ->assertArraySubset(array(
      'a' => 'item a',
      'c' => array(
        'a2' => 'item a2',
      ),
    ), $array);
    $this
      ->assertArraySubset(array(
      'a' => 'item a',
      'd' => array(
        'a2' => array(
          'b3' => 'item b3',
        ),
      ),
    ), $array);
    try {
      $this
        ->assertArraySubset(array(
        'a' => 'bad value',
      ), $array);
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
    }
    try {
      $this
        ->assertArraySubset(array(
        'd' => array(
          'a2' => array(
            'bad index' => 'item b3',
          ),
        ),
      ), $array);
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertArraySubset
   * @covers PHPUnit_Framework_Constraint_ArraySubset
   */
  public function testAssertArraySubsetWithDeepNestedArrays() {
    $array = array(
      'path' => array(
        'to' => array(
          'the' => array(
            'cake' => 'is a lie',
          ),
        ),
      ),
    );
    $this
      ->assertArraySubset(array(
      'path' => array(),
    ), $array);
    $this
      ->assertArraySubset(array(
      'path' => array(
        'to' => array(),
      ),
    ), $array);
    $this
      ->assertArraySubset(array(
      'path' => array(
        'to' => array(
          'the' => array(),
        ),
      ),
    ), $array);
    $this
      ->assertArraySubset(array(
      'path' => array(
        'to' => array(
          'the' => array(
            'cake' => 'is a lie',
          ),
        ),
      ),
    ), $array);
    try {
      $this
        ->assertArraySubset(array(
        'path' => array(
          'to' => array(
            'the' => array(
              'cake' => 'is not a lie',
            ),
          ),
        ),
      ), $array);
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertArraySubset
   * @covers PHPUnit_Framework_Constraint_ArraySubset
   */
  public function testAssertArraySubsetWithNoStrictCheckAndObjects() {
    $obj = new \stdClass();
    $reference =& $obj;
    $array = array(
      'a' => $obj,
    );
    $this
      ->assertArraySubset(array(
      'a' => $reference,
    ), $array);
    $this
      ->assertArraySubset(array(
      'a' => new \stdClass(),
    ), $array);
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertArraySubset
   * @covers PHPUnit_Framework_Constraint_ArraySubset
   */
  public function testAssertArraySubsetWithStrictCheckAndObjects() {
    $obj = new \stdClass();
    $reference =& $obj;
    $array = array(
      'a' => $obj,
    );
    $this
      ->assertArraySubset(array(
      'a' => $reference,
    ), $array, true);
    try {
      $this
        ->assertArraySubset(array(
        'a' => new \stdClass(),
      ), $array, true);
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail('Strict recursive array check fail.');
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertArraySubset
   * @covers PHPUnit_Framework_Constraint_ArraySubset
   * @expectedException PHPUnit_Framework_Exception
   * @expectedExceptionMessage array or ArrayAccess
   * @dataProvider assertArraySubsetInvalidArgumentProvider
   */
  public function testAssertArraySubsetRaisesExceptionForInvalidArguments($partial, $subject) {
    $this
      ->assertArraySubset($partial, $subject);
  }

  /**
   * @return array
   */
  public function assertArraySubsetInvalidArgumentProvider() {
    return array(
      array(
        false,
        array(),
      ),
      array(
        array(),
        false,
      ),
    );
  }

  /**
   * @covers            PHPUnit_Framework_Assert::assertArrayNotHasKey
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testAssertArrayNotHasKeyThrowsExceptionForInvalidFirstArgument() {
    $this
      ->assertArrayNotHasKey(null, array());
  }

  /**
   * @covers            PHPUnit_Framework_Assert::assertArrayNotHasKey
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testAssertArrayNotHasKeyThrowsExceptionForInvalidSecondArgument() {
    $this
      ->assertArrayNotHasKey(0, null);
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertArrayNotHasKey
   */
  public function testAssertArrayNotHasIntegerKey() {
    $this
      ->assertArrayNotHasKey(1, array(
      'foo',
    ));
    try {
      $this
        ->assertArrayNotHasKey(0, array(
        'foo',
      ));
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertArrayHasKey
   */
  public function testAssertArrayHasStringKey() {
    $this
      ->assertArrayHasKey('foo', array(
      'foo' => 'bar',
    ));
    try {
      $this
        ->assertArrayHasKey('bar', array(
        'foo' => 'bar',
      ));
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertArrayNotHasKey
   */
  public function testAssertArrayNotHasStringKey() {
    $this
      ->assertArrayNotHasKey('bar', array(
      'foo' => 'bar',
    ));
    try {
      $this
        ->assertArrayNotHasKey('foo', array(
        'foo' => 'bar',
      ));
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertArrayHasKey
   */
  public function testAssertArrayHasKeyAcceptsArrayObjectValue() {
    $array = new ArrayObject();
    $array['foo'] = 'bar';
    $this
      ->assertArrayHasKey('foo', $array);
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertArrayHasKey
   * @expectedException PHPUnit_Framework_AssertionFailedError
   */
  public function testAssertArrayHasKeyProperlyFailsWithArrayObjectValue() {
    $array = new ArrayObject();
    $array['bar'] = 'bar';
    $this
      ->assertArrayHasKey('foo', $array);
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertArrayHasKey
   */
  public function testAssertArrayHasKeyAcceptsArrayAccessValue() {
    $array = new SampleArrayAccess();
    $array['foo'] = 'bar';
    $this
      ->assertArrayHasKey('foo', $array);
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertArrayHasKey
   * @expectedException PHPUnit_Framework_AssertionFailedError
   */
  public function testAssertArrayHasKeyProperlyFailsWithArrayAccessValue() {
    $array = new SampleArrayAccess();
    $array['bar'] = 'bar';
    $this
      ->assertArrayHasKey('foo', $array);
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertArrayNotHasKey
   */
  public function testAssertArrayNotHasKeyAcceptsArrayAccessValue() {
    $array = new ArrayObject();
    $array['foo'] = 'bar';
    $this
      ->assertArrayNotHasKey('bar', $array);
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertArrayNotHasKey
   * @expectedException PHPUnit_Framework_AssertionFailedError
   */
  public function testAssertArrayNotHasKeyPropertlyFailsWithArrayAccessValue() {
    $array = new ArrayObject();
    $array['bar'] = 'bar';
    $this
      ->assertArrayNotHasKey('bar', $array);
  }

  /**
   * @covers            PHPUnit_Framework_Assert::assertContains
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testAssertContainsThrowsException() {
    $this
      ->assertContains(null, null);
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertContains
   */
  public function testAssertIteratorContainsObject() {
    $foo = new stdClass();
    $this
      ->assertContains($foo, new TestIterator(array(
      $foo,
    )));
    try {
      $this
        ->assertContains($foo, new TestIterator(array(
        new stdClass(),
      )));
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertContains
   */
  public function testAssertIteratorContainsString() {
    $this
      ->assertContains('foo', new TestIterator(array(
      'foo',
    )));
    try {
      $this
        ->assertContains('foo', new TestIterator(array(
        'bar',
      )));
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertContains
   */
  public function testAssertStringContainsString() {
    $this
      ->assertContains('foo', 'foobar');
    try {
      $this
        ->assertContains('foo', 'bar');
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers            PHPUnit_Framework_Assert::assertNotContains
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testAssertNotContainsThrowsException() {
    $this
      ->assertNotContains(null, null);
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertNotContains
   */
  public function testAssertSplObjectStorageNotContainsObject() {
    $a = new stdClass();
    $b = new stdClass();
    $c = new SplObjectStorage();
    $c
      ->attach($a);
    $this
      ->assertNotContains($b, $c);
    try {
      $this
        ->assertNotContains($a, $c);
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertNotContains
   */
  public function testAssertArrayNotContainsObject() {
    $a = new stdClass();
    $b = new stdClass();
    $this
      ->assertNotContains($a, array(
      $b,
    ));
    try {
      $this
        ->assertNotContains($a, array(
        $a,
      ));
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertNotContains
   */
  public function testAssertArrayNotContainsString() {
    $this
      ->assertNotContains('foo', array(
      'bar',
    ));
    try {
      $this
        ->assertNotContains('foo', array(
        'foo',
      ));
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertNotContains
   */
  public function testAssertArrayNotContainsNonObject() {
    $this
      ->assertNotContains('foo', array(
      true,
    ), '', false, true, true);
    try {
      $this
        ->assertNotContains('foo', array(
        true,
      ));
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertNotContains
   */
  public function testAssertStringNotContainsString() {
    $this
      ->assertNotContains('foo', 'bar');
    try {
      $this
        ->assertNotContains('foo', 'foo');
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers            PHPUnit_Framework_Assert::assertContainsOnly
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testAssertContainsOnlyThrowsException() {
    $this
      ->assertContainsOnly(null, null);
  }

  /**
   * @covers            PHPUnit_Framework_Assert::assertNotContainsOnly
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testAssertNotContainsOnlyThrowsException() {
    $this
      ->assertNotContainsOnly(null, null);
  }

  /**
   * @covers            PHPUnit_Framework_Assert::assertContainsOnlyInstancesOf
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testAssertContainsOnlyInstancesOfThrowsException() {
    $this
      ->assertContainsOnlyInstancesOf(null, null);
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertContainsOnly
   */
  public function testAssertArrayContainsOnlyIntegers() {
    $this
      ->assertContainsOnly('integer', array(
      1,
      2,
      3,
    ));
    try {
      $this
        ->assertContainsOnly('integer', array(
        '1',
        2,
        3,
      ));
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertNotContainsOnly
   */
  public function testAssertArrayNotContainsOnlyIntegers() {
    $this
      ->assertNotContainsOnly('integer', array(
      '1',
      2,
      3,
    ));
    try {
      $this
        ->assertNotContainsOnly('integer', array(
        1,
        2,
        3,
      ));
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertContainsOnly
   */
  public function testAssertArrayContainsOnlyStdClass() {
    $this
      ->assertContainsOnly('StdClass', array(
      new stdClass(),
    ));
    try {
      $this
        ->assertContainsOnly('StdClass', array(
        'StdClass',
      ));
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertNotContainsOnly
   */
  public function testAssertArrayNotContainsOnlyStdClass() {
    $this
      ->assertNotContainsOnly('StdClass', array(
      'StdClass',
    ));
    try {
      $this
        ->assertNotContainsOnly('StdClass', array(
        new stdClass(),
      ));
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }
  protected function sameValues() {
    $object = new SampleClass(4, 8, 15);

    // cannot use $filesDirectory, because neither setUp() nor
    // setUpBeforeClass() are executed before the data providers
    $file = dirname(__DIR__) . DIRECTORY_SEPARATOR . '_files' . DIRECTORY_SEPARATOR . 'foo.xml';
    $resource = fopen($file, 'r');
    return array(
      // null
      array(
        null,
        null,
      ),
      // strings
      array(
        'a',
        'a',
      ),
      // integers
      array(
        0,
        0,
      ),
      // floats
      array(
        2.3,
        2.3,
      ),
      array(
        1 / 3,
        1 - 2 / 3,
      ),
      array(
        log(0),
        log(0),
      ),
      // arrays
      array(
        array(),
        array(),
      ),
      array(
        array(
          0 => 1,
        ),
        array(
          0 => 1,
        ),
      ),
      array(
        array(
          0 => null,
        ),
        array(
          0 => null,
        ),
      ),
      array(
        array(
          'a',
          'b' => array(
            1,
            2,
          ),
        ),
        array(
          'a',
          'b' => array(
            1,
            2,
          ),
        ),
      ),
      // objects
      array(
        $object,
        $object,
      ),
      // resources
      array(
        $resource,
        $resource,
      ),
    );
  }
  protected function notEqualValues() {

    // cyclic dependencies
    $book1 = new Book();
    $book1->author = new Author('Terry Pratchett');
    $book1->author->books[] = $book1;
    $book2 = new Book();
    $book2->author = new Author('Terry Pratch');
    $book2->author->books[] = $book2;
    $book3 = new Book();
    $book3->author = 'Terry Pratchett';
    $book4 = new stdClass();
    $book4->author = 'Terry Pratchett';
    $object1 = new SampleClass(4, 8, 15);
    $object2 = new SampleClass(16, 23, 42);
    $object3 = new SampleClass(4, 8, 15);
    $storage1 = new SplObjectStorage();
    $storage1
      ->attach($object1);
    $storage2 = new SplObjectStorage();
    $storage2
      ->attach($object3);

    // same content, different object
    // cannot use $filesDirectory, because neither setUp() nor
    // setUpBeforeClass() are executed before the data providers
    $file = dirname(__DIR__) . DIRECTORY_SEPARATOR . '_files' . DIRECTORY_SEPARATOR . 'foo.xml';
    return array(
      // strings
      array(
        'a',
        'b',
      ),
      array(
        'a',
        'A',
      ),
      // https://github.com/sebastianbergmann/phpunit/issues/1023
      array(
        '9E6666666',
        '9E7777777',
      ),
      // integers
      array(
        1,
        2,
      ),
      array(
        2,
        1,
      ),
      // floats
      array(
        2.3,
        4.2,
      ),
      array(
        2.3,
        4.2,
        0.5,
      ),
      array(
        array(
          2.3,
        ),
        array(
          4.2,
        ),
        0.5,
      ),
      array(
        array(
          array(
            2.3,
          ),
        ),
        array(
          array(
            4.2,
          ),
        ),
        0.5,
      ),
      array(
        new Struct(2.3),
        new Struct(4.2),
        0.5,
      ),
      array(
        array(
          new Struct(2.3),
        ),
        array(
          new Struct(4.2),
        ),
        0.5,
      ),
      // NAN
      array(
        NAN,
        NAN,
      ),
      // arrays
      array(
        array(),
        array(
          0 => 1,
        ),
      ),
      array(
        array(
          0 => 1,
        ),
        array(),
      ),
      array(
        array(
          0 => null,
        ),
        array(),
      ),
      array(
        array(
          0 => 1,
          1 => 2,
        ),
        array(
          0 => 1,
          1 => 3,
        ),
      ),
      array(
        array(
          'a',
          'b' => array(
            1,
            2,
          ),
        ),
        array(
          'a',
          'b' => array(
            2,
            1,
          ),
        ),
      ),
      // objects
      array(
        new SampleClass(4, 8, 15),
        new SampleClass(16, 23, 42),
      ),
      array(
        $object1,
        $object2,
      ),
      array(
        $book1,
        $book2,
      ),
      array(
        $book3,
        $book4,
      ),
      // same content, different class
      // resources
      array(
        fopen($file, 'r'),
        fopen($file, 'r'),
      ),
      // SplObjectStorage
      array(
        $storage1,
        $storage2,
      ),
      // DOMDocument
      array(
        PHPUnit_Util_XML::load('<root></root>'),
        PHPUnit_Util_XML::load('<bar/>'),
      ),
      array(
        PHPUnit_Util_XML::load('<foo attr1="bar"/>'),
        PHPUnit_Util_XML::load('<foo attr1="foobar"/>'),
      ),
      array(
        PHPUnit_Util_XML::load('<foo> bar </foo>'),
        PHPUnit_Util_XML::load('<foo />'),
      ),
      array(
        PHPUnit_Util_XML::load('<foo xmlns="urn:myns:bar"/>'),
        PHPUnit_Util_XML::load('<foo xmlns="urn:notmyns:bar"/>'),
      ),
      array(
        PHPUnit_Util_XML::load('<foo> bar </foo>'),
        PHPUnit_Util_XML::load('<foo> bir </foo>'),
      ),
      array(
        new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/New_York')),
        new DateTime('2013-03-29 03:13:35', new DateTimeZone('America/New_York')),
      ),
      array(
        new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/New_York')),
        new DateTime('2013-03-29 03:13:35', new DateTimeZone('America/New_York')),
        3500,
      ),
      array(
        new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/New_York')),
        new DateTime('2013-03-29 05:13:35', new DateTimeZone('America/New_York')),
        3500,
      ),
      array(
        new DateTime('2013-03-29', new DateTimeZone('America/New_York')),
        new DateTime('2013-03-30', new DateTimeZone('America/New_York')),
      ),
      array(
        new DateTime('2013-03-29', new DateTimeZone('America/New_York')),
        new DateTime('2013-03-30', new DateTimeZone('America/New_York')),
        43200,
      ),
      array(
        new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/New_York')),
        new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/Chicago')),
      ),
      array(
        new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/New_York')),
        new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/Chicago')),
        3500,
      ),
      array(
        new DateTime('2013-03-30', new DateTimeZone('America/New_York')),
        new DateTime('2013-03-30', new DateTimeZone('America/Chicago')),
      ),
      array(
        new DateTime('2013-03-29T05:13:35-0600'),
        new DateTime('2013-03-29T04:13:35-0600'),
      ),
      array(
        new DateTime('2013-03-29T05:13:35-0600'),
        new DateTime('2013-03-29T05:13:35-0500'),
      ),
      // Exception

      //array(new Exception('Exception 1'), new Exception('Exception 2')),

      // different types
      array(
        new SampleClass(4, 8, 15),
        false,
      ),
      array(
        false,
        new SampleClass(4, 8, 15),
      ),
      array(
        array(
          0 => 1,
          1 => 2,
        ),
        false,
      ),
      array(
        false,
        array(
          0 => 1,
          1 => 2,
        ),
      ),
      array(
        array(),
        new stdClass(),
      ),
      array(
        new stdClass(),
        array(),
      ),
      // PHP: 0 == 'Foobar' => true!
      // We want these values to differ
      array(
        0,
        'Foobar',
      ),
      array(
        'Foobar',
        0,
      ),
      array(
        3,
        acos(8),
      ),
      array(
        acos(8),
        3,
      ),
    );
  }
  protected function equalValues() {

    // cyclic dependencies
    $book1 = new Book();
    $book1->author = new Author('Terry Pratchett');
    $book1->author->books[] = $book1;
    $book2 = new Book();
    $book2->author = new Author('Terry Pratchett');
    $book2->author->books[] = $book2;
    $object1 = new SampleClass(4, 8, 15);
    $object2 = new SampleClass(4, 8, 15);
    $storage1 = new SplObjectStorage();
    $storage1
      ->attach($object1);
    $storage2 = new SplObjectStorage();
    $storage2
      ->attach($object1);
    return array(
      // strings
      array(
        'a',
        'A',
        0,
        false,
        true,
      ),
      // ignore case
      // arrays
      array(
        array(
          'a' => 1,
          'b' => 2,
        ),
        array(
          'b' => 2,
          'a' => 1,
        ),
      ),
      array(
        array(
          1,
        ),
        array(
          '1',
        ),
      ),
      array(
        array(
          3,
          2,
          1,
        ),
        array(
          2,
          3,
          1,
        ),
        0,
        true,
      ),
      // canonicalized comparison
      // floats
      array(
        2.3,
        2.5,
        0.5,
      ),
      array(
        array(
          2.3,
        ),
        array(
          2.5,
        ),
        0.5,
      ),
      array(
        array(
          array(
            2.3,
          ),
        ),
        array(
          array(
            2.5,
          ),
        ),
        0.5,
      ),
      array(
        new Struct(2.3),
        new Struct(2.5),
        0.5,
      ),
      array(
        array(
          new Struct(2.3),
        ),
        array(
          new Struct(2.5),
        ),
        0.5,
      ),
      // numeric with delta
      array(
        1,
        2,
        1,
      ),
      // objects
      array(
        $object1,
        $object2,
      ),
      array(
        $book1,
        $book2,
      ),
      // SplObjectStorage
      array(
        $storage1,
        $storage2,
      ),
      // DOMDocument
      array(
        PHPUnit_Util_XML::load('<root></root>'),
        PHPUnit_Util_XML::load('<root/>'),
      ),
      array(
        PHPUnit_Util_XML::load('<root attr="bar"></root>'),
        PHPUnit_Util_XML::load('<root attr="bar"/>'),
      ),
      array(
        PHPUnit_Util_XML::load('<root><foo attr="bar"></foo></root>'),
        PHPUnit_Util_XML::load('<root><foo attr="bar"/></root>'),
      ),
      array(
        PHPUnit_Util_XML::load("<root>\n  <child/>\n</root>"),
        PHPUnit_Util_XML::load('<root><child/></root>'),
      ),
      array(
        new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/New_York')),
        new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/New_York')),
      ),
      array(
        new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/New_York')),
        new DateTime('2013-03-29 04:13:25', new DateTimeZone('America/New_York')),
        10,
      ),
      array(
        new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/New_York')),
        new DateTime('2013-03-29 04:14:40', new DateTimeZone('America/New_York')),
        65,
      ),
      array(
        new DateTime('2013-03-29', new DateTimeZone('America/New_York')),
        new DateTime('2013-03-29', new DateTimeZone('America/New_York')),
      ),
      array(
        new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/New_York')),
        new DateTime('2013-03-29 03:13:35', new DateTimeZone('America/Chicago')),
      ),
      array(
        new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/New_York')),
        new DateTime('2013-03-29 03:13:49', new DateTimeZone('America/Chicago')),
        15,
      ),
      array(
        new DateTime('2013-03-30', new DateTimeZone('America/New_York')),
        new DateTime('2013-03-29 23:00:00', new DateTimeZone('America/Chicago')),
      ),
      array(
        new DateTime('2013-03-30', new DateTimeZone('America/New_York')),
        new DateTime('2013-03-29 23:01:30', new DateTimeZone('America/Chicago')),
        100,
      ),
      array(
        new DateTime('@1364616000'),
        new DateTime('2013-03-29 23:00:00', new DateTimeZone('America/Chicago')),
      ),
      array(
        new DateTime('2013-03-29T05:13:35-0500'),
        new DateTime('2013-03-29T04:13:35-0600'),
      ),
      // Exception

      //array(new Exception('Exception 1'), new Exception('Exception 1')),

      // mixed types
      array(
        0,
        '0',
      ),
      array(
        '0',
        0,
      ),
      array(
        2.3,
        '2.3',
      ),
      array(
        '2.3',
        2.3,
      ),
      array(
        (string) (1 / 3),
        1 - 2 / 3,
      ),
      array(
        1 / 3,
        (string) (1 - 2 / 3),
      ),
      array(
        'string representation',
        new ClassWithToString(),
      ),
      array(
        new ClassWithToString(),
        'string representation',
      ),
    );
  }
  public function equalProvider() {

    // same |= equal
    return array_merge($this
      ->equalValues(), $this
      ->sameValues());
  }
  public function notEqualProvider() {
    return $this
      ->notEqualValues();
  }
  public function sameProvider() {
    return $this
      ->sameValues();
  }
  public function notSameProvider() {

    // not equal |= not same
    // equal, ¬same |= not same
    return array_merge($this
      ->notEqualValues(), $this
      ->equalValues());
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertEquals
   * @dataProvider equalProvider
   */
  public function testAssertEqualsSucceeds($a, $b, $delta = 0.0, $canonicalize = false, $ignoreCase = false) {
    $this
      ->assertEquals($a, $b, '', $delta, 10, $canonicalize, $ignoreCase);
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertEquals
   * @dataProvider notEqualProvider
   */
  public function testAssertEqualsFails($a, $b, $delta = 0.0, $canonicalize = false, $ignoreCase = false) {
    try {
      $this
        ->assertEquals($a, $b, '', $delta, 10, $canonicalize, $ignoreCase);
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertNotEquals
   * @dataProvider notEqualProvider
   */
  public function testAssertNotEqualsSucceeds($a, $b, $delta = 0.0, $canonicalize = false, $ignoreCase = false) {
    $this
      ->assertNotEquals($a, $b, '', $delta, 10, $canonicalize, $ignoreCase);
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertNotEquals
   * @dataProvider equalProvider
   */
  public function testAssertNotEqualsFails($a, $b, $delta = 0.0, $canonicalize = false, $ignoreCase = false) {
    try {
      $this
        ->assertNotEquals($a, $b, '', $delta, 10, $canonicalize, $ignoreCase);
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertSame
   * @dataProvider sameProvider
   */
  public function testAssertSameSucceeds($a, $b) {
    $this
      ->assertSame($a, $b);
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertSame
   * @dataProvider notSameProvider
   */
  public function testAssertSameFails($a, $b) {
    try {
      $this
        ->assertSame($a, $b);
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertNotSame
   * @dataProvider notSameProvider
   */
  public function testAssertNotSameSucceeds($a, $b) {
    $this
      ->assertNotSame($a, $b);
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertNotSame
   * @dataProvider sameProvider
   */
  public function testAssertNotSameFails($a, $b) {
    try {
      $this
        ->assertNotSame($a, $b);
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertXmlFileEqualsXmlFile
   */
  public function testAssertXmlFileEqualsXmlFile() {
    $this
      ->assertXmlFileEqualsXmlFile($this->filesDirectory . 'foo.xml', $this->filesDirectory . 'foo.xml');
    try {
      $this
        ->assertXmlFileEqualsXmlFile($this->filesDirectory . 'foo.xml', $this->filesDirectory . 'bar.xml');
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertXmlFileNotEqualsXmlFile
   */
  public function testAssertXmlFileNotEqualsXmlFile() {
    $this
      ->assertXmlFileNotEqualsXmlFile($this->filesDirectory . 'foo.xml', $this->filesDirectory . 'bar.xml');
    try {
      $this
        ->assertXmlFileNotEqualsXmlFile($this->filesDirectory . 'foo.xml', $this->filesDirectory . 'foo.xml');
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertXmlStringEqualsXmlFile
   */
  public function testAssertXmlStringEqualsXmlFile() {
    $this
      ->assertXmlStringEqualsXmlFile($this->filesDirectory . 'foo.xml', file_get_contents($this->filesDirectory . 'foo.xml'));
    try {
      $this
        ->assertXmlStringEqualsXmlFile($this->filesDirectory . 'foo.xml', file_get_contents($this->filesDirectory . 'bar.xml'));
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertXmlStringNotEqualsXmlFile
   */
  public function testXmlStringNotEqualsXmlFile() {
    $this
      ->assertXmlStringNotEqualsXmlFile($this->filesDirectory . 'foo.xml', file_get_contents($this->filesDirectory . 'bar.xml'));
    try {
      $this
        ->assertXmlStringNotEqualsXmlFile($this->filesDirectory . 'foo.xml', file_get_contents($this->filesDirectory . 'foo.xml'));
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertXmlStringEqualsXmlString
   */
  public function testAssertXmlStringEqualsXmlString() {
    $this
      ->assertXmlStringEqualsXmlString('<root/>', '<root/>');
    try {
      $this
        ->assertXmlStringEqualsXmlString('<foo/>', '<bar/>');
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @expectedException PHPUnit_Framework_Exception
   * @covers            PHPUnit_Framework_Assert::assertXmlStringEqualsXmlString
   * @ticket            1860
   */
  public function testAssertXmlStringEqualsXmlString2() {
    $this
      ->assertXmlStringEqualsXmlString('<a></b>', '<c></d>');
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertXmlStringEqualsXmlString
   * @ticket 1860
   */
  public function testAssertXmlStringEqualsXmlString3() {
    $expected = <<<XML
<?xml version="1.0"?>
<root>
    <node />
</root>
XML;
    $actual = <<<XML
<?xml version="1.0"?>
<root>
<node />
</root>
XML;
    $this
      ->assertXmlStringEqualsXmlString($expected, $actual);
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertXmlStringNotEqualsXmlString
   */
  public function testAssertXmlStringNotEqualsXmlString() {
    $this
      ->assertXmlStringNotEqualsXmlString('<foo/>', '<bar/>');
    try {
      $this
        ->assertXmlStringNotEqualsXmlString('<root/>', '<root/>');
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertEqualXMLStructure
   */
  public function testXMLStructureIsSame() {
    $expected = new DOMDocument();
    $expected
      ->load($this->filesDirectory . 'structureExpected.xml');
    $actual = new DOMDocument();
    $actual
      ->load($this->filesDirectory . 'structureExpected.xml');
    $this
      ->assertEqualXMLStructure($expected->firstChild, $actual->firstChild, true);
  }

  /**
   * @covers            PHPUnit_Framework_Assert::assertEqualXMLStructure
   * @expectedException PHPUnit_Framework_ExpectationFailedException
   */
  public function testXMLStructureWrongNumberOfAttributes() {
    $expected = new DOMDocument();
    $expected
      ->load($this->filesDirectory . 'structureExpected.xml');
    $actual = new DOMDocument();
    $actual
      ->load($this->filesDirectory . 'structureWrongNumberOfAttributes.xml');
    $this
      ->assertEqualXMLStructure($expected->firstChild, $actual->firstChild, true);
  }

  /**
   * @covers            PHPUnit_Framework_Assert::assertEqualXMLStructure
   * @expectedException PHPUnit_Framework_ExpectationFailedException
   */
  public function testXMLStructureWrongNumberOfNodes() {
    $expected = new DOMDocument();
    $expected
      ->load($this->filesDirectory . 'structureExpected.xml');
    $actual = new DOMDocument();
    $actual
      ->load($this->filesDirectory . 'structureWrongNumberOfNodes.xml');
    $this
      ->assertEqualXMLStructure($expected->firstChild, $actual->firstChild, true);
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertEqualXMLStructure
   */
  public function testXMLStructureIsSameButDataIsNot() {
    $expected = new DOMDocument();
    $expected
      ->load($this->filesDirectory . 'structureExpected.xml');
    $actual = new DOMDocument();
    $actual
      ->load($this->filesDirectory . 'structureIsSameButDataIsNot.xml');
    $this
      ->assertEqualXMLStructure($expected->firstChild, $actual->firstChild, true);
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertEqualXMLStructure
   */
  public function testXMLStructureAttributesAreSameButValuesAreNot() {
    $expected = new DOMDocument();
    $expected
      ->load($this->filesDirectory . 'structureExpected.xml');
    $actual = new DOMDocument();
    $actual
      ->load($this->filesDirectory . 'structureAttributesAreSameButValuesAreNot.xml');
    $this
      ->assertEqualXMLStructure($expected->firstChild, $actual->firstChild, true);
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertEqualXMLStructure
   */
  public function testXMLStructureIgnoreTextNodes() {
    $expected = new DOMDocument();
    $expected
      ->load($this->filesDirectory . 'structureExpected.xml');
    $actual = new DOMDocument();
    $actual
      ->load($this->filesDirectory . 'structureIgnoreTextNodes.xml');
    $this
      ->assertEqualXMLStructure($expected->firstChild, $actual->firstChild, true);
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertEquals
   */
  public function testAssertStringEqualsNumeric() {
    $this
      ->assertEquals('0', 0);
    try {
      $this
        ->assertEquals('0', 1);
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertNotEquals
   */
  public function testAssertStringEqualsNumeric2() {
    $this
      ->assertNotEquals('A', 0);
  }

  /**
   * @covers            PHPUnit_Framework_Assert::assertFileExists
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testAssertFileExistsThrowsException() {
    $this
      ->assertFileExists(null);
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertFileExists
   */
  public function testAssertFileExists() {
    $this
      ->assertFileExists(__FILE__);
    try {
      $this
        ->assertFileExists(__DIR__ . DIRECTORY_SEPARATOR . 'NotExisting');
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers            PHPUnit_Framework_Assert::assertFileNotExists
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testAssertFileNotExistsThrowsException() {
    $this
      ->assertFileNotExists(null);
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertFileNotExists
   */
  public function testAssertFileNotExists() {
    $this
      ->assertFileNotExists(__DIR__ . DIRECTORY_SEPARATOR . 'NotExisting');
    try {
      $this
        ->assertFileNotExists(__FILE__);
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertObjectHasAttribute
   */
  public function testAssertObjectHasAttribute() {
    $o = new Author('Terry Pratchett');
    $this
      ->assertObjectHasAttribute('name', $o);
    try {
      $this
        ->assertObjectHasAttribute('foo', $o);
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertObjectNotHasAttribute
   */
  public function testAssertObjectNotHasAttribute() {
    $o = new Author('Terry Pratchett');
    $this
      ->assertObjectNotHasAttribute('foo', $o);
    try {
      $this
        ->assertObjectNotHasAttribute('name', $o);
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertNull
   */
  public function testAssertNull() {
    $this
      ->assertNull(null);
    try {
      $this
        ->assertNull(new stdClass());
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertNotNull
   */
  public function testAssertNotNull() {
    $this
      ->assertNotNull(new stdClass());
    try {
      $this
        ->assertNotNull(null);
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertTrue
   */
  public function testAssertTrue() {
    $this
      ->assertTrue(true);
    try {
      $this
        ->assertTrue(false);
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertNotTrue
   */
  public function testAssertNotTrue() {
    $this
      ->assertNotTrue(false);
    $this
      ->assertNotTrue(1);
    $this
      ->assertNotTrue('true');
    try {
      $this
        ->assertNotTrue(true);
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertFalse
   */
  public function testAssertFalse() {
    $this
      ->assertFalse(false);
    try {
      $this
        ->assertFalse(true);
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertNotFalse
   */
  public function testAssertNotFalse() {
    $this
      ->assertNotFalse(true);
    $this
      ->assertNotFalse(0);
    $this
      ->assertNotFalse('');
    try {
      $this
        ->assertNotFalse(false);
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers            PHPUnit_Framework_Assert::assertRegExp
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testAssertRegExpThrowsException() {
    $this
      ->assertRegExp(null, null);
  }

  /**
   * @covers            PHPUnit_Framework_Assert::assertRegExp
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testAssertRegExpThrowsException2() {
    $this
      ->assertRegExp('', null);
  }

  /**
   * @covers            PHPUnit_Framework_Assert::assertNotRegExp
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testAssertNotRegExpThrowsException() {
    $this
      ->assertNotRegExp(null, null);
  }

  /**
   * @covers            PHPUnit_Framework_Assert::assertNotRegExp
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testAssertNotRegExpThrowsException2() {
    $this
      ->assertNotRegExp('', null);
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertRegExp
   */
  public function testAssertRegExp() {
    $this
      ->assertRegExp('/foo/', 'foobar');
    try {
      $this
        ->assertRegExp('/foo/', 'bar');
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertNotRegExp
   */
  public function testAssertNotRegExp() {
    $this
      ->assertNotRegExp('/foo/', 'bar');
    try {
      $this
        ->assertNotRegExp('/foo/', 'foobar');
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertSame
   */
  public function testAssertSame() {
    $o = new stdClass();
    $this
      ->assertSame($o, $o);
    try {
      $this
        ->assertSame(new stdClass(), new stdClass());
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertSame
   */
  public function testAssertSame2() {
    $this
      ->assertSame(true, true);
    $this
      ->assertSame(false, false);
    try {
      $this
        ->assertSame(true, false);
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertNotSame
   */
  public function testAssertNotSame() {
    $this
      ->assertNotSame(new stdClass(), null);
    $this
      ->assertNotSame(null, new stdClass());
    $this
      ->assertNotSame(new stdClass(), new stdClass());
    $o = new stdClass();
    try {
      $this
        ->assertNotSame($o, $o);
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertNotSame
   */
  public function testAssertNotSame2() {
    $this
      ->assertNotSame(true, false);
    $this
      ->assertNotSame(false, true);
    try {
      $this
        ->assertNotSame(true, true);
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertNotSame
   */
  public function testAssertNotSameFailsNull() {
    try {
      $this
        ->assertNotSame(null, null);
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertGreaterThan
   */
  public function testGreaterThan() {
    $this
      ->assertGreaterThan(1, 2);
    try {
      $this
        ->assertGreaterThan(2, 1);
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertAttributeGreaterThan
   */
  public function testAttributeGreaterThan() {
    $this
      ->assertAttributeGreaterThan(1, 'bar', new ClassWithNonPublicAttributes());
    try {
      $this
        ->assertAttributeGreaterThan(1, 'foo', new ClassWithNonPublicAttributes());
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertGreaterThanOrEqual
   */
  public function testGreaterThanOrEqual() {
    $this
      ->assertGreaterThanOrEqual(1, 2);
    try {
      $this
        ->assertGreaterThanOrEqual(2, 1);
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertAttributeGreaterThanOrEqual
   */
  public function testAttributeGreaterThanOrEqual() {
    $this
      ->assertAttributeGreaterThanOrEqual(1, 'bar', new ClassWithNonPublicAttributes());
    try {
      $this
        ->assertAttributeGreaterThanOrEqual(2, 'foo', new ClassWithNonPublicAttributes());
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertLessThan
   */
  public function testLessThan() {
    $this
      ->assertLessThan(2, 1);
    try {
      $this
        ->assertLessThan(1, 2);
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertAttributeLessThan
   */
  public function testAttributeLessThan() {
    $this
      ->assertAttributeLessThan(2, 'foo', new ClassWithNonPublicAttributes());
    try {
      $this
        ->assertAttributeLessThan(1, 'bar', new ClassWithNonPublicAttributes());
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertLessThanOrEqual
   */
  public function testLessThanOrEqual() {
    $this
      ->assertLessThanOrEqual(2, 1);
    try {
      $this
        ->assertLessThanOrEqual(1, 2);
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertAttributeLessThanOrEqual
   */
  public function testAttributeLessThanOrEqual() {
    $this
      ->assertAttributeLessThanOrEqual(2, 'foo', new ClassWithNonPublicAttributes());
    try {
      $this
        ->assertAttributeLessThanOrEqual(1, 'bar', new ClassWithNonPublicAttributes());
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::readAttribute
   * @covers PHPUnit_Framework_Assert::getStaticAttribute
   * @covers PHPUnit_Framework_Assert::getObjectAttribute
   */
  public function testReadAttribute() {
    $obj = new ClassWithNonPublicAttributes();
    $this
      ->assertEquals('foo', $this
      ->readAttribute($obj, 'publicAttribute'));
    $this
      ->assertEquals('bar', $this
      ->readAttribute($obj, 'protectedAttribute'));
    $this
      ->assertEquals('baz', $this
      ->readAttribute($obj, 'privateAttribute'));
    $this
      ->assertEquals('bar', $this
      ->readAttribute($obj, 'protectedParentAttribute'));

    //$this->assertEquals('bar', $this->readAttribute($obj, 'privateParentAttribute'));
  }

  /**
   * @covers PHPUnit_Framework_Assert::readAttribute
   * @covers PHPUnit_Framework_Assert::getStaticAttribute
   * @covers PHPUnit_Framework_Assert::getObjectAttribute
   */
  public function testReadAttribute2() {
    $this
      ->assertEquals('foo', $this
      ->readAttribute('ClassWithNonPublicAttributes', 'publicStaticAttribute'));
    $this
      ->assertEquals('bar', $this
      ->readAttribute('ClassWithNonPublicAttributes', 'protectedStaticAttribute'));
    $this
      ->assertEquals('baz', $this
      ->readAttribute('ClassWithNonPublicAttributes', 'privateStaticAttribute'));
    $this
      ->assertEquals('foo', $this
      ->readAttribute('ClassWithNonPublicAttributes', 'protectedStaticParentAttribute'));
    $this
      ->assertEquals('foo', $this
      ->readAttribute('ClassWithNonPublicAttributes', 'privateStaticParentAttribute'));
  }

  /**
   * @covers            PHPUnit_Framework_Assert::readAttribute
   * @covers            PHPUnit_Framework_Assert::getStaticAttribute
   * @covers            PHPUnit_Framework_Assert::getObjectAttribute
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testReadAttribute3() {
    $this
      ->readAttribute('StdClass', null);
  }

  /**
   * @covers            PHPUnit_Framework_Assert::readAttribute
   * @covers            PHPUnit_Framework_Assert::getStaticAttribute
   * @covers            PHPUnit_Framework_Assert::getObjectAttribute
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testReadAttribute4() {
    $this
      ->readAttribute('NotExistingClass', 'foo');
  }

  /**
   * @covers            PHPUnit_Framework_Assert::readAttribute
   * @covers            PHPUnit_Framework_Assert::getStaticAttribute
   * @covers            PHPUnit_Framework_Assert::getObjectAttribute
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testReadAttribute5() {
    $this
      ->readAttribute(null, 'foo');
  }

  /**
   * @covers            PHPUnit_Framework_Assert::readAttribute
   * @covers            PHPUnit_Framework_Assert::getStaticAttribute
   * @covers            PHPUnit_Framework_Assert::getObjectAttribute
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testReadAttributeIfAttributeNameIsNotValid() {
    $this
      ->readAttribute('StdClass', '2');
  }

  /**
   * @covers PHPUnit_Framework_Assert::getStaticAttribute
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testGetStaticAttributeRaisesExceptionForInvalidFirstArgument() {
    $this
      ->getStaticAttribute(null, 'foo');
  }

  /**
   * @covers PHPUnit_Framework_Assert::getStaticAttribute
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testGetStaticAttributeRaisesExceptionForInvalidFirstArgument2() {
    $this
      ->getStaticAttribute('NotExistingClass', 'foo');
  }

  /**
   * @covers PHPUnit_Framework_Assert::getStaticAttribute
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testGetStaticAttributeRaisesExceptionForInvalidSecondArgument() {
    $this
      ->getStaticAttribute('stdClass', null);
  }

  /**
   * @covers PHPUnit_Framework_Assert::getStaticAttribute
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testGetStaticAttributeRaisesExceptionForInvalidSecondArgument2() {
    $this
      ->getStaticAttribute('stdClass', '0');
  }

  /**
   * @covers PHPUnit_Framework_Assert::getStaticAttribute
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testGetStaticAttributeRaisesExceptionForInvalidSecondArgument3() {
    $this
      ->getStaticAttribute('stdClass', 'foo');
  }

  /**
   * @covers PHPUnit_Framework_Assert::getObjectAttribute
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testGetObjectAttributeRaisesExceptionForInvalidFirstArgument() {
    $this
      ->getObjectAttribute(null, 'foo');
  }

  /**
   * @covers PHPUnit_Framework_Assert::getObjectAttribute
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testGetObjectAttributeRaisesExceptionForInvalidSecondArgument() {
    $this
      ->getObjectAttribute(new stdClass(), null);
  }

  /**
   * @covers PHPUnit_Framework_Assert::getObjectAttribute
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testGetObjectAttributeRaisesExceptionForInvalidSecondArgument2() {
    $this
      ->getObjectAttribute(new stdClass(), '0');
  }

  /**
   * @covers PHPUnit_Framework_Assert::getObjectAttribute
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testGetObjectAttributeRaisesExceptionForInvalidSecondArgument3() {
    $this
      ->getObjectAttribute(new stdClass(), 'foo');
  }

  /**
   * @covers PHPUnit_Framework_Assert::getObjectAttribute
   */
  public function testGetObjectAttributeWorksForInheritedAttributes() {
    $this
      ->assertEquals('bar', $this
      ->getObjectAttribute(new ClassWithNonPublicAttributes(), 'privateParentAttribute'));
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertAttributeContains
   */
  public function testAssertPublicAttributeContains() {
    $obj = new ClassWithNonPublicAttributes();
    $this
      ->assertAttributeContains('foo', 'publicArray', $obj);
    try {
      $this
        ->assertAttributeContains('bar', 'publicArray', $obj);
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertAttributeContainsOnly
   */
  public function testAssertPublicAttributeContainsOnly() {
    $obj = new ClassWithNonPublicAttributes();
    $this
      ->assertAttributeContainsOnly('string', 'publicArray', $obj);
    try {
      $this
        ->assertAttributeContainsOnly('integer', 'publicArray', $obj);
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertAttributeNotContains
   */
  public function testAssertPublicAttributeNotContains() {
    $obj = new ClassWithNonPublicAttributes();
    $this
      ->assertAttributeNotContains('bar', 'publicArray', $obj);
    try {
      $this
        ->assertAttributeNotContains('foo', 'publicArray', $obj);
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertAttributeNotContainsOnly
   */
  public function testAssertPublicAttributeNotContainsOnly() {
    $obj = new ClassWithNonPublicAttributes();
    $this
      ->assertAttributeNotContainsOnly('integer', 'publicArray', $obj);
    try {
      $this
        ->assertAttributeNotContainsOnly('string', 'publicArray', $obj);
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertAttributeContains
   */
  public function testAssertProtectedAttributeContains() {
    $obj = new ClassWithNonPublicAttributes();
    $this
      ->assertAttributeContains('bar', 'protectedArray', $obj);
    try {
      $this
        ->assertAttributeContains('foo', 'protectedArray', $obj);
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertAttributeNotContains
   */
  public function testAssertProtectedAttributeNotContains() {
    $obj = new ClassWithNonPublicAttributes();
    $this
      ->assertAttributeNotContains('foo', 'protectedArray', $obj);
    try {
      $this
        ->assertAttributeNotContains('bar', 'protectedArray', $obj);
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertAttributeContains
   */
  public function testAssertPrivateAttributeContains() {
    $obj = new ClassWithNonPublicAttributes();
    $this
      ->assertAttributeContains('baz', 'privateArray', $obj);
    try {
      $this
        ->assertAttributeContains('foo', 'privateArray', $obj);
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertAttributeNotContains
   */
  public function testAssertPrivateAttributeNotContains() {
    $obj = new ClassWithNonPublicAttributes();
    $this
      ->assertAttributeNotContains('foo', 'privateArray', $obj);
    try {
      $this
        ->assertAttributeNotContains('baz', 'privateArray', $obj);
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertAttributeContains
   */
  public function testAssertAttributeContainsNonObject() {
    $obj = new ClassWithNonPublicAttributes();
    $this
      ->assertAttributeContains(true, 'privateArray', $obj);
    try {
      $this
        ->assertAttributeContains(true, 'privateArray', $obj, '', false, true, true);
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertAttributeNotContains
   */
  public function testAssertAttributeNotContainsNonObject() {
    $obj = new ClassWithNonPublicAttributes();
    $this
      ->assertAttributeNotContains(true, 'privateArray', $obj, '', false, true, true);
    try {
      $this
        ->assertAttributeNotContains(true, 'privateArray', $obj);
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertAttributeEquals
   */
  public function testAssertPublicAttributeEquals() {
    $obj = new ClassWithNonPublicAttributes();
    $this
      ->assertAttributeEquals('foo', 'publicAttribute', $obj);
    try {
      $this
        ->assertAttributeEquals('bar', 'publicAttribute', $obj);
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertAttributeNotEquals
   */
  public function testAssertPublicAttributeNotEquals() {
    $obj = new ClassWithNonPublicAttributes();
    $this
      ->assertAttributeNotEquals('bar', 'publicAttribute', $obj);
    try {
      $this
        ->assertAttributeNotEquals('foo', 'publicAttribute', $obj);
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertAttributeSame
   */
  public function testAssertPublicAttributeSame() {
    $obj = new ClassWithNonPublicAttributes();
    $this
      ->assertAttributeSame('foo', 'publicAttribute', $obj);
    try {
      $this
        ->assertAttributeSame('bar', 'publicAttribute', $obj);
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertAttributeNotSame
   */
  public function testAssertPublicAttributeNotSame() {
    $obj = new ClassWithNonPublicAttributes();
    $this
      ->assertAttributeNotSame('bar', 'publicAttribute', $obj);
    try {
      $this
        ->assertAttributeNotSame('foo', 'publicAttribute', $obj);
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertAttributeEquals
   */
  public function testAssertProtectedAttributeEquals() {
    $obj = new ClassWithNonPublicAttributes();
    $this
      ->assertAttributeEquals('bar', 'protectedAttribute', $obj);
    try {
      $this
        ->assertAttributeEquals('foo', 'protectedAttribute', $obj);
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertAttributeNotEquals
   */
  public function testAssertProtectedAttributeNotEquals() {
    $obj = new ClassWithNonPublicAttributes();
    $this
      ->assertAttributeNotEquals('foo', 'protectedAttribute', $obj);
    try {
      $this
        ->assertAttributeNotEquals('bar', 'protectedAttribute', $obj);
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertAttributeEquals
   */
  public function testAssertPrivateAttributeEquals() {
    $obj = new ClassWithNonPublicAttributes();
    $this
      ->assertAttributeEquals('baz', 'privateAttribute', $obj);
    try {
      $this
        ->assertAttributeEquals('foo', 'privateAttribute', $obj);
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertAttributeNotEquals
   */
  public function testAssertPrivateAttributeNotEquals() {
    $obj = new ClassWithNonPublicAttributes();
    $this
      ->assertAttributeNotEquals('foo', 'privateAttribute', $obj);
    try {
      $this
        ->assertAttributeNotEquals('baz', 'privateAttribute', $obj);
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertAttributeEquals
   */
  public function testAssertPublicStaticAttributeEquals() {
    $this
      ->assertAttributeEquals('foo', 'publicStaticAttribute', 'ClassWithNonPublicAttributes');
    try {
      $this
        ->assertAttributeEquals('bar', 'publicStaticAttribute', 'ClassWithNonPublicAttributes');
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertAttributeNotEquals
   */
  public function testAssertPublicStaticAttributeNotEquals() {
    $this
      ->assertAttributeNotEquals('bar', 'publicStaticAttribute', 'ClassWithNonPublicAttributes');
    try {
      $this
        ->assertAttributeNotEquals('foo', 'publicStaticAttribute', 'ClassWithNonPublicAttributes');
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertAttributeEquals
   */
  public function testAssertProtectedStaticAttributeEquals() {
    $this
      ->assertAttributeEquals('bar', 'protectedStaticAttribute', 'ClassWithNonPublicAttributes');
    try {
      $this
        ->assertAttributeEquals('foo', 'protectedStaticAttribute', 'ClassWithNonPublicAttributes');
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertAttributeNotEquals
   */
  public function testAssertProtectedStaticAttributeNotEquals() {
    $this
      ->assertAttributeNotEquals('foo', 'protectedStaticAttribute', 'ClassWithNonPublicAttributes');
    try {
      $this
        ->assertAttributeNotEquals('bar', 'protectedStaticAttribute', 'ClassWithNonPublicAttributes');
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertAttributeEquals
   */
  public function testAssertPrivateStaticAttributeEquals() {
    $this
      ->assertAttributeEquals('baz', 'privateStaticAttribute', 'ClassWithNonPublicAttributes');
    try {
      $this
        ->assertAttributeEquals('foo', 'privateStaticAttribute', 'ClassWithNonPublicAttributes');
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertAttributeNotEquals
   */
  public function testAssertPrivateStaticAttributeNotEquals() {
    $this
      ->assertAttributeNotEquals('foo', 'privateStaticAttribute', 'ClassWithNonPublicAttributes');
    try {
      $this
        ->assertAttributeNotEquals('baz', 'privateStaticAttribute', 'ClassWithNonPublicAttributes');
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers            PHPUnit_Framework_Assert::assertClassHasAttribute
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testAssertClassHasAttributeThrowsException() {
    $this
      ->assertClassHasAttribute(null, null);
  }

  /**
   * @covers            PHPUnit_Framework_Assert::assertClassHasAttribute
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testAssertClassHasAttributeThrowsException2() {
    $this
      ->assertClassHasAttribute('foo', null);
  }

  /**
   * @covers            PHPUnit_Framework_Assert::assertClassHasAttribute
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testAssertClassHasAttributeThrowsExceptionIfAttributeNameIsNotValid() {
    $this
      ->assertClassHasAttribute('1', 'ClassWithNonPublicAttributes');
  }

  /**
   * @covers            PHPUnit_Framework_Assert::assertClassNotHasAttribute
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testAssertClassNotHasAttributeThrowsException() {
    $this
      ->assertClassNotHasAttribute(null, null);
  }

  /**
   * @covers            PHPUnit_Framework_Assert::assertClassNotHasAttribute
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testAssertClassNotHasAttributeThrowsException2() {
    $this
      ->assertClassNotHasAttribute('foo', null);
  }

  /**
   * @covers            PHPUnit_Framework_Assert::assertClassNotHasAttribute
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testAssertClassNotHasAttributeThrowsExceptionIfAttributeNameIsNotValid() {
    $this
      ->assertClassNotHasAttribute('1', 'ClassWithNonPublicAttributes');
  }

  /**
   * @covers            PHPUnit_Framework_Assert::assertClassHasStaticAttribute
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testAssertClassHasStaticAttributeThrowsException() {
    $this
      ->assertClassHasStaticAttribute(null, null);
  }

  /**
   * @covers            PHPUnit_Framework_Assert::assertClassHasStaticAttribute
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testAssertClassHasStaticAttributeThrowsException2() {
    $this
      ->assertClassHasStaticAttribute('foo', null);
  }

  /**
   * @covers            PHPUnit_Framework_Assert::assertClassHasStaticAttribute
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testAssertClassHasStaticAttributeThrowsExceptionIfAttributeNameIsNotValid() {
    $this
      ->assertClassHasStaticAttribute('1', 'ClassWithNonPublicAttributes');
  }

  /**
   * @covers            PHPUnit_Framework_Assert::assertClassNotHasStaticAttribute
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testAssertClassNotHasStaticAttributeThrowsException() {
    $this
      ->assertClassNotHasStaticAttribute(null, null);
  }

  /**
   * @covers            PHPUnit_Framework_Assert::assertClassNotHasStaticAttribute
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testAssertClassNotHasStaticAttributeThrowsException2() {
    $this
      ->assertClassNotHasStaticAttribute('foo', null);
  }

  /**
   * @covers            PHPUnit_Framework_Assert::assertClassNotHasStaticAttribute
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testAssertClassNotHasStaticAttributeThrowsExceptionIfAttributeNameIsNotValid() {
    $this
      ->assertClassNotHasStaticAttribute('1', 'ClassWithNonPublicAttributes');
  }

  /**
   * @covers            PHPUnit_Framework_Assert::assertObjectHasAttribute
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testAssertObjectHasAttributeThrowsException() {
    $this
      ->assertObjectHasAttribute(null, null);
  }

  /**
   * @covers            PHPUnit_Framework_Assert::assertObjectHasAttribute
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testAssertObjectHasAttributeThrowsException2() {
    $this
      ->assertObjectHasAttribute('foo', null);
  }

  /**
   * @covers            PHPUnit_Framework_Assert::assertObjectHasAttribute
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testAssertObjectHasAttributeThrowsExceptionIfAttributeNameIsNotValid() {
    $this
      ->assertObjectHasAttribute('1', 'ClassWithNonPublicAttributes');
  }

  /**
   * @covers            PHPUnit_Framework_Assert::assertObjectNotHasAttribute
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testAssertObjectNotHasAttributeThrowsException() {
    $this
      ->assertObjectNotHasAttribute(null, null);
  }

  /**
   * @covers            PHPUnit_Framework_Assert::assertObjectNotHasAttribute
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testAssertObjectNotHasAttributeThrowsException2() {
    $this
      ->assertObjectNotHasAttribute('foo', null);
  }

  /**
   * @covers            PHPUnit_Framework_Assert::assertObjectNotHasAttribute
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testAssertObjectNotHasAttributeThrowsExceptionIfAttributeNameIsNotValid() {
    $this
      ->assertObjectNotHasAttribute('1', 'ClassWithNonPublicAttributes');
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertClassHasAttribute
   */
  public function testClassHasPublicAttribute() {
    $this
      ->assertClassHasAttribute('publicAttribute', 'ClassWithNonPublicAttributes');
    try {
      $this
        ->assertClassHasAttribute('attribute', 'ClassWithNonPublicAttributes');
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertClassNotHasAttribute
   */
  public function testClassNotHasPublicAttribute() {
    $this
      ->assertClassNotHasAttribute('attribute', 'ClassWithNonPublicAttributes');
    try {
      $this
        ->assertClassNotHasAttribute('publicAttribute', 'ClassWithNonPublicAttributes');
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertClassHasStaticAttribute
   */
  public function testClassHasPublicStaticAttribute() {
    $this
      ->assertClassHasStaticAttribute('publicStaticAttribute', 'ClassWithNonPublicAttributes');
    try {
      $this
        ->assertClassHasStaticAttribute('attribute', 'ClassWithNonPublicAttributes');
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertClassNotHasStaticAttribute
   */
  public function testClassNotHasPublicStaticAttribute() {
    $this
      ->assertClassNotHasStaticAttribute('attribute', 'ClassWithNonPublicAttributes');
    try {
      $this
        ->assertClassNotHasStaticAttribute('publicStaticAttribute', 'ClassWithNonPublicAttributes');
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertObjectHasAttribute
   */
  public function testObjectHasPublicAttribute() {
    $obj = new ClassWithNonPublicAttributes();
    $this
      ->assertObjectHasAttribute('publicAttribute', $obj);
    try {
      $this
        ->assertObjectHasAttribute('attribute', $obj);
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertObjectNotHasAttribute
   */
  public function testObjectNotHasPublicAttribute() {
    $obj = new ClassWithNonPublicAttributes();
    $this
      ->assertObjectNotHasAttribute('attribute', $obj);
    try {
      $this
        ->assertObjectNotHasAttribute('publicAttribute', $obj);
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertObjectHasAttribute
   */
  public function testObjectHasOnTheFlyAttribute() {
    $obj = new stdClass();
    $obj->foo = 'bar';
    $this
      ->assertObjectHasAttribute('foo', $obj);
    try {
      $this
        ->assertObjectHasAttribute('bar', $obj);
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertObjectNotHasAttribute
   */
  public function testObjectNotHasOnTheFlyAttribute() {
    $obj = new stdClass();
    $obj->foo = 'bar';
    $this
      ->assertObjectNotHasAttribute('bar', $obj);
    try {
      $this
        ->assertObjectNotHasAttribute('foo', $obj);
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertObjectHasAttribute
   */
  public function testObjectHasProtectedAttribute() {
    $obj = new ClassWithNonPublicAttributes();
    $this
      ->assertObjectHasAttribute('protectedAttribute', $obj);
    try {
      $this
        ->assertObjectHasAttribute('attribute', $obj);
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertObjectNotHasAttribute
   */
  public function testObjectNotHasProtectedAttribute() {
    $obj = new ClassWithNonPublicAttributes();
    $this
      ->assertObjectNotHasAttribute('attribute', $obj);
    try {
      $this
        ->assertObjectNotHasAttribute('protectedAttribute', $obj);
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertObjectHasAttribute
   */
  public function testObjectHasPrivateAttribute() {
    $obj = new ClassWithNonPublicAttributes();
    $this
      ->assertObjectHasAttribute('privateAttribute', $obj);
    try {
      $this
        ->assertObjectHasAttribute('attribute', $obj);
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertObjectNotHasAttribute
   */
  public function testObjectNotHasPrivateAttribute() {
    $obj = new ClassWithNonPublicAttributes();
    $this
      ->assertObjectNotHasAttribute('attribute', $obj);
    try {
      $this
        ->assertObjectNotHasAttribute('privateAttribute', $obj);
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertThat
   * @covers PHPUnit_Framework_Assert::attribute
   * @covers PHPUnit_Framework_Assert::equalTo
   */
  public function testAssertThatAttributeEquals() {
    $this
      ->assertThat(new ClassWithNonPublicAttributes(), $this
      ->attribute($this
      ->equalTo('foo'), 'publicAttribute'));
  }

  /**
   * @covers            PHPUnit_Framework_Assert::assertThat
   * @covers            PHPUnit_Framework_Assert::attribute
   * @covers            PHPUnit_Framework_Assert::equalTo
   * @expectedException PHPUnit_Framework_AssertionFailedError
   */
  public function testAssertThatAttributeEquals2() {
    $this
      ->assertThat(new ClassWithNonPublicAttributes(), $this
      ->attribute($this
      ->equalTo('bar'), 'publicAttribute'));
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertThat
   * @covers PHPUnit_Framework_Assert::attribute
   * @covers PHPUnit_Framework_Assert::equalTo
   */
  public function testAssertThatAttributeEqualTo() {
    $this
      ->assertThat(new ClassWithNonPublicAttributes(), $this
      ->attributeEqualTo('publicAttribute', 'foo'));
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertThat
   * @covers PHPUnit_Framework_Assert::anything
   */
  public function testAssertThatAnything() {
    $this
      ->assertThat('anything', $this
      ->anything());
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertThat
   * @covers PHPUnit_Framework_Assert::isTrue
   */
  public function testAssertThatIsTrue() {
    $this
      ->assertThat(true, $this
      ->isTrue());
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertThat
   * @covers PHPUnit_Framework_Assert::isFalse
   */
  public function testAssertThatIsFalse() {
    $this
      ->assertThat(false, $this
      ->isFalse());
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertThat
   * @covers PHPUnit_Framework_Assert::isJson
   */
  public function testAssertThatIsJson() {
    $this
      ->assertThat('{}', $this
      ->isJson());
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertThat
   * @covers PHPUnit_Framework_Assert::anything
   * @covers PHPUnit_Framework_Assert::logicalAnd
   */
  public function testAssertThatAnythingAndAnything() {
    $this
      ->assertThat('anything', $this
      ->logicalAnd($this
      ->anything(), $this
      ->anything()));
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertThat
   * @covers PHPUnit_Framework_Assert::anything
   * @covers PHPUnit_Framework_Assert::logicalOr
   */
  public function testAssertThatAnythingOrAnything() {
    $this
      ->assertThat('anything', $this
      ->logicalOr($this
      ->anything(), $this
      ->anything()));
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertThat
   * @covers PHPUnit_Framework_Assert::anything
   * @covers PHPUnit_Framework_Assert::logicalNot
   * @covers PHPUnit_Framework_Assert::logicalXor
   */
  public function testAssertThatAnythingXorNotAnything() {
    $this
      ->assertThat('anything', $this
      ->logicalXor($this
      ->anything(), $this
      ->logicalNot($this
      ->anything())));
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertThat
   * @covers PHPUnit_Framework_Assert::contains
   */
  public function testAssertThatContains() {
    $this
      ->assertThat(array(
      'foo',
    ), $this
      ->contains('foo'));
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertThat
   * @covers PHPUnit_Framework_Assert::stringContains
   */
  public function testAssertThatStringContains() {
    $this
      ->assertThat('barfoobar', $this
      ->stringContains('foo'));
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertThat
   * @covers PHPUnit_Framework_Assert::containsOnly
   */
  public function testAssertThatContainsOnly() {
    $this
      ->assertThat(array(
      'foo',
    ), $this
      ->containsOnly('string'));
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertThat
   * @covers PHPUnit_Framework_Assert::containsOnlyInstancesOf
   */
  public function testAssertThatContainsOnlyInstancesOf() {
    $this
      ->assertThat(array(
      new Book(),
    ), $this
      ->containsOnlyInstancesOf('Book'));
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertThat
   * @covers PHPUnit_Framework_Assert::arrayHasKey
   */
  public function testAssertThatArrayHasKey() {
    $this
      ->assertThat(array(
      'foo' => 'bar',
    ), $this
      ->arrayHasKey('foo'));
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertThat
   * @covers PHPUnit_Framework_Assert::classHasAttribute
   */
  public function testAssertThatClassHasAttribute() {
    $this
      ->assertThat(new ClassWithNonPublicAttributes(), $this
      ->classHasAttribute('publicAttribute'));
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertThat
   * @covers PHPUnit_Framework_Assert::classHasStaticAttribute
   */
  public function testAssertThatClassHasStaticAttribute() {
    $this
      ->assertThat(new ClassWithNonPublicAttributes(), $this
      ->classHasStaticAttribute('publicStaticAttribute'));
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertThat
   * @covers PHPUnit_Framework_Assert::objectHasAttribute
   */
  public function testAssertThatObjectHasAttribute() {
    $this
      ->assertThat(new ClassWithNonPublicAttributes(), $this
      ->objectHasAttribute('publicAttribute'));
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertThat
   * @covers PHPUnit_Framework_Assert::equalTo
   */
  public function testAssertThatEqualTo() {
    $this
      ->assertThat('foo', $this
      ->equalTo('foo'));
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertThat
   * @covers PHPUnit_Framework_Assert::identicalTo
   */
  public function testAssertThatIdenticalTo() {
    $value = new stdClass();
    $constraint = $this
      ->identicalTo($value);
    $this
      ->assertThat($value, $constraint);
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertThat
   * @covers PHPUnit_Framework_Assert::isInstanceOf
   */
  public function testAssertThatIsInstanceOf() {
    $this
      ->assertThat(new stdClass(), $this
      ->isInstanceOf('StdClass'));
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertThat
   * @covers PHPUnit_Framework_Assert::isType
   */
  public function testAssertThatIsType() {
    $this
      ->assertThat('string', $this
      ->isType('string'));
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertThat
   * @covers PHPUnit_Framework_Assert::isEmpty
   */
  public function testAssertThatIsEmpty() {
    $this
      ->assertThat(array(), $this
      ->isEmpty());
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertThat
   * @covers PHPUnit_Framework_Assert::fileExists
   */
  public function testAssertThatFileExists() {
    $this
      ->assertThat(__FILE__, $this
      ->fileExists());
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertThat
   * @covers PHPUnit_Framework_Assert::greaterThan
   */
  public function testAssertThatGreaterThan() {
    $this
      ->assertThat(2, $this
      ->greaterThan(1));
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertThat
   * @covers PHPUnit_Framework_Assert::greaterThanOrEqual
   */
  public function testAssertThatGreaterThanOrEqual() {
    $this
      ->assertThat(2, $this
      ->greaterThanOrEqual(1));
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertThat
   * @covers PHPUnit_Framework_Assert::lessThan
   */
  public function testAssertThatLessThan() {
    $this
      ->assertThat(1, $this
      ->lessThan(2));
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertThat
   * @covers PHPUnit_Framework_Assert::lessThanOrEqual
   */
  public function testAssertThatLessThanOrEqual() {
    $this
      ->assertThat(1, $this
      ->lessThanOrEqual(2));
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertThat
   * @covers PHPUnit_Framework_Assert::matchesRegularExpression
   */
  public function testAssertThatMatchesRegularExpression() {
    $this
      ->assertThat('foobar', $this
      ->matchesRegularExpression('/foo/'));
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertThat
   * @covers PHPUnit_Framework_Assert::callback
   */
  public function testAssertThatCallback() {
    $this
      ->assertThat(null, $this
      ->callback(function ($other) {
      return true;
    }));
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertThat
   * @covers PHPUnit_Framework_Assert::countOf
   */
  public function testAssertThatCountOf() {
    $this
      ->assertThat(array(
      1,
    ), $this
      ->countOf(1));
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertFileEquals
   */
  public function testAssertFileEquals() {
    $this
      ->assertFileEquals($this->filesDirectory . 'foo.xml', $this->filesDirectory . 'foo.xml');
    try {
      $this
        ->assertFileEquals($this->filesDirectory . 'foo.xml', $this->filesDirectory . 'bar.xml');
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertFileNotEquals
   */
  public function testAssertFileNotEquals() {
    $this
      ->assertFileNotEquals($this->filesDirectory . 'foo.xml', $this->filesDirectory . 'bar.xml');
    try {
      $this
        ->assertFileNotEquals($this->filesDirectory . 'foo.xml', $this->filesDirectory . 'foo.xml');
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertStringEqualsFile
   */
  public function testAssertStringEqualsFile() {
    $this
      ->assertStringEqualsFile($this->filesDirectory . 'foo.xml', file_get_contents($this->filesDirectory . 'foo.xml'));
    try {
      $this
        ->assertStringEqualsFile($this->filesDirectory . 'foo.xml', file_get_contents($this->filesDirectory . 'bar.xml'));
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertStringNotEqualsFile
   */
  public function testAssertStringNotEqualsFile() {
    $this
      ->assertStringNotEqualsFile($this->filesDirectory . 'foo.xml', file_get_contents($this->filesDirectory . 'bar.xml'));
    try {
      $this
        ->assertStringNotEqualsFile($this->filesDirectory . 'foo.xml', file_get_contents($this->filesDirectory . 'foo.xml'));
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers            PHPUnit_Framework_Assert::assertStringStartsWith
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testAssertStringStartsWithThrowsException() {
    $this
      ->assertStringStartsWith(null, null);
  }

  /**
   * @covers            PHPUnit_Framework_Assert::assertStringStartsWith
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testAssertStringStartsWithThrowsException2() {
    $this
      ->assertStringStartsWith('', null);
  }

  /**
   * @covers            PHPUnit_Framework_Assert::assertStringStartsNotWith
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testAssertStringStartsNotWithThrowsException() {
    $this
      ->assertStringStartsNotWith(null, null);
  }

  /**
   * @covers            PHPUnit_Framework_Assert::assertStringStartsNotWith
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testAssertStringStartsNotWithThrowsException2() {
    $this
      ->assertStringStartsNotWith('', null);
  }

  /**
   * @covers            PHPUnit_Framework_Assert::assertStringEndsWith
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testAssertStringEndsWithThrowsException() {
    $this
      ->assertStringEndsWith(null, null);
  }

  /**
   * @covers            PHPUnit_Framework_Assert::assertStringEndsWith
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testAssertStringEndsWithThrowsException2() {
    $this
      ->assertStringEndsWith('', null);
  }

  /**
   * @covers            PHPUnit_Framework_Assert::assertStringEndsNotWith
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testAssertStringEndsNotWithThrowsException() {
    $this
      ->assertStringEndsNotWith(null, null);
  }

  /**
   * @covers            PHPUnit_Framework_Assert::assertStringEndsNotWith
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testAssertStringEndsNotWithThrowsException2() {
    $this
      ->assertStringEndsNotWith('', null);
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertStringStartsWith
   */
  public function testAssertStringStartsWith() {
    $this
      ->assertStringStartsWith('prefix', 'prefixfoo');
    try {
      $this
        ->assertStringStartsWith('prefix', 'foo');
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertStringStartsNotWith
   */
  public function testAssertStringStartsNotWith() {
    $this
      ->assertStringStartsNotWith('prefix', 'foo');
    try {
      $this
        ->assertStringStartsNotWith('prefix', 'prefixfoo');
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertStringEndsWith
   */
  public function testAssertStringEndsWith() {
    $this
      ->assertStringEndsWith('suffix', 'foosuffix');
    try {
      $this
        ->assertStringEndsWith('suffix', 'foo');
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertStringEndsNotWith
   */
  public function testAssertStringEndsNotWith() {
    $this
      ->assertStringEndsNotWith('suffix', 'foo');
    try {
      $this
        ->assertStringEndsNotWith('suffix', 'foosuffix');
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertStringMatchesFormat
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testAssertStringMatchesFormatRaisesExceptionForInvalidFirstArgument() {
    $this
      ->assertStringMatchesFormat(null, '');
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertStringMatchesFormat
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testAssertStringMatchesFormatRaisesExceptionForInvalidSecondArgument() {
    $this
      ->assertStringMatchesFormat('', null);
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertStringMatchesFormat
   */
  public function testAssertStringMatchesFormat() {
    $this
      ->assertStringMatchesFormat('*%s*', '***');
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertStringMatchesFormat
   * @expectedException PHPUnit_Framework_AssertionFailedError
   */
  public function testAssertStringMatchesFormatFailure() {
    $this
      ->assertStringMatchesFormat('*%s*', '**');
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertStringNotMatchesFormat
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testAssertStringNotMatchesFormatRaisesExceptionForInvalidFirstArgument() {
    $this
      ->assertStringNotMatchesFormat(null, '');
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertStringNotMatchesFormat
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testAssertStringNotMatchesFormatRaisesExceptionForInvalidSecondArgument() {
    $this
      ->assertStringNotMatchesFormat('', null);
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertStringNotMatchesFormat
   */
  public function testAssertStringNotMatchesFormat() {
    $this
      ->assertStringNotMatchesFormat('*%s*', '**');
    try {
      $this
        ->assertStringMatchesFormat('*%s*', '**');
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertEmpty
   */
  public function testAssertEmpty() {
    $this
      ->assertEmpty(array());
    try {
      $this
        ->assertEmpty(array(
        'foo',
      ));
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertNotEmpty
   */
  public function testAssertNotEmpty() {
    $this
      ->assertNotEmpty(array(
      'foo',
    ));
    try {
      $this
        ->assertNotEmpty(array());
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertAttributeEmpty
   */
  public function testAssertAttributeEmpty() {
    $o = new stdClass();
    $o->a = array();
    $this
      ->assertAttributeEmpty('a', $o);
    try {
      $o->a = array(
        'b',
      );
      $this
        ->assertAttributeEmpty('a', $o);
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertAttributeNotEmpty
   */
  public function testAssertAttributeNotEmpty() {
    $o = new stdClass();
    $o->a = array(
      'b',
    );
    $this
      ->assertAttributeNotEmpty('a', $o);
    try {
      $o->a = array();
      $this
        ->assertAttributeNotEmpty('a', $o);
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::markTestIncomplete
   */
  public function testMarkTestIncomplete() {
    try {
      $this
        ->markTestIncomplete('incomplete');
    } catch (PHPUnit_Framework_IncompleteTestError $e) {
      $this
        ->assertEquals('incomplete', $e
        ->getMessage());
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::markTestSkipped
   */
  public function testMarkTestSkipped() {
    try {
      $this
        ->markTestSkipped('skipped');
    } catch (PHPUnit_Framework_SkippedTestError $e) {
      $this
        ->assertEquals('skipped', $e
        ->getMessage());
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertCount
   */
  public function testAssertCount() {
    $this
      ->assertCount(2, array(
      1,
      2,
    ));
    try {
      $this
        ->assertCount(2, array(
        1,
        2,
        3,
      ));
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertCount
   */
  public function testAssertCountTraversable() {
    $this
      ->assertCount(2, new ArrayIterator(array(
      1,
      2,
    )));
    try {
      $this
        ->assertCount(2, new ArrayIterator(array(
        1,
        2,
        3,
      )));
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertCount
   */
  public function testAssertCountThrowsExceptionIfExpectedCountIsNoInteger() {
    try {
      $this
        ->assertCount('a', array());
    } catch (PHPUnit_Framework_Exception $e) {
      $this
        ->assertEquals('Argument #1 (No Value) of PHPUnit_Framework_Assert::assertCount() must be a integer', $e
        ->getMessage());
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertCount
   */
  public function testAssertCountThrowsExceptionIfElementIsNotCountable() {
    try {
      $this
        ->assertCount(2, '');
    } catch (PHPUnit_Framework_Exception $e) {
      $this
        ->assertEquals('Argument #2 (No Value) of PHPUnit_Framework_Assert::assertCount() must be a countable or traversable', $e
        ->getMessage());
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertAttributeCount
   */
  public function testAssertAttributeCount() {
    $o = new stdClass();
    $o->a = array();
    $this
      ->assertAttributeCount(0, 'a', $o);
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertNotCount
   */
  public function testAssertNotCount() {
    $this
      ->assertNotCount(2, array(
      1,
      2,
      3,
    ));
    try {
      $this
        ->assertNotCount(2, array(
        1,
        2,
      ));
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertNotCount
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testAssertNotCountThrowsExceptionIfExpectedCountIsNoInteger() {
    $this
      ->assertNotCount('a', array());
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertNotCount
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testAssertNotCountThrowsExceptionIfElementIsNotCountable() {
    $this
      ->assertNotCount(2, '');
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertAttributeNotCount
   */
  public function testAssertAttributeNotCount() {
    $o = new stdClass();
    $o->a = array();
    $this
      ->assertAttributeNotCount(1, 'a', $o);
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertSameSize
   */
  public function testAssertSameSize() {
    $this
      ->assertSameSize(array(
      1,
      2,
    ), array(
      3,
      4,
    ));
    try {
      $this
        ->assertSameSize(array(
        1,
        2,
      ), array(
        1,
        2,
        3,
      ));
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertSameSize
   */
  public function testAssertSameSizeThrowsExceptionIfExpectedIsNotCountable() {
    try {
      $this
        ->assertSameSize('a', array());
    } catch (PHPUnit_Framework_Exception $e) {
      $this
        ->assertEquals('Argument #1 (No Value) of PHPUnit_Framework_Assert::assertSameSize() must be a countable or traversable', $e
        ->getMessage());
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertSameSize
   */
  public function testAssertSameSizeThrowsExceptionIfActualIsNotCountable() {
    try {
      $this
        ->assertSameSize(array(), '');
    } catch (PHPUnit_Framework_Exception $e) {
      $this
        ->assertEquals('Argument #2 (No Value) of PHPUnit_Framework_Assert::assertSameSize() must be a countable or traversable', $e
        ->getMessage());
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertNotSameSize
   */
  public function testAssertNotSameSize() {
    $this
      ->assertNotSameSize(array(
      1,
      2,
    ), array(
      1,
      2,
      3,
    ));
    try {
      $this
        ->assertNotSameSize(array(
        1,
        2,
      ), array(
        3,
        4,
      ));
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertNotSameSize
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testAssertNotSameSizeThrowsExceptionIfExpectedIsNotCountable() {
    $this
      ->assertNotSameSize('a', array());
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertNotSameSize
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testAssertNotSameSizeThrowsExceptionIfActualIsNotCountable() {
    $this
      ->assertNotSameSize(array(), '');
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertJson
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testAssertJsonRaisesExceptionForInvalidArgument() {
    $this
      ->assertJson(null);
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertJson
   */
  public function testAssertJson() {
    $this
      ->assertJson('{}');
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertJsonStringEqualsJsonString
   */
  public function testAssertJsonStringEqualsJsonString() {
    $expected = '{"Mascott" : "Tux"}';
    $actual = '{"Mascott" : "Tux"}';
    $message = 'Given Json strings do not match';
    $this
      ->assertJsonStringEqualsJsonString($expected, $actual, $message);
  }

  /**
   * @dataProvider validInvalidJsonDataprovider
   * @covers PHPUnit_Framework_Assert::assertJsonStringEqualsJsonString
   */
  public function testAssertJsonStringEqualsJsonStringErrorRaised($expected, $actual) {
    try {
      $this
        ->assertJsonStringEqualsJsonString($expected, $actual);
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail('Expected exception not found');
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertJsonStringNotEqualsJsonString
   */
  public function testAssertJsonStringNotEqualsJsonString() {
    $expected = '{"Mascott" : "Beastie"}';
    $actual = '{"Mascott" : "Tux"}';
    $message = 'Given Json strings do match';
    $this
      ->assertJsonStringNotEqualsJsonString($expected, $actual, $message);
  }

  /**
   * @dataProvider validInvalidJsonDataprovider
   * @covers PHPUnit_Framework_Assert::assertJsonStringNotEqualsJsonString
   */
  public function testAssertJsonStringNotEqualsJsonStringErrorRaised($expected, $actual) {
    try {
      $this
        ->assertJsonStringNotEqualsJsonString($expected, $actual);
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail('Expected exception not found');
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertJsonStringEqualsJsonFile
   */
  public function testAssertJsonStringEqualsJsonFile() {
    $file = __DIR__ . '/../_files/JsonData/simpleObject.json';
    $actual = json_encode(array(
      'Mascott' => 'Tux',
    ));
    $message = '';
    $this
      ->assertJsonStringEqualsJsonFile($file, $actual, $message);
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertJsonStringEqualsJsonFile
   */
  public function testAssertJsonStringEqualsJsonFileExpectingExpectationFailedException() {
    $file = __DIR__ . '/../_files/JsonData/simpleObject.json';
    $actual = json_encode(array(
      'Mascott' => 'Beastie',
    ));
    $message = '';
    try {
      $this
        ->assertJsonStringEqualsJsonFile($file, $actual, $message);
    } catch (PHPUnit_Framework_ExpectationFailedException $e) {
      $this
        ->assertEquals('Failed asserting that \'{"Mascott":"Beastie"}\' matches JSON string "{"Mascott":"Tux"}".', $e
        ->getMessage());
      return;
    }
    $this
      ->fail('Expected Exception not thrown.');
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertJsonStringEqualsJsonFile
   */
  public function testAssertJsonStringEqualsJsonFileExpectingException() {
    $file = __DIR__ . '/../_files/JsonData/simpleObject.json';
    try {
      $this
        ->assertJsonStringEqualsJsonFile($file, null);
    } catch (PHPUnit_Framework_Exception $e) {
      return;
    }
    $this
      ->fail('Expected Exception not thrown.');
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertJsonStringNotEqualsJsonFile
   */
  public function testAssertJsonStringNotEqualsJsonFile() {
    $file = __DIR__ . '/../_files/JsonData/simpleObject.json';
    $actual = json_encode(array(
      'Mascott' => 'Beastie',
    ));
    $message = '';
    $this
      ->assertJsonStringNotEqualsJsonFile($file, $actual, $message);
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertJsonStringNotEqualsJsonFile
   */
  public function testAssertJsonStringNotEqualsJsonFileExpectingException() {
    $file = __DIR__ . '/../_files/JsonData/simpleObject.json';
    try {
      $this
        ->assertJsonStringNotEqualsJsonFile($file, null);
    } catch (PHPUnit_Framework_Exception $e) {
      return;
    }
    $this
      ->fail('Expected exception not found.');
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertJsonFileNotEqualsJsonFile
   */
  public function testAssertJsonFileNotEqualsJsonFile() {
    $fileExpected = __DIR__ . '/../_files/JsonData/simpleObject.json';
    $fileActual = __DIR__ . '/../_files/JsonData/arrayObject.json';
    $message = '';
    $this
      ->assertJsonFileNotEqualsJsonFile($fileExpected, $fileActual, $message);
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertJsonFileEqualsJsonFile
   */
  public function testAssertJsonFileEqualsJsonFile() {
    $file = __DIR__ . '/../_files/JsonData/simpleObject.json';
    $message = '';
    $this
      ->assertJsonFileEqualsJsonFile($file, $file, $message);
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertInstanceOf
   */
  public function testAssertInstanceOf() {
    $this
      ->assertInstanceOf('stdClass', new stdClass());
    try {
      $this
        ->assertInstanceOf('Exception', new stdClass());
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertInstanceOf
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testAssertInstanceOfThrowsExceptionForInvalidArgument() {
    $this
      ->assertInstanceOf(null, new stdClass());
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertAttributeInstanceOf
   */
  public function testAssertAttributeInstanceOf() {
    $o = new stdClass();
    $o->a = new stdClass();
    $this
      ->assertAttributeInstanceOf('stdClass', 'a', $o);
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertNotInstanceOf
   */
  public function testAssertNotInstanceOf() {
    $this
      ->assertNotInstanceOf('Exception', new stdClass());
    try {
      $this
        ->assertNotInstanceOf('stdClass', new stdClass());
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertNotInstanceOf
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testAssertNotInstanceOfThrowsExceptionForInvalidArgument() {
    $this
      ->assertNotInstanceOf(null, new stdClass());
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertAttributeNotInstanceOf
   */
  public function testAssertAttributeNotInstanceOf() {
    $o = new stdClass();
    $o->a = new stdClass();
    $this
      ->assertAttributeNotInstanceOf('Exception', 'a', $o);
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertInternalType
   */
  public function testAssertInternalType() {
    $this
      ->assertInternalType('integer', 1);
    try {
      $this
        ->assertInternalType('string', 1);
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertInternalType
   */
  public function testAssertInternalTypeDouble() {
    $this
      ->assertInternalType('double', 1.0);
    try {
      $this
        ->assertInternalType('double', 1);
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertInternalType
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testAssertInternalTypeThrowsExceptionForInvalidArgument() {
    $this
      ->assertInternalType(null, 1);
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertAttributeInternalType
   */
  public function testAssertAttributeInternalType() {
    $o = new stdClass();
    $o->a = 1;
    $this
      ->assertAttributeInternalType('integer', 'a', $o);
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertNotInternalType
   */
  public function testAssertNotInternalType() {
    $this
      ->assertNotInternalType('string', 1);
    try {
      $this
        ->assertNotInternalType('integer', 1);
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertNotInternalType
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testAssertNotInternalTypeThrowsExceptionForInvalidArgument() {
    $this
      ->assertNotInternalType(null, 1);
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertAttributeNotInternalType
   */
  public function testAssertAttributeNotInternalType() {
    $o = new stdClass();
    $o->a = 1;
    $this
      ->assertAttributeNotInternalType('string', 'a', $o);
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertStringMatchesFormatFile
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testAssertStringMatchesFormatFileThrowsExceptionForInvalidArgument() {
    $this
      ->assertStringMatchesFormatFile('not_existing_file', '');
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertStringMatchesFormatFile
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testAssertStringMatchesFormatFileThrowsExceptionForInvalidArgument2() {
    $this
      ->assertStringMatchesFormatFile($this->filesDirectory . 'expectedFileFormat.txt', null);
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertStringMatchesFormatFile
   */
  public function testAssertStringMatchesFormatFile() {
    $this
      ->assertStringMatchesFormatFile($this->filesDirectory . 'expectedFileFormat.txt', "FOO\n");
    try {
      $this
        ->assertStringMatchesFormatFile($this->filesDirectory . 'expectedFileFormat.txt', "BAR\n");
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertStringNotMatchesFormatFile
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testAssertStringNotMatchesFormatFileThrowsExceptionForInvalidArgument() {
    $this
      ->assertStringNotMatchesFormatFile('not_existing_file', '');
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertStringNotMatchesFormatFile
   * @expectedException PHPUnit_Framework_Exception
   */
  public function testAssertStringNotMatchesFormatFileThrowsExceptionForInvalidArgument2() {
    $this
      ->assertStringNotMatchesFormatFile($this->filesDirectory . 'expectedFileFormat.txt', null);
  }

  /**
   * @covers PHPUnit_Framework_Assert::assertStringNotMatchesFormatFile
   */
  public function testAssertStringNotMatchesFormatFile() {
    $this
      ->assertStringNotMatchesFormatFile($this->filesDirectory . 'expectedFileFormat.txt', "BAR\n");
    try {
      $this
        ->assertStringNotMatchesFormatFile($this->filesDirectory . 'expectedFileFormat.txt', "FOO\n");
    } catch (PHPUnit_Framework_AssertionFailedError $e) {
      return;
    }
    $this
      ->fail();
  }

  /**
   * @return array
   */
  public static function validInvalidJsonDataprovider() {
    return array(
      'error syntax in expected JSON' => array(
        '{"Mascott"::}',
        '{"Mascott" : "Tux"}',
      ),
      'error UTF-8 in actual JSON' => array(
        '{"Mascott" : "Tux"}',
        '{"Mascott" : :}',
      ),
    );
  }

}

Members

Namesort descending Modifiers Type Description Overrides
Framework_AssertTest::$filesDirectory private property
Framework_AssertTest::assertArraySubsetInvalidArgumentProvider public function
Framework_AssertTest::equalProvider public function
Framework_AssertTest::equalValues protected function
Framework_AssertTest::notEqualProvider public function
Framework_AssertTest::notEqualValues protected function
Framework_AssertTest::notSameProvider public function
Framework_AssertTest::sameProvider public function
Framework_AssertTest::sameValues protected function
Framework_AssertTest::setUp protected function Sets up the fixture, for example, open a network connection. This method is called before a test is executed. Overrides PHPUnit_Framework_TestCase::setUp
Framework_AssertTest::testAssertArrayContainsNonObject public function @covers PHPUnit_Framework_Assert::assertContains
Framework_AssertTest::testAssertArrayContainsObject public function @covers PHPUnit_Framework_Assert::assertContains
Framework_AssertTest::testAssertArrayContainsOnlyIntegers public function @covers PHPUnit_Framework_Assert::assertContainsOnly
Framework_AssertTest::testAssertArrayContainsOnlyStdClass public function @covers PHPUnit_Framework_Assert::assertContainsOnly
Framework_AssertTest::testAssertArrayContainsString public function @covers PHPUnit_Framework_Assert::assertContains
Framework_AssertTest::testAssertArrayHasIntegerKey public function @covers PHPUnit_Framework_Assert::assertArrayHasKey
Framework_AssertTest::testAssertArrayHasKeyAcceptsArrayAccessValue public function @covers PHPUnit_Framework_Assert::assertArrayHasKey
Framework_AssertTest::testAssertArrayHasKeyAcceptsArrayObjectValue public function @covers PHPUnit_Framework_Assert::assertArrayHasKey
Framework_AssertTest::testAssertArrayHasKeyProperlyFailsWithArrayAccessValue public function @covers PHPUnit_Framework_Assert::assertArrayHasKey @expectedException PHPUnit_Framework_AssertionFailedError
Framework_AssertTest::testAssertArrayHasKeyProperlyFailsWithArrayObjectValue public function @covers PHPUnit_Framework_Assert::assertArrayHasKey @expectedException PHPUnit_Framework_AssertionFailedError
Framework_AssertTest::testAssertArrayHasKeyThrowsExceptionForInvalidFirstArgument public function @covers PHPUnit_Framework_Assert::assertArrayHasKey @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testAssertArrayHasKeyThrowsExceptionForInvalidSecondArgument public function @covers PHPUnit_Framework_Assert::assertArrayHasKey @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testAssertArrayHasStringKey public function @covers PHPUnit_Framework_Assert::assertArrayHasKey
Framework_AssertTest::testAssertArrayNotContainsNonObject public function @covers PHPUnit_Framework_Assert::assertNotContains
Framework_AssertTest::testAssertArrayNotContainsObject public function @covers PHPUnit_Framework_Assert::assertNotContains
Framework_AssertTest::testAssertArrayNotContainsOnlyIntegers public function @covers PHPUnit_Framework_Assert::assertNotContainsOnly
Framework_AssertTest::testAssertArrayNotContainsOnlyStdClass public function @covers PHPUnit_Framework_Assert::assertNotContainsOnly
Framework_AssertTest::testAssertArrayNotContainsString public function @covers PHPUnit_Framework_Assert::assertNotContains
Framework_AssertTest::testAssertArrayNotHasIntegerKey public function @covers PHPUnit_Framework_Assert::assertArrayNotHasKey
Framework_AssertTest::testAssertArrayNotHasKeyAcceptsArrayAccessValue public function @covers PHPUnit_Framework_Assert::assertArrayNotHasKey
Framework_AssertTest::testAssertArrayNotHasKeyPropertlyFailsWithArrayAccessValue public function @covers PHPUnit_Framework_Assert::assertArrayNotHasKey @expectedException PHPUnit_Framework_AssertionFailedError
Framework_AssertTest::testAssertArrayNotHasKeyThrowsExceptionForInvalidFirstArgument public function @covers PHPUnit_Framework_Assert::assertArrayNotHasKey @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testAssertArrayNotHasKeyThrowsExceptionForInvalidSecondArgument public function @covers PHPUnit_Framework_Assert::assertArrayNotHasKey @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testAssertArrayNotHasStringKey public function @covers PHPUnit_Framework_Assert::assertArrayNotHasKey
Framework_AssertTest::testAssertArraySubset public function @covers PHPUnit_Framework_Assert::assertArraySubset @covers PHPUnit_Framework_Constraint_ArraySubset
Framework_AssertTest::testAssertArraySubsetRaisesExceptionForInvalidArguments public function @covers PHPUnit_Framework_Assert::assertArraySubset @covers PHPUnit_Framework_Constraint_ArraySubset @expectedException PHPUnit_Framework_Exception @expectedExceptionMessage array or ArrayAccess @dataProvider assertArraySubsetInvalidArgumentProvider
Framework_AssertTest::testAssertArraySubsetWithDeepNestedArrays public function @covers PHPUnit_Framework_Assert::assertArraySubset @covers PHPUnit_Framework_Constraint_ArraySubset
Framework_AssertTest::testAssertArraySubsetWithNoStrictCheckAndObjects public function @covers PHPUnit_Framework_Assert::assertArraySubset @covers PHPUnit_Framework_Constraint_ArraySubset
Framework_AssertTest::testAssertArraySubsetWithStrictCheckAndObjects public function @covers PHPUnit_Framework_Assert::assertArraySubset @covers PHPUnit_Framework_Constraint_ArraySubset
Framework_AssertTest::testAssertAttributeContainsNonObject public function @covers PHPUnit_Framework_Assert::assertAttributeContains
Framework_AssertTest::testAssertAttributeCount public function @covers PHPUnit_Framework_Assert::assertAttributeCount
Framework_AssertTest::testAssertAttributeEmpty public function @covers PHPUnit_Framework_Assert::assertAttributeEmpty
Framework_AssertTest::testAssertAttributeInstanceOf public function @covers PHPUnit_Framework_Assert::assertAttributeInstanceOf
Framework_AssertTest::testAssertAttributeInternalType public function @covers PHPUnit_Framework_Assert::assertAttributeInternalType
Framework_AssertTest::testAssertAttributeNotContainsNonObject public function @covers PHPUnit_Framework_Assert::assertAttributeNotContains
Framework_AssertTest::testAssertAttributeNotCount public function @covers PHPUnit_Framework_Assert::assertAttributeNotCount
Framework_AssertTest::testAssertAttributeNotEmpty public function @covers PHPUnit_Framework_Assert::assertAttributeNotEmpty
Framework_AssertTest::testAssertAttributeNotInstanceOf public function @covers PHPUnit_Framework_Assert::assertAttributeNotInstanceOf
Framework_AssertTest::testAssertAttributeNotInternalType public function @covers PHPUnit_Framework_Assert::assertAttributeNotInternalType
Framework_AssertTest::testAssertClassHasAttributeThrowsException public function @covers PHPUnit_Framework_Assert::assertClassHasAttribute @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testAssertClassHasAttributeThrowsException2 public function @covers PHPUnit_Framework_Assert::assertClassHasAttribute @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testAssertClassHasAttributeThrowsExceptionIfAttributeNameIsNotValid public function @covers PHPUnit_Framework_Assert::assertClassHasAttribute @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testAssertClassHasStaticAttributeThrowsException public function @covers PHPUnit_Framework_Assert::assertClassHasStaticAttribute @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testAssertClassHasStaticAttributeThrowsException2 public function @covers PHPUnit_Framework_Assert::assertClassHasStaticAttribute @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testAssertClassHasStaticAttributeThrowsExceptionIfAttributeNameIsNotValid public function @covers PHPUnit_Framework_Assert::assertClassHasStaticAttribute @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testAssertClassNotHasAttributeThrowsException public function @covers PHPUnit_Framework_Assert::assertClassNotHasAttribute @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testAssertClassNotHasAttributeThrowsException2 public function @covers PHPUnit_Framework_Assert::assertClassNotHasAttribute @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testAssertClassNotHasAttributeThrowsExceptionIfAttributeNameIsNotValid public function @covers PHPUnit_Framework_Assert::assertClassNotHasAttribute @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testAssertClassNotHasStaticAttributeThrowsException public function @covers PHPUnit_Framework_Assert::assertClassNotHasStaticAttribute @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testAssertClassNotHasStaticAttributeThrowsException2 public function @covers PHPUnit_Framework_Assert::assertClassNotHasStaticAttribute @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testAssertClassNotHasStaticAttributeThrowsExceptionIfAttributeNameIsNotValid public function @covers PHPUnit_Framework_Assert::assertClassNotHasStaticAttribute @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testAssertContainsOnlyInstancesOf public function @covers PHPUnit_Framework_Assert::assertContainsOnlyInstancesOf
Framework_AssertTest::testAssertContainsOnlyInstancesOfThrowsException public function @covers PHPUnit_Framework_Assert::assertContainsOnlyInstancesOf @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testAssertContainsOnlyThrowsException public function @covers PHPUnit_Framework_Assert::assertContainsOnly @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testAssertContainsThrowsException public function @covers PHPUnit_Framework_Assert::assertContains @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testAssertCount public function @covers PHPUnit_Framework_Assert::assertCount
Framework_AssertTest::testAssertCountThrowsExceptionIfElementIsNotCountable public function @covers PHPUnit_Framework_Assert::assertCount
Framework_AssertTest::testAssertCountThrowsExceptionIfExpectedCountIsNoInteger public function @covers PHPUnit_Framework_Assert::assertCount
Framework_AssertTest::testAssertCountTraversable public function @covers PHPUnit_Framework_Assert::assertCount
Framework_AssertTest::testAssertEmpty public function @covers PHPUnit_Framework_Assert::assertEmpty
Framework_AssertTest::testAssertEqualsFails public function @covers PHPUnit_Framework_Assert::assertEquals @dataProvider notEqualProvider
Framework_AssertTest::testAssertEqualsSucceeds public function @covers PHPUnit_Framework_Assert::assertEquals @dataProvider equalProvider
Framework_AssertTest::testAssertFalse public function @covers PHPUnit_Framework_Assert::assertFalse
Framework_AssertTest::testAssertFileEquals public function @covers PHPUnit_Framework_Assert::assertFileEquals
Framework_AssertTest::testAssertFileExists public function @covers PHPUnit_Framework_Assert::assertFileExists
Framework_AssertTest::testAssertFileExistsThrowsException public function @covers PHPUnit_Framework_Assert::assertFileExists @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testAssertFileNotEquals public function @covers PHPUnit_Framework_Assert::assertFileNotEquals
Framework_AssertTest::testAssertFileNotExists public function @covers PHPUnit_Framework_Assert::assertFileNotExists
Framework_AssertTest::testAssertFileNotExistsThrowsException public function @covers PHPUnit_Framework_Assert::assertFileNotExists @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testAssertInstanceOf public function @covers PHPUnit_Framework_Assert::assertInstanceOf
Framework_AssertTest::testAssertInstanceOfThrowsExceptionForInvalidArgument public function @covers PHPUnit_Framework_Assert::assertInstanceOf @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testAssertInternalType public function @covers PHPUnit_Framework_Assert::assertInternalType
Framework_AssertTest::testAssertInternalTypeDouble public function @covers PHPUnit_Framework_Assert::assertInternalType
Framework_AssertTest::testAssertInternalTypeThrowsExceptionForInvalidArgument public function @covers PHPUnit_Framework_Assert::assertInternalType @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testAssertIteratorContainsObject public function @covers PHPUnit_Framework_Assert::assertContains
Framework_AssertTest::testAssertIteratorContainsString public function @covers PHPUnit_Framework_Assert::assertContains
Framework_AssertTest::testAssertJson public function @covers PHPUnit_Framework_Assert::assertJson
Framework_AssertTest::testAssertJsonFileEqualsJsonFile public function @covers PHPUnit_Framework_Assert::assertJsonFileEqualsJsonFile
Framework_AssertTest::testAssertJsonFileNotEqualsJsonFile public function @covers PHPUnit_Framework_Assert::assertJsonFileNotEqualsJsonFile
Framework_AssertTest::testAssertJsonRaisesExceptionForInvalidArgument public function @covers PHPUnit_Framework_Assert::assertJson @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testAssertJsonStringEqualsJsonFile public function @covers PHPUnit_Framework_Assert::assertJsonStringEqualsJsonFile
Framework_AssertTest::testAssertJsonStringEqualsJsonFileExpectingException public function @covers PHPUnit_Framework_Assert::assertJsonStringEqualsJsonFile
Framework_AssertTest::testAssertJsonStringEqualsJsonFileExpectingExpectationFailedException public function @covers PHPUnit_Framework_Assert::assertJsonStringEqualsJsonFile
Framework_AssertTest::testAssertJsonStringEqualsJsonString public function @covers PHPUnit_Framework_Assert::assertJsonStringEqualsJsonString
Framework_AssertTest::testAssertJsonStringEqualsJsonStringErrorRaised public function @dataProvider validInvalidJsonDataprovider @covers PHPUnit_Framework_Assert::assertJsonStringEqualsJsonString
Framework_AssertTest::testAssertJsonStringNotEqualsJsonFile public function @covers PHPUnit_Framework_Assert::assertJsonStringNotEqualsJsonFile
Framework_AssertTest::testAssertJsonStringNotEqualsJsonFileExpectingException public function @covers PHPUnit_Framework_Assert::assertJsonStringNotEqualsJsonFile
Framework_AssertTest::testAssertJsonStringNotEqualsJsonString public function @covers PHPUnit_Framework_Assert::assertJsonStringNotEqualsJsonString
Framework_AssertTest::testAssertJsonStringNotEqualsJsonStringErrorRaised public function @dataProvider validInvalidJsonDataprovider @covers PHPUnit_Framework_Assert::assertJsonStringNotEqualsJsonString
Framework_AssertTest::testAssertNotContainsOnlyThrowsException public function @covers PHPUnit_Framework_Assert::assertNotContainsOnly @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testAssertNotContainsThrowsException public function @covers PHPUnit_Framework_Assert::assertNotContains @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testAssertNotCount public function @covers PHPUnit_Framework_Assert::assertNotCount
Framework_AssertTest::testAssertNotCountThrowsExceptionIfElementIsNotCountable public function @covers PHPUnit_Framework_Assert::assertNotCount @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testAssertNotCountThrowsExceptionIfExpectedCountIsNoInteger public function @covers PHPUnit_Framework_Assert::assertNotCount @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testAssertNotEmpty public function @covers PHPUnit_Framework_Assert::assertNotEmpty
Framework_AssertTest::testAssertNotEqualsFails public function @covers PHPUnit_Framework_Assert::assertNotEquals @dataProvider equalProvider
Framework_AssertTest::testAssertNotEqualsSucceeds public function @covers PHPUnit_Framework_Assert::assertNotEquals @dataProvider notEqualProvider
Framework_AssertTest::testAssertNotFalse public function @covers PHPUnit_Framework_Assert::assertNotFalse
Framework_AssertTest::testAssertNotInstanceOf public function @covers PHPUnit_Framework_Assert::assertNotInstanceOf
Framework_AssertTest::testAssertNotInstanceOfThrowsExceptionForInvalidArgument public function @covers PHPUnit_Framework_Assert::assertNotInstanceOf @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testAssertNotInternalType public function @covers PHPUnit_Framework_Assert::assertNotInternalType
Framework_AssertTest::testAssertNotInternalTypeThrowsExceptionForInvalidArgument public function @covers PHPUnit_Framework_Assert::assertNotInternalType @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testAssertNotNull public function @covers PHPUnit_Framework_Assert::assertNotNull
Framework_AssertTest::testAssertNotRegExp public function @covers PHPUnit_Framework_Assert::assertNotRegExp
Framework_AssertTest::testAssertNotRegExpThrowsException public function @covers PHPUnit_Framework_Assert::assertNotRegExp @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testAssertNotRegExpThrowsException2 public function @covers PHPUnit_Framework_Assert::assertNotRegExp @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testAssertNotSame public function @covers PHPUnit_Framework_Assert::assertNotSame
Framework_AssertTest::testAssertNotSame2 public function @covers PHPUnit_Framework_Assert::assertNotSame
Framework_AssertTest::testAssertNotSameFails public function @covers PHPUnit_Framework_Assert::assertNotSame @dataProvider sameProvider
Framework_AssertTest::testAssertNotSameFailsNull public function @covers PHPUnit_Framework_Assert::assertNotSame
Framework_AssertTest::testAssertNotSameSize public function @covers PHPUnit_Framework_Assert::assertNotSameSize
Framework_AssertTest::testAssertNotSameSizeThrowsExceptionIfActualIsNotCountable public function @covers PHPUnit_Framework_Assert::assertNotSameSize @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testAssertNotSameSizeThrowsExceptionIfExpectedIsNotCountable public function @covers PHPUnit_Framework_Assert::assertNotSameSize @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testAssertNotSameSucceeds public function @covers PHPUnit_Framework_Assert::assertNotSame @dataProvider notSameProvider
Framework_AssertTest::testAssertNotTrue public function @covers PHPUnit_Framework_Assert::assertNotTrue
Framework_AssertTest::testAssertNull public function @covers PHPUnit_Framework_Assert::assertNull
Framework_AssertTest::testAssertObjectHasAttribute public function @covers PHPUnit_Framework_Assert::assertObjectHasAttribute
Framework_AssertTest::testAssertObjectHasAttributeThrowsException public function @covers PHPUnit_Framework_Assert::assertObjectHasAttribute @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testAssertObjectHasAttributeThrowsException2 public function @covers PHPUnit_Framework_Assert::assertObjectHasAttribute @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testAssertObjectHasAttributeThrowsExceptionIfAttributeNameIsNotValid public function @covers PHPUnit_Framework_Assert::assertObjectHasAttribute @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testAssertObjectNotHasAttribute public function @covers PHPUnit_Framework_Assert::assertObjectNotHasAttribute
Framework_AssertTest::testAssertObjectNotHasAttributeThrowsException public function @covers PHPUnit_Framework_Assert::assertObjectNotHasAttribute @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testAssertObjectNotHasAttributeThrowsException2 public function @covers PHPUnit_Framework_Assert::assertObjectNotHasAttribute @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testAssertObjectNotHasAttributeThrowsExceptionIfAttributeNameIsNotValid public function @covers PHPUnit_Framework_Assert::assertObjectNotHasAttribute @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testAssertPrivateAttributeContains public function @covers PHPUnit_Framework_Assert::assertAttributeContains
Framework_AssertTest::testAssertPrivateAttributeEquals public function @covers PHPUnit_Framework_Assert::assertAttributeEquals
Framework_AssertTest::testAssertPrivateAttributeNotContains public function @covers PHPUnit_Framework_Assert::assertAttributeNotContains
Framework_AssertTest::testAssertPrivateAttributeNotEquals public function @covers PHPUnit_Framework_Assert::assertAttributeNotEquals
Framework_AssertTest::testAssertPrivateStaticAttributeEquals public function @covers PHPUnit_Framework_Assert::assertAttributeEquals
Framework_AssertTest::testAssertPrivateStaticAttributeNotEquals public function @covers PHPUnit_Framework_Assert::assertAttributeNotEquals
Framework_AssertTest::testAssertProtectedAttributeContains public function @covers PHPUnit_Framework_Assert::assertAttributeContains
Framework_AssertTest::testAssertProtectedAttributeEquals public function @covers PHPUnit_Framework_Assert::assertAttributeEquals
Framework_AssertTest::testAssertProtectedAttributeNotContains public function @covers PHPUnit_Framework_Assert::assertAttributeNotContains
Framework_AssertTest::testAssertProtectedAttributeNotEquals public function @covers PHPUnit_Framework_Assert::assertAttributeNotEquals
Framework_AssertTest::testAssertProtectedStaticAttributeEquals public function @covers PHPUnit_Framework_Assert::assertAttributeEquals
Framework_AssertTest::testAssertProtectedStaticAttributeNotEquals public function @covers PHPUnit_Framework_Assert::assertAttributeNotEquals
Framework_AssertTest::testAssertPublicAttributeContains public function @covers PHPUnit_Framework_Assert::assertAttributeContains
Framework_AssertTest::testAssertPublicAttributeContainsOnly public function @covers PHPUnit_Framework_Assert::assertAttributeContainsOnly
Framework_AssertTest::testAssertPublicAttributeEquals public function @covers PHPUnit_Framework_Assert::assertAttributeEquals
Framework_AssertTest::testAssertPublicAttributeNotContains public function @covers PHPUnit_Framework_Assert::assertAttributeNotContains
Framework_AssertTest::testAssertPublicAttributeNotContainsOnly public function @covers PHPUnit_Framework_Assert::assertAttributeNotContainsOnly
Framework_AssertTest::testAssertPublicAttributeNotEquals public function @covers PHPUnit_Framework_Assert::assertAttributeNotEquals
Framework_AssertTest::testAssertPublicAttributeNotSame public function @covers PHPUnit_Framework_Assert::assertAttributeNotSame
Framework_AssertTest::testAssertPublicAttributeSame public function @covers PHPUnit_Framework_Assert::assertAttributeSame
Framework_AssertTest::testAssertPublicStaticAttributeEquals public function @covers PHPUnit_Framework_Assert::assertAttributeEquals
Framework_AssertTest::testAssertPublicStaticAttributeNotEquals public function @covers PHPUnit_Framework_Assert::assertAttributeNotEquals
Framework_AssertTest::testAssertRegExp public function @covers PHPUnit_Framework_Assert::assertRegExp
Framework_AssertTest::testAssertRegExpThrowsException public function @covers PHPUnit_Framework_Assert::assertRegExp @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testAssertRegExpThrowsException2 public function @covers PHPUnit_Framework_Assert::assertRegExp @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testAssertSame public function @covers PHPUnit_Framework_Assert::assertSame
Framework_AssertTest::testAssertSame2 public function @covers PHPUnit_Framework_Assert::assertSame
Framework_AssertTest::testAssertSameFails public function @covers PHPUnit_Framework_Assert::assertSame @dataProvider notSameProvider
Framework_AssertTest::testAssertSameSize public function @covers PHPUnit_Framework_Assert::assertSameSize
Framework_AssertTest::testAssertSameSizeThrowsExceptionIfActualIsNotCountable public function @covers PHPUnit_Framework_Assert::assertSameSize
Framework_AssertTest::testAssertSameSizeThrowsExceptionIfExpectedIsNotCountable public function @covers PHPUnit_Framework_Assert::assertSameSize
Framework_AssertTest::testAssertSameSucceeds public function @covers PHPUnit_Framework_Assert::assertSame @dataProvider sameProvider
Framework_AssertTest::testAssertSplObjectStorageContainsObject public function @covers PHPUnit_Framework_Assert::assertContains
Framework_AssertTest::testAssertSplObjectStorageNotContainsObject public function @covers PHPUnit_Framework_Assert::assertNotContains
Framework_AssertTest::testAssertStringContainsString public function @covers PHPUnit_Framework_Assert::assertContains
Framework_AssertTest::testAssertStringEndsNotWith public function @covers PHPUnit_Framework_Assert::assertStringEndsNotWith
Framework_AssertTest::testAssertStringEndsNotWithThrowsException public function @covers PHPUnit_Framework_Assert::assertStringEndsNotWith @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testAssertStringEndsNotWithThrowsException2 public function @covers PHPUnit_Framework_Assert::assertStringEndsNotWith @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testAssertStringEndsWith public function @covers PHPUnit_Framework_Assert::assertStringEndsWith
Framework_AssertTest::testAssertStringEndsWithThrowsException public function @covers PHPUnit_Framework_Assert::assertStringEndsWith @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testAssertStringEndsWithThrowsException2 public function @covers PHPUnit_Framework_Assert::assertStringEndsWith @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testAssertStringEqualsFile public function @covers PHPUnit_Framework_Assert::assertStringEqualsFile
Framework_AssertTest::testAssertStringEqualsNumeric public function @covers PHPUnit_Framework_Assert::assertEquals
Framework_AssertTest::testAssertStringEqualsNumeric2 public function @covers PHPUnit_Framework_Assert::assertNotEquals
Framework_AssertTest::testAssertStringMatchesFormat public function @covers PHPUnit_Framework_Assert::assertStringMatchesFormat
Framework_AssertTest::testAssertStringMatchesFormatFailure public function @covers PHPUnit_Framework_Assert::assertStringMatchesFormat @expectedException PHPUnit_Framework_AssertionFailedError
Framework_AssertTest::testAssertStringMatchesFormatFile public function @covers PHPUnit_Framework_Assert::assertStringMatchesFormatFile
Framework_AssertTest::testAssertStringMatchesFormatFileThrowsExceptionForInvalidArgument public function @covers PHPUnit_Framework_Assert::assertStringMatchesFormatFile @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testAssertStringMatchesFormatFileThrowsExceptionForInvalidArgument2 public function @covers PHPUnit_Framework_Assert::assertStringMatchesFormatFile @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testAssertStringMatchesFormatRaisesExceptionForInvalidFirstArgument public function @covers PHPUnit_Framework_Assert::assertStringMatchesFormat @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testAssertStringMatchesFormatRaisesExceptionForInvalidSecondArgument public function @covers PHPUnit_Framework_Assert::assertStringMatchesFormat @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testAssertStringNotContainsString public function @covers PHPUnit_Framework_Assert::assertNotContains
Framework_AssertTest::testAssertStringNotEqualsFile public function @covers PHPUnit_Framework_Assert::assertStringNotEqualsFile
Framework_AssertTest::testAssertStringNotMatchesFormat public function @covers PHPUnit_Framework_Assert::assertStringNotMatchesFormat
Framework_AssertTest::testAssertStringNotMatchesFormatFile public function @covers PHPUnit_Framework_Assert::assertStringNotMatchesFormatFile
Framework_AssertTest::testAssertStringNotMatchesFormatFileThrowsExceptionForInvalidArgument public function @covers PHPUnit_Framework_Assert::assertStringNotMatchesFormatFile @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testAssertStringNotMatchesFormatFileThrowsExceptionForInvalidArgument2 public function @covers PHPUnit_Framework_Assert::assertStringNotMatchesFormatFile @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testAssertStringNotMatchesFormatRaisesExceptionForInvalidFirstArgument public function @covers PHPUnit_Framework_Assert::assertStringNotMatchesFormat @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testAssertStringNotMatchesFormatRaisesExceptionForInvalidSecondArgument public function @covers PHPUnit_Framework_Assert::assertStringNotMatchesFormat @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testAssertStringStartsNotWith public function @covers PHPUnit_Framework_Assert::assertStringStartsNotWith
Framework_AssertTest::testAssertStringStartsNotWithThrowsException public function @covers PHPUnit_Framework_Assert::assertStringStartsNotWith @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testAssertStringStartsNotWithThrowsException2 public function @covers PHPUnit_Framework_Assert::assertStringStartsNotWith @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testAssertStringStartsWith public function @covers PHPUnit_Framework_Assert::assertStringStartsWith
Framework_AssertTest::testAssertStringStartsWithThrowsException public function @covers PHPUnit_Framework_Assert::assertStringStartsWith @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testAssertStringStartsWithThrowsException2 public function @covers PHPUnit_Framework_Assert::assertStringStartsWith @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testAssertThatAnything public function @covers PHPUnit_Framework_Assert::assertThat @covers PHPUnit_Framework_Assert::anything
Framework_AssertTest::testAssertThatAnythingAndAnything public function @covers PHPUnit_Framework_Assert::assertThat @covers PHPUnit_Framework_Assert::anything @covers PHPUnit_Framework_Assert::logicalAnd
Framework_AssertTest::testAssertThatAnythingOrAnything public function @covers PHPUnit_Framework_Assert::assertThat @covers PHPUnit_Framework_Assert::anything @covers PHPUnit_Framework_Assert::logicalOr
Framework_AssertTest::testAssertThatAnythingXorNotAnything public function @covers PHPUnit_Framework_Assert::assertThat @covers PHPUnit_Framework_Assert::anything @covers PHPUnit_Framework_Assert::logicalNot @covers PHPUnit_Framework_Assert::logicalXor
Framework_AssertTest::testAssertThatArrayHasKey public function @covers PHPUnit_Framework_Assert::assertThat @covers PHPUnit_Framework_Assert::arrayHasKey
Framework_AssertTest::testAssertThatAttributeEquals public function @covers PHPUnit_Framework_Assert::assertThat @covers PHPUnit_Framework_Assert::attribute @covers PHPUnit_Framework_Assert::equalTo
Framework_AssertTest::testAssertThatAttributeEquals2 public function @covers PHPUnit_Framework_Assert::assertThat @covers PHPUnit_Framework_Assert::attribute @covers PHPUnit_Framework_Assert::equalTo @expectedException PHPUnit_Framework_AssertionFailedError
Framework_AssertTest::testAssertThatAttributeEqualTo public function @covers PHPUnit_Framework_Assert::assertThat @covers PHPUnit_Framework_Assert::attribute @covers PHPUnit_Framework_Assert::equalTo
Framework_AssertTest::testAssertThatCallback public function @covers PHPUnit_Framework_Assert::assertThat @covers PHPUnit_Framework_Assert::callback
Framework_AssertTest::testAssertThatClassHasAttribute public function @covers PHPUnit_Framework_Assert::assertThat @covers PHPUnit_Framework_Assert::classHasAttribute
Framework_AssertTest::testAssertThatClassHasStaticAttribute public function @covers PHPUnit_Framework_Assert::assertThat @covers PHPUnit_Framework_Assert::classHasStaticAttribute
Framework_AssertTest::testAssertThatContains public function @covers PHPUnit_Framework_Assert::assertThat @covers PHPUnit_Framework_Assert::contains
Framework_AssertTest::testAssertThatContainsOnly public function @covers PHPUnit_Framework_Assert::assertThat @covers PHPUnit_Framework_Assert::containsOnly
Framework_AssertTest::testAssertThatContainsOnlyInstancesOf public function @covers PHPUnit_Framework_Assert::assertThat @covers PHPUnit_Framework_Assert::containsOnlyInstancesOf
Framework_AssertTest::testAssertThatCountOf public function @covers PHPUnit_Framework_Assert::assertThat @covers PHPUnit_Framework_Assert::countOf
Framework_AssertTest::testAssertThatEqualTo public function @covers PHPUnit_Framework_Assert::assertThat @covers PHPUnit_Framework_Assert::equalTo
Framework_AssertTest::testAssertThatFileExists public function @covers PHPUnit_Framework_Assert::assertThat @covers PHPUnit_Framework_Assert::fileExists
Framework_AssertTest::testAssertThatGreaterThan public function @covers PHPUnit_Framework_Assert::assertThat @covers PHPUnit_Framework_Assert::greaterThan
Framework_AssertTest::testAssertThatGreaterThanOrEqual public function @covers PHPUnit_Framework_Assert::assertThat @covers PHPUnit_Framework_Assert::greaterThanOrEqual
Framework_AssertTest::testAssertThatIdenticalTo public function @covers PHPUnit_Framework_Assert::assertThat @covers PHPUnit_Framework_Assert::identicalTo
Framework_AssertTest::testAssertThatIsEmpty public function @covers PHPUnit_Framework_Assert::assertThat @covers PHPUnit_Framework_Assert::isEmpty
Framework_AssertTest::testAssertThatIsFalse public function @covers PHPUnit_Framework_Assert::assertThat @covers PHPUnit_Framework_Assert::isFalse
Framework_AssertTest::testAssertThatIsInstanceOf public function @covers PHPUnit_Framework_Assert::assertThat @covers PHPUnit_Framework_Assert::isInstanceOf
Framework_AssertTest::testAssertThatIsJson public function @covers PHPUnit_Framework_Assert::assertThat @covers PHPUnit_Framework_Assert::isJson
Framework_AssertTest::testAssertThatIsTrue public function @covers PHPUnit_Framework_Assert::assertThat @covers PHPUnit_Framework_Assert::isTrue
Framework_AssertTest::testAssertThatIsType public function @covers PHPUnit_Framework_Assert::assertThat @covers PHPUnit_Framework_Assert::isType
Framework_AssertTest::testAssertThatLessThan public function @covers PHPUnit_Framework_Assert::assertThat @covers PHPUnit_Framework_Assert::lessThan
Framework_AssertTest::testAssertThatLessThanOrEqual public function @covers PHPUnit_Framework_Assert::assertThat @covers PHPUnit_Framework_Assert::lessThanOrEqual
Framework_AssertTest::testAssertThatMatchesRegularExpression public function @covers PHPUnit_Framework_Assert::assertThat @covers PHPUnit_Framework_Assert::matchesRegularExpression
Framework_AssertTest::testAssertThatObjectHasAttribute public function @covers PHPUnit_Framework_Assert::assertThat @covers PHPUnit_Framework_Assert::objectHasAttribute
Framework_AssertTest::testAssertThatStringContains public function @covers PHPUnit_Framework_Assert::assertThat @covers PHPUnit_Framework_Assert::stringContains
Framework_AssertTest::testAssertTrue public function @covers PHPUnit_Framework_Assert::assertTrue
Framework_AssertTest::testAssertXmlFileEqualsXmlFile public function @covers PHPUnit_Framework_Assert::assertXmlFileEqualsXmlFile
Framework_AssertTest::testAssertXmlFileNotEqualsXmlFile public function @covers PHPUnit_Framework_Assert::assertXmlFileNotEqualsXmlFile
Framework_AssertTest::testAssertXmlStringEqualsXmlFile public function @covers PHPUnit_Framework_Assert::assertXmlStringEqualsXmlFile
Framework_AssertTest::testAssertXmlStringEqualsXmlString public function @covers PHPUnit_Framework_Assert::assertXmlStringEqualsXmlString
Framework_AssertTest::testAssertXmlStringEqualsXmlString2 public function @expectedException PHPUnit_Framework_Exception @covers PHPUnit_Framework_Assert::assertXmlStringEqualsXmlString @ticket 1860
Framework_AssertTest::testAssertXmlStringEqualsXmlString3 public function @covers PHPUnit_Framework_Assert::assertXmlStringEqualsXmlString @ticket 1860
Framework_AssertTest::testAssertXmlStringNotEqualsXmlString public function @covers PHPUnit_Framework_Assert::assertXmlStringNotEqualsXmlString
Framework_AssertTest::testAttributeGreaterThan public function @covers PHPUnit_Framework_Assert::assertAttributeGreaterThan
Framework_AssertTest::testAttributeGreaterThanOrEqual public function @covers PHPUnit_Framework_Assert::assertAttributeGreaterThanOrEqual
Framework_AssertTest::testAttributeLessThan public function @covers PHPUnit_Framework_Assert::assertAttributeLessThan
Framework_AssertTest::testAttributeLessThanOrEqual public function @covers PHPUnit_Framework_Assert::assertAttributeLessThanOrEqual
Framework_AssertTest::testClassHasPublicAttribute public function @covers PHPUnit_Framework_Assert::assertClassHasAttribute
Framework_AssertTest::testClassHasPublicStaticAttribute public function @covers PHPUnit_Framework_Assert::assertClassHasStaticAttribute
Framework_AssertTest::testClassNotHasPublicAttribute public function @covers PHPUnit_Framework_Assert::assertClassNotHasAttribute
Framework_AssertTest::testClassNotHasPublicStaticAttribute public function @covers PHPUnit_Framework_Assert::assertClassNotHasStaticAttribute
Framework_AssertTest::testFail public function @covers PHPUnit_Framework_Assert::fail
Framework_AssertTest::testGetObjectAttributeRaisesExceptionForInvalidFirstArgument public function @covers PHPUnit_Framework_Assert::getObjectAttribute @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testGetObjectAttributeRaisesExceptionForInvalidSecondArgument public function @covers PHPUnit_Framework_Assert::getObjectAttribute @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testGetObjectAttributeRaisesExceptionForInvalidSecondArgument2 public function @covers PHPUnit_Framework_Assert::getObjectAttribute @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testGetObjectAttributeRaisesExceptionForInvalidSecondArgument3 public function @covers PHPUnit_Framework_Assert::getObjectAttribute @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testGetObjectAttributeWorksForInheritedAttributes public function @covers PHPUnit_Framework_Assert::getObjectAttribute
Framework_AssertTest::testGetStaticAttributeRaisesExceptionForInvalidFirstArgument public function @covers PHPUnit_Framework_Assert::getStaticAttribute @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testGetStaticAttributeRaisesExceptionForInvalidFirstArgument2 public function @covers PHPUnit_Framework_Assert::getStaticAttribute @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testGetStaticAttributeRaisesExceptionForInvalidSecondArgument public function @covers PHPUnit_Framework_Assert::getStaticAttribute @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testGetStaticAttributeRaisesExceptionForInvalidSecondArgument2 public function @covers PHPUnit_Framework_Assert::getStaticAttribute @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testGetStaticAttributeRaisesExceptionForInvalidSecondArgument3 public function @covers PHPUnit_Framework_Assert::getStaticAttribute @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testGreaterThan public function @covers PHPUnit_Framework_Assert::assertGreaterThan
Framework_AssertTest::testGreaterThanOrEqual public function @covers PHPUnit_Framework_Assert::assertGreaterThanOrEqual
Framework_AssertTest::testLessThan public function @covers PHPUnit_Framework_Assert::assertLessThan
Framework_AssertTest::testLessThanOrEqual public function @covers PHPUnit_Framework_Assert::assertLessThanOrEqual
Framework_AssertTest::testMarkTestIncomplete public function @covers PHPUnit_Framework_Assert::markTestIncomplete
Framework_AssertTest::testMarkTestSkipped public function @covers PHPUnit_Framework_Assert::markTestSkipped
Framework_AssertTest::testObjectHasOnTheFlyAttribute public function @covers PHPUnit_Framework_Assert::assertObjectHasAttribute
Framework_AssertTest::testObjectHasPrivateAttribute public function @covers PHPUnit_Framework_Assert::assertObjectHasAttribute
Framework_AssertTest::testObjectHasProtectedAttribute public function @covers PHPUnit_Framework_Assert::assertObjectHasAttribute
Framework_AssertTest::testObjectHasPublicAttribute public function @covers PHPUnit_Framework_Assert::assertObjectHasAttribute
Framework_AssertTest::testObjectNotHasOnTheFlyAttribute public function @covers PHPUnit_Framework_Assert::assertObjectNotHasAttribute
Framework_AssertTest::testObjectNotHasPrivateAttribute public function @covers PHPUnit_Framework_Assert::assertObjectNotHasAttribute
Framework_AssertTest::testObjectNotHasProtectedAttribute public function @covers PHPUnit_Framework_Assert::assertObjectNotHasAttribute
Framework_AssertTest::testObjectNotHasPublicAttribute public function @covers PHPUnit_Framework_Assert::assertObjectNotHasAttribute
Framework_AssertTest::testReadAttribute public function @covers PHPUnit_Framework_Assert::readAttribute @covers PHPUnit_Framework_Assert::getStaticAttribute @covers PHPUnit_Framework_Assert::getObjectAttribute
Framework_AssertTest::testReadAttribute2 public function @covers PHPUnit_Framework_Assert::readAttribute @covers PHPUnit_Framework_Assert::getStaticAttribute @covers PHPUnit_Framework_Assert::getObjectAttribute
Framework_AssertTest::testReadAttribute3 public function @covers PHPUnit_Framework_Assert::readAttribute @covers PHPUnit_Framework_Assert::getStaticAttribute @covers PHPUnit_Framework_Assert::getObjectAttribute @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testReadAttribute4 public function @covers PHPUnit_Framework_Assert::readAttribute @covers PHPUnit_Framework_Assert::getStaticAttribute @covers PHPUnit_Framework_Assert::getObjectAttribute @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testReadAttribute5 public function @covers PHPUnit_Framework_Assert::readAttribute @covers PHPUnit_Framework_Assert::getStaticAttribute @covers PHPUnit_Framework_Assert::getObjectAttribute @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testReadAttributeIfAttributeNameIsNotValid public function @covers PHPUnit_Framework_Assert::readAttribute @covers PHPUnit_Framework_Assert::getStaticAttribute @covers PHPUnit_Framework_Assert::getObjectAttribute @expectedException PHPUnit_Framework_Exception
Framework_AssertTest::testXmlStringNotEqualsXmlFile public function @covers PHPUnit_Framework_Assert::assertXmlStringNotEqualsXmlFile
Framework_AssertTest::testXMLStructureAttributesAreSameButValuesAreNot public function @covers PHPUnit_Framework_Assert::assertEqualXMLStructure
Framework_AssertTest::testXMLStructureIgnoreTextNodes public function @covers PHPUnit_Framework_Assert::assertEqualXMLStructure
Framework_AssertTest::testXMLStructureIsSame public function @covers PHPUnit_Framework_Assert::assertEqualXMLStructure
Framework_AssertTest::testXMLStructureIsSameButDataIsNot public function @covers PHPUnit_Framework_Assert::assertEqualXMLStructure
Framework_AssertTest::testXMLStructureWrongNumberOfAttributes public function @covers PHPUnit_Framework_Assert::assertEqualXMLStructure @expectedException PHPUnit_Framework_ExpectationFailedException
Framework_AssertTest::testXMLStructureWrongNumberOfNodes public function @covers PHPUnit_Framework_Assert::assertEqualXMLStructure @expectedException PHPUnit_Framework_ExpectationFailedException
Framework_AssertTest::validInvalidJsonDataprovider public static 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::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