You are here

abstract class PHPUnit_Framework_Assert in Zircon Profile 8

Same name and namespace in other branches
  1. 8.0 vendor/phpunit/phpunit/src/Framework/Assert.php \PHPUnit_Framework_Assert

A set of assert methods.

@since Class available since Release 2.0.0

Hierarchy

Expanded class hierarchy of PHPUnit_Framework_Assert

File

vendor/phpunit/phpunit/src/Framework/Assert.php, line 16

View source
abstract class PHPUnit_Framework_Assert {

  /**
   * @var int
   */
  private static $count = 0;

  /**
   * Asserts that an array has a specified key.
   *
   * @param mixed             $key
   * @param array|ArrayAccess $array
   * @param string            $message
   * @since Method available since Release 3.0.0
   */
  public static function assertArrayHasKey($key, $array, $message = '') {
    if (!(is_integer($key) || is_string($key))) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'integer or string');
    }
    if (!(is_array($array) || $array instanceof ArrayAccess)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(2, 'array or ArrayAccess');
    }
    $constraint = new PHPUnit_Framework_Constraint_ArrayHasKey($key);
    self::assertThat($array, $constraint, $message);
  }

  /**
   * Asserts that an array has a specified subset.
   *
   * @param array|ArrayAccess $subset
   * @param array|ArrayAccess $array
   * @param bool              $strict  Check for object identity
   * @param string            $message
   * @since Method available since Release 4.4.0
   */
  public static function assertArraySubset($subset, $array, $strict = false, $message = '') {
    if (!is_array($subset)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'array or ArrayAccess');
    }
    if (!is_array($array)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(2, 'array or ArrayAccess');
    }
    $constraint = new PHPUnit_Framework_Constraint_ArraySubset($subset, $strict);
    self::assertThat($array, $constraint, $message);
  }

  /**
   * Asserts that an array does not have a specified key.
   *
   * @param mixed             $key
   * @param array|ArrayAccess $array
   * @param string            $message
   * @since  Method available since Release 3.0.0
   */
  public static function assertArrayNotHasKey($key, $array, $message = '') {
    if (!(is_integer($key) || is_string($key))) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'integer or string');
    }
    if (!(is_array($array) || $array instanceof ArrayAccess)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(2, 'array or ArrayAccess');
    }
    $constraint = new PHPUnit_Framework_Constraint_Not(new PHPUnit_Framework_Constraint_ArrayHasKey($key));
    self::assertThat($array, $constraint, $message);
  }

  /**
   * Asserts that a haystack contains a needle.
   *
   * @param mixed  $needle
   * @param mixed  $haystack
   * @param string $message
   * @param bool   $ignoreCase
   * @param bool   $checkForObjectIdentity
   * @param bool   $checkForNonObjectIdentity
   * @since  Method available since Release 2.1.0
   */
  public static function assertContains($needle, $haystack, $message = '', $ignoreCase = false, $checkForObjectIdentity = true, $checkForNonObjectIdentity = false) {
    if (is_array($haystack) || is_object($haystack) && $haystack instanceof Traversable) {
      $constraint = new PHPUnit_Framework_Constraint_TraversableContains($needle, $checkForObjectIdentity, $checkForNonObjectIdentity);
    }
    elseif (is_string($haystack)) {
      if (!is_string($needle)) {
        throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'string');
      }
      $constraint = new PHPUnit_Framework_Constraint_StringContains($needle, $ignoreCase);
    }
    else {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(2, 'array, traversable or string');
    }
    self::assertThat($haystack, $constraint, $message);
  }

  /**
   * Asserts that a haystack that is stored in a static attribute of a class
   * or an attribute of an object contains a needle.
   *
   * @param mixed  $needle
   * @param string $haystackAttributeName
   * @param mixed  $haystackClassOrObject
   * @param string $message
   * @param bool   $ignoreCase
   * @param bool   $checkForObjectIdentity
   * @param bool   $checkForNonObjectIdentity
   * @since  Method available since Release 3.0.0
   */
  public static function assertAttributeContains($needle, $haystackAttributeName, $haystackClassOrObject, $message = '', $ignoreCase = false, $checkForObjectIdentity = true, $checkForNonObjectIdentity = false) {
    self::assertContains($needle, self::readAttribute($haystackClassOrObject, $haystackAttributeName), $message, $ignoreCase, $checkForObjectIdentity, $checkForNonObjectIdentity);
  }

  /**
   * Asserts that a haystack does not contain a needle.
   *
   * @param mixed  $needle
   * @param mixed  $haystack
   * @param string $message
   * @param bool   $ignoreCase
   * @param bool   $checkForObjectIdentity
   * @param bool   $checkForNonObjectIdentity
   * @since  Method available since Release 2.1.0
   */
  public static function assertNotContains($needle, $haystack, $message = '', $ignoreCase = false, $checkForObjectIdentity = true, $checkForNonObjectIdentity = false) {
    if (is_array($haystack) || is_object($haystack) && $haystack instanceof Traversable) {
      $constraint = new PHPUnit_Framework_Constraint_Not(new PHPUnit_Framework_Constraint_TraversableContains($needle, $checkForObjectIdentity, $checkForNonObjectIdentity));
    }
    elseif (is_string($haystack)) {
      if (!is_string($needle)) {
        throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'string');
      }
      $constraint = new PHPUnit_Framework_Constraint_Not(new PHPUnit_Framework_Constraint_StringContains($needle, $ignoreCase));
    }
    else {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(2, 'array, traversable or string');
    }
    self::assertThat($haystack, $constraint, $message);
  }

  /**
   * 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.
   *
   * @param mixed  $needle
   * @param string $haystackAttributeName
   * @param mixed  $haystackClassOrObject
   * @param string $message
   * @param bool   $ignoreCase
   * @param bool   $checkForObjectIdentity
   * @param bool   $checkForNonObjectIdentity
   * @since  Method available since Release 3.0.0
   */
  public static function assertAttributeNotContains($needle, $haystackAttributeName, $haystackClassOrObject, $message = '', $ignoreCase = false, $checkForObjectIdentity = true, $checkForNonObjectIdentity = false) {
    self::assertNotContains($needle, self::readAttribute($haystackClassOrObject, $haystackAttributeName), $message, $ignoreCase, $checkForObjectIdentity, $checkForNonObjectIdentity);
  }

  /**
   * Asserts that a haystack contains only values of a given type.
   *
   * @param string $type
   * @param mixed  $haystack
   * @param bool   $isNativeType
   * @param string $message
   * @since  Method available since Release 3.1.4
   */
  public static function assertContainsOnly($type, $haystack, $isNativeType = null, $message = '') {
    if (!(is_array($haystack) || is_object($haystack) && $haystack instanceof Traversable)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(2, 'array or traversable');
    }
    if ($isNativeType == null) {
      $isNativeType = PHPUnit_Util_Type::isType($type);
    }
    self::assertThat($haystack, new PHPUnit_Framework_Constraint_TraversableContainsOnly($type, $isNativeType), $message);
  }

  /**
   * Asserts that a haystack contains only instances of a given classname
   *
   * @param string            $classname
   * @param array|Traversable $haystack
   * @param string            $message
   */
  public static function assertContainsOnlyInstancesOf($classname, $haystack, $message = '') {
    if (!(is_array($haystack) || is_object($haystack) && $haystack instanceof Traversable)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(2, 'array or traversable');
    }
    self::assertThat($haystack, new PHPUnit_Framework_Constraint_TraversableContainsOnly($classname, false), $message);
  }

  /**
   * 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.
   *
   * @param string $type
   * @param string $haystackAttributeName
   * @param mixed  $haystackClassOrObject
   * @param bool   $isNativeType
   * @param string $message
   * @since  Method available since Release 3.1.4
   */
  public static function assertAttributeContainsOnly($type, $haystackAttributeName, $haystackClassOrObject, $isNativeType = null, $message = '') {
    self::assertContainsOnly($type, self::readAttribute($haystackClassOrObject, $haystackAttributeName), $isNativeType, $message);
  }

  /**
   * Asserts that a haystack does not contain only values of a given type.
   *
   * @param string $type
   * @param mixed  $haystack
   * @param bool   $isNativeType
   * @param string $message
   * @since  Method available since Release 3.1.4
   */
  public static function assertNotContainsOnly($type, $haystack, $isNativeType = null, $message = '') {
    if (!(is_array($haystack) || is_object($haystack) && $haystack instanceof Traversable)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(2, 'array or traversable');
    }
    if ($isNativeType == null) {
      $isNativeType = PHPUnit_Util_Type::isType($type);
    }
    self::assertThat($haystack, new PHPUnit_Framework_Constraint_Not(new PHPUnit_Framework_Constraint_TraversableContainsOnly($type, $isNativeType)), $message);
  }

  /**
   * 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.
   *
   * @param string $type
   * @param string $haystackAttributeName
   * @param mixed  $haystackClassOrObject
   * @param bool   $isNativeType
   * @param string $message
   * @since  Method available since Release 3.1.4
   */
  public static function assertAttributeNotContainsOnly($type, $haystackAttributeName, $haystackClassOrObject, $isNativeType = null, $message = '') {
    self::assertNotContainsOnly($type, self::readAttribute($haystackClassOrObject, $haystackAttributeName), $isNativeType, $message);
  }

  /**
   * Asserts the number of elements of an array, Countable or Traversable.
   *
   * @param int    $expectedCount
   * @param mixed  $haystack
   * @param string $message
   */
  public static function assertCount($expectedCount, $haystack, $message = '') {
    if (!is_int($expectedCount)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'integer');
    }
    if (!$haystack instanceof Countable && !$haystack instanceof Traversable && !is_array($haystack)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(2, 'countable or traversable');
    }
    self::assertThat($haystack, new PHPUnit_Framework_Constraint_Count($expectedCount), $message);
  }

  /**
   * Asserts the number of elements of an array, Countable or Traversable
   * that is stored in an attribute.
   *
   * @param int    $expectedCount
   * @param string $haystackAttributeName
   * @param mixed  $haystackClassOrObject
   * @param string $message
   * @since Method available since Release 3.6.0
   */
  public static function assertAttributeCount($expectedCount, $haystackAttributeName, $haystackClassOrObject, $message = '') {
    self::assertCount($expectedCount, self::readAttribute($haystackClassOrObject, $haystackAttributeName), $message);
  }

  /**
   * Asserts the number of elements of an array, Countable or Traversable.
   *
   * @param int    $expectedCount
   * @param mixed  $haystack
   * @param string $message
   */
  public static function assertNotCount($expectedCount, $haystack, $message = '') {
    if (!is_int($expectedCount)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'integer');
    }
    if (!$haystack instanceof Countable && !$haystack instanceof Traversable && !is_array($haystack)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(2, 'countable or traversable');
    }
    $constraint = new PHPUnit_Framework_Constraint_Not(new PHPUnit_Framework_Constraint_Count($expectedCount));
    self::assertThat($haystack, $constraint, $message);
  }

  /**
   * Asserts the number of elements of an array, Countable or Traversable
   * that is stored in an attribute.
   *
   * @param int    $expectedCount
   * @param string $haystackAttributeName
   * @param mixed  $haystackClassOrObject
   * @param string $message
   * @since Method available since Release 3.6.0
   */
  public static function assertAttributeNotCount($expectedCount, $haystackAttributeName, $haystackClassOrObject, $message = '') {
    self::assertNotCount($expectedCount, self::readAttribute($haystackClassOrObject, $haystackAttributeName), $message);
  }

  /**
   * Asserts that two variables are equal.
   *
   * @param mixed  $expected
   * @param mixed  $actual
   * @param string $message
   * @param float  $delta
   * @param int    $maxDepth
   * @param bool   $canonicalize
   * @param bool   $ignoreCase
   */
  public static function assertEquals($expected, $actual, $message = '', $delta = 0.0, $maxDepth = 10, $canonicalize = false, $ignoreCase = false) {
    $constraint = new PHPUnit_Framework_Constraint_IsEqual($expected, $delta, $maxDepth, $canonicalize, $ignoreCase);
    self::assertThat($actual, $constraint, $message);
  }

  /**
   * Asserts that a variable is equal to an attribute of an object.
   *
   * @param mixed  $expected
   * @param string $actualAttributeName
   * @param string $actualClassOrObject
   * @param string $message
   * @param float  $delta
   * @param int    $maxDepth
   * @param bool   $canonicalize
   * @param bool   $ignoreCase
   */
  public static function assertAttributeEquals($expected, $actualAttributeName, $actualClassOrObject, $message = '', $delta = 0.0, $maxDepth = 10, $canonicalize = false, $ignoreCase = false) {
    self::assertEquals($expected, self::readAttribute($actualClassOrObject, $actualAttributeName), $message, $delta, $maxDepth, $canonicalize, $ignoreCase);
  }

  /**
   * Asserts that two variables are not equal.
   *
   * @param mixed  $expected
   * @param mixed  $actual
   * @param string $message
   * @param float  $delta
   * @param int    $maxDepth
   * @param bool   $canonicalize
   * @param bool   $ignoreCase
   * @since  Method available since Release 2.3.0
   */
  public static function assertNotEquals($expected, $actual, $message = '', $delta = 0.0, $maxDepth = 10, $canonicalize = false, $ignoreCase = false) {
    $constraint = new PHPUnit_Framework_Constraint_Not(new PHPUnit_Framework_Constraint_IsEqual($expected, $delta, $maxDepth, $canonicalize, $ignoreCase));
    self::assertThat($actual, $constraint, $message);
  }

  /**
   * Asserts that a variable is not equal to an attribute of an object.
   *
   * @param mixed  $expected
   * @param string $actualAttributeName
   * @param string $actualClassOrObject
   * @param string $message
   * @param float  $delta
   * @param int    $maxDepth
   * @param bool   $canonicalize
   * @param bool   $ignoreCase
   */
  public static function assertAttributeNotEquals($expected, $actualAttributeName, $actualClassOrObject, $message = '', $delta = 0.0, $maxDepth = 10, $canonicalize = false, $ignoreCase = false) {
    self::assertNotEquals($expected, self::readAttribute($actualClassOrObject, $actualAttributeName), $message, $delta, $maxDepth, $canonicalize, $ignoreCase);
  }

  /**
   * Asserts that a variable is empty.
   *
   * @param  mixed                                  $actual
   * @param  string                                 $message
   * @throws PHPUnit_Framework_AssertionFailedError
   */
  public static function assertEmpty($actual, $message = '') {
    self::assertThat($actual, self::isEmpty(), $message);
  }

  /**
   * Asserts that a static attribute of a class or an attribute of an object
   * is empty.
   *
   * @param string $haystackAttributeName
   * @param mixed  $haystackClassOrObject
   * @param string $message
   * @since Method available since Release 3.5.0
   */
  public static function assertAttributeEmpty($haystackAttributeName, $haystackClassOrObject, $message = '') {
    self::assertEmpty(self::readAttribute($haystackClassOrObject, $haystackAttributeName), $message);
  }

  /**
   * Asserts that a variable is not empty.
   *
   * @param  mixed                                  $actual
   * @param  string                                 $message
   * @throws PHPUnit_Framework_AssertionFailedError
   */
  public static function assertNotEmpty($actual, $message = '') {
    self::assertThat($actual, self::logicalNot(self::isEmpty()), $message);
  }

  /**
   * Asserts that a static attribute of a class or an attribute of an object
   * is not empty.
   *
   * @param string $haystackAttributeName
   * @param mixed  $haystackClassOrObject
   * @param string $message
   * @since Method available since Release 3.5.0
   */
  public static function assertAttributeNotEmpty($haystackAttributeName, $haystackClassOrObject, $message = '') {
    self::assertNotEmpty(self::readAttribute($haystackClassOrObject, $haystackAttributeName), $message);
  }

  /**
   * Asserts that a value is greater than another value.
   *
   * @param mixed  $expected
   * @param mixed  $actual
   * @param string $message
   * @since  Method available since Release 3.1.0
   */
  public static function assertGreaterThan($expected, $actual, $message = '') {
    self::assertThat($actual, self::greaterThan($expected), $message);
  }

  /**
   * Asserts that an attribute is greater than another value.
   *
   * @param mixed  $expected
   * @param string $actualAttributeName
   * @param string $actualClassOrObject
   * @param string $message
   * @since  Method available since Release 3.1.0
   */
  public static function assertAttributeGreaterThan($expected, $actualAttributeName, $actualClassOrObject, $message = '') {
    self::assertGreaterThan($expected, self::readAttribute($actualClassOrObject, $actualAttributeName), $message);
  }

  /**
   * Asserts that a value is greater than or equal to another value.
   *
   * @param mixed  $expected
   * @param mixed  $actual
   * @param string $message
   * @since  Method available since Release 3.1.0
   */
  public static function assertGreaterThanOrEqual($expected, $actual, $message = '') {
    self::assertThat($actual, self::greaterThanOrEqual($expected), $message);
  }

  /**
   * Asserts that an attribute is greater than or equal to another value.
   *
   * @param mixed  $expected
   * @param string $actualAttributeName
   * @param string $actualClassOrObject
   * @param string $message
   * @since  Method available since Release 3.1.0
   */
  public static function assertAttributeGreaterThanOrEqual($expected, $actualAttributeName, $actualClassOrObject, $message = '') {
    self::assertGreaterThanOrEqual($expected, self::readAttribute($actualClassOrObject, $actualAttributeName), $message);
  }

  /**
   * Asserts that a value is smaller than another value.
   *
   * @param mixed  $expected
   * @param mixed  $actual
   * @param string $message
   * @since  Method available since Release 3.1.0
   */
  public static function assertLessThan($expected, $actual, $message = '') {
    self::assertThat($actual, self::lessThan($expected), $message);
  }

  /**
   * Asserts that an attribute is smaller than another value.
   *
   * @param mixed  $expected
   * @param string $actualAttributeName
   * @param string $actualClassOrObject
   * @param string $message
   * @since  Method available since Release 3.1.0
   */
  public static function assertAttributeLessThan($expected, $actualAttributeName, $actualClassOrObject, $message = '') {
    self::assertLessThan($expected, self::readAttribute($actualClassOrObject, $actualAttributeName), $message);
  }

  /**
   * Asserts that a value is smaller than or equal to another value.
   *
   * @param mixed  $expected
   * @param mixed  $actual
   * @param string $message
   * @since  Method available since Release 3.1.0
   */
  public static function assertLessThanOrEqual($expected, $actual, $message = '') {
    self::assertThat($actual, self::lessThanOrEqual($expected), $message);
  }

  /**
   * Asserts that an attribute is smaller than or equal to another value.
   *
   * @param mixed  $expected
   * @param string $actualAttributeName
   * @param string $actualClassOrObject
   * @param string $message
   * @since  Method available since Release 3.1.0
   */
  public static function assertAttributeLessThanOrEqual($expected, $actualAttributeName, $actualClassOrObject, $message = '') {
    self::assertLessThanOrEqual($expected, self::readAttribute($actualClassOrObject, $actualAttributeName), $message);
  }

  /**
   * Asserts that the contents of one file is equal to the contents of another
   * file.
   *
   * @param string $expected
   * @param string $actual
   * @param string $message
   * @param bool   $canonicalize
   * @param bool   $ignoreCase
   * @since  Method available since Release 3.2.14
   */
  public static function assertFileEquals($expected, $actual, $message = '', $canonicalize = false, $ignoreCase = false) {
    self::assertFileExists($expected, $message);
    self::assertFileExists($actual, $message);
    self::assertEquals(file_get_contents($expected), file_get_contents($actual), $message, 0, 10, $canonicalize, $ignoreCase);
  }

  /**
   * Asserts that the contents of one file is not equal to the contents of
   * another file.
   *
   * @param string $expected
   * @param string $actual
   * @param string $message
   * @param bool   $canonicalize
   * @param bool   $ignoreCase
   * @since  Method available since Release 3.2.14
   */
  public static function assertFileNotEquals($expected, $actual, $message = '', $canonicalize = false, $ignoreCase = false) {
    self::assertFileExists($expected, $message);
    self::assertFileExists($actual, $message);
    self::assertNotEquals(file_get_contents($expected), file_get_contents($actual), $message, 0, 10, $canonicalize, $ignoreCase);
  }

  /**
   * Asserts that the contents of a string is equal
   * to the contents of a file.
   *
   * @param string $expectedFile
   * @param string $actualString
   * @param string $message
   * @param bool   $canonicalize
   * @param bool   $ignoreCase
   * @since  Method available since Release 3.3.0
   */
  public static function assertStringEqualsFile($expectedFile, $actualString, $message = '', $canonicalize = false, $ignoreCase = false) {
    self::assertFileExists($expectedFile, $message);
    self::assertEquals(file_get_contents($expectedFile), $actualString, $message, 0, 10, $canonicalize, $ignoreCase);
  }

  /**
   * Asserts that the contents of a string is not equal
   * to the contents of a file.
   *
   * @param string $expectedFile
   * @param string $actualString
   * @param string $message
   * @param bool   $canonicalize
   * @param bool   $ignoreCase
   * @since  Method available since Release 3.3.0
   */
  public static function assertStringNotEqualsFile($expectedFile, $actualString, $message = '', $canonicalize = false, $ignoreCase = false) {
    self::assertFileExists($expectedFile, $message);
    self::assertNotEquals(file_get_contents($expectedFile), $actualString, $message, 0, 10, $canonicalize, $ignoreCase);
  }

  /**
   * Asserts that a file exists.
   *
   * @param string $filename
   * @param string $message
   * @since  Method available since Release 3.0.0
   */
  public static function assertFileExists($filename, $message = '') {
    if (!is_string($filename)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'string');
    }
    $constraint = new PHPUnit_Framework_Constraint_FileExists();
    self::assertThat($filename, $constraint, $message);
  }

  /**
   * Asserts that a file does not exist.
   *
   * @param string $filename
   * @param string $message
   * @since  Method available since Release 3.0.0
   */
  public static function assertFileNotExists($filename, $message = '') {
    if (!is_string($filename)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'string');
    }
    $constraint = new PHPUnit_Framework_Constraint_Not(new PHPUnit_Framework_Constraint_FileExists());
    self::assertThat($filename, $constraint, $message);
  }

  /**
   * Asserts that a condition is true.
   *
   * @param  bool                                   $condition
   * @param  string                                 $message
   * @throws PHPUnit_Framework_AssertionFailedError
   */
  public static function assertTrue($condition, $message = '') {
    self::assertThat($condition, self::isTrue(), $message);
  }

  /**
   * Asserts that a condition is not true.
   *
   * @param  bool                                   $condition
   * @param  string                                 $message
   * @throws PHPUnit_Framework_AssertionFailedError
   */
  public static function assertNotTrue($condition, $message = '') {
    self::assertThat($condition, self::logicalNot(self::isTrue()), $message);
  }

  /**
   * Asserts that a condition is false.
   *
   * @param  bool                                   $condition
   * @param  string                                 $message
   * @throws PHPUnit_Framework_AssertionFailedError
   */
  public static function assertFalse($condition, $message = '') {
    self::assertThat($condition, self::isFalse(), $message);
  }

  /**
   * Asserts that a condition is not false.
   *
   * @param  bool                                   $condition
   * @param  string                                 $message
   * @throws PHPUnit_Framework_AssertionFailedError
   */
  public static function assertNotFalse($condition, $message = '') {
    self::assertThat($condition, self::logicalNot(self::isFalse()), $message);
  }

  /**
   * Asserts that a variable is not null.
   *
   * @param mixed  $actual
   * @param string $message
   */
  public static function assertNotNull($actual, $message = '') {
    self::assertThat($actual, self::logicalNot(self::isNull()), $message);
  }

  /**
   * Asserts that a variable is null.
   *
   * @param mixed  $actual
   * @param string $message
   */
  public static function assertNull($actual, $message = '') {
    self::assertThat($actual, self::isNull(), $message);
  }

  /**
   * Asserts that a class has a specified attribute.
   *
   * @param string $attributeName
   * @param string $className
   * @param string $message
   * @since  Method available since Release 3.1.0
   */
  public static function assertClassHasAttribute($attributeName, $className, $message = '') {
    if (!is_string($attributeName)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'string');
    }
    if (!preg_match('/[a-zA-Z_\\x7f-\\xff][a-zA-Z0-9_\\x7f-\\xff]*/', $attributeName)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'valid attribute name');
    }
    if (!is_string($className) || !class_exists($className)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(2, 'class name', $className);
    }
    $constraint = new PHPUnit_Framework_Constraint_ClassHasAttribute($attributeName);
    self::assertThat($className, $constraint, $message);
  }

  /**
   * Asserts that a class does not have a specified attribute.
   *
   * @param string $attributeName
   * @param string $className
   * @param string $message
   * @since  Method available since Release 3.1.0
   */
  public static function assertClassNotHasAttribute($attributeName, $className, $message = '') {
    if (!is_string($attributeName)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'string');
    }
    if (!preg_match('/[a-zA-Z_\\x7f-\\xff][a-zA-Z0-9_\\x7f-\\xff]*/', $attributeName)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'valid attribute name');
    }
    if (!is_string($className) || !class_exists($className)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(2, 'class name', $className);
    }
    $constraint = new PHPUnit_Framework_Constraint_Not(new PHPUnit_Framework_Constraint_ClassHasAttribute($attributeName));
    self::assertThat($className, $constraint, $message);
  }

  /**
   * Asserts that a class has a specified static attribute.
   *
   * @param string $attributeName
   * @param string $className
   * @param string $message
   * @since  Method available since Release 3.1.0
   */
  public static function assertClassHasStaticAttribute($attributeName, $className, $message = '') {
    if (!is_string($attributeName)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'string');
    }
    if (!preg_match('/[a-zA-Z_\\x7f-\\xff][a-zA-Z0-9_\\x7f-\\xff]*/', $attributeName)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'valid attribute name');
    }
    if (!is_string($className) || !class_exists($className)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(2, 'class name', $className);
    }
    $constraint = new PHPUnit_Framework_Constraint_ClassHasStaticAttribute($attributeName);
    self::assertThat($className, $constraint, $message);
  }

  /**
   * Asserts that a class does not have a specified static attribute.
   *
   * @param string $attributeName
   * @param string $className
   * @param string $message
   * @since  Method available since Release 3.1.0
   */
  public static function assertClassNotHasStaticAttribute($attributeName, $className, $message = '') {
    if (!is_string($attributeName)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'string');
    }
    if (!preg_match('/[a-zA-Z_\\x7f-\\xff][a-zA-Z0-9_\\x7f-\\xff]*/', $attributeName)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'valid attribute name');
    }
    if (!is_string($className) || !class_exists($className)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(2, 'class name', $className);
    }
    $constraint = new PHPUnit_Framework_Constraint_Not(new PHPUnit_Framework_Constraint_ClassHasStaticAttribute($attributeName));
    self::assertThat($className, $constraint, $message);
  }

  /**
   * Asserts that an object has a specified attribute.
   *
   * @param string $attributeName
   * @param object $object
   * @param string $message
   * @since  Method available since Release 3.0.0
   */
  public static function assertObjectHasAttribute($attributeName, $object, $message = '') {
    if (!is_string($attributeName)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'string');
    }
    if (!preg_match('/[a-zA-Z_\\x7f-\\xff][a-zA-Z0-9_\\x7f-\\xff]*/', $attributeName)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'valid attribute name');
    }
    if (!is_object($object)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(2, 'object');
    }
    $constraint = new PHPUnit_Framework_Constraint_ObjectHasAttribute($attributeName);
    self::assertThat($object, $constraint, $message);
  }

  /**
   * Asserts that an object does not have a specified attribute.
   *
   * @param string $attributeName
   * @param object $object
   * @param string $message
   * @since  Method available since Release 3.0.0
   */
  public static function assertObjectNotHasAttribute($attributeName, $object, $message = '') {
    if (!is_string($attributeName)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'string');
    }
    if (!preg_match('/[a-zA-Z_\\x7f-\\xff][a-zA-Z0-9_\\x7f-\\xff]*/', $attributeName)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'valid attribute name');
    }
    if (!is_object($object)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(2, 'object');
    }
    $constraint = new PHPUnit_Framework_Constraint_Not(new PHPUnit_Framework_Constraint_ObjectHasAttribute($attributeName));
    self::assertThat($object, $constraint, $message);
  }

  /**
   * Asserts that two variables have the same type and value.
   * Used on objects, it asserts that two variables reference
   * the same object.
   *
   * @param mixed  $expected
   * @param mixed  $actual
   * @param string $message
   */
  public static function assertSame($expected, $actual, $message = '') {
    if (is_bool($expected) && is_bool($actual)) {
      self::assertEquals($expected, $actual, $message);
    }
    else {
      $constraint = new PHPUnit_Framework_Constraint_IsIdentical($expected);
      self::assertThat($actual, $constraint, $message);
    }
  }

  /**
   * Asserts that a variable and an attribute of an object have the same type
   * and value.
   *
   * @param mixed  $expected
   * @param string $actualAttributeName
   * @param object $actualClassOrObject
   * @param string $message
   */
  public static function assertAttributeSame($expected, $actualAttributeName, $actualClassOrObject, $message = '') {
    self::assertSame($expected, self::readAttribute($actualClassOrObject, $actualAttributeName), $message);
  }

  /**
   * 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.
   *
   * @param mixed  $expected
   * @param mixed  $actual
   * @param string $message
   */
  public static function assertNotSame($expected, $actual, $message = '') {
    if (is_bool($expected) && is_bool($actual)) {
      self::assertNotEquals($expected, $actual, $message);
    }
    else {
      $constraint = new PHPUnit_Framework_Constraint_Not(new PHPUnit_Framework_Constraint_IsIdentical($expected));
      self::assertThat($actual, $constraint, $message);
    }
  }

  /**
   * Asserts that a variable and an attribute of an object do not have the
   * same type and value.
   *
   * @param mixed  $expected
   * @param string $actualAttributeName
   * @param object $actualClassOrObject
   * @param string $message
   */
  public static function assertAttributeNotSame($expected, $actualAttributeName, $actualClassOrObject, $message = '') {
    self::assertNotSame($expected, self::readAttribute($actualClassOrObject, $actualAttributeName), $message);
  }

  /**
   * Asserts that a variable is of a given type.
   *
   * @param string $expected
   * @param mixed  $actual
   * @param string $message
   * @since Method available since Release 3.5.0
   */
  public static function assertInstanceOf($expected, $actual, $message = '') {
    if (!(is_string($expected) && (class_exists($expected) || interface_exists($expected)))) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'class or interface name');
    }
    $constraint = new PHPUnit_Framework_Constraint_IsInstanceOf($expected);
    self::assertThat($actual, $constraint, $message);
  }

  /**
   * Asserts that an attribute is of a given type.
   *
   * @param string $expected
   * @param string $attributeName
   * @param mixed  $classOrObject
   * @param string $message
   * @since Method available since Release 3.5.0
   */
  public static function assertAttributeInstanceOf($expected, $attributeName, $classOrObject, $message = '') {
    self::assertInstanceOf($expected, self::readAttribute($classOrObject, $attributeName), $message);
  }

  /**
   * Asserts that a variable is not of a given type.
   *
   * @param string $expected
   * @param mixed  $actual
   * @param string $message
   * @since Method available since Release 3.5.0
   */
  public static function assertNotInstanceOf($expected, $actual, $message = '') {
    if (!(is_string($expected) && (class_exists($expected) || interface_exists($expected)))) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'class or interface name');
    }
    $constraint = new PHPUnit_Framework_Constraint_Not(new PHPUnit_Framework_Constraint_IsInstanceOf($expected));
    self::assertThat($actual, $constraint, $message);
  }

  /**
   * Asserts that an attribute is of a given type.
   *
   * @param string $expected
   * @param string $attributeName
   * @param mixed  $classOrObject
   * @param string $message
   * @since Method available since Release 3.5.0
   */
  public static function assertAttributeNotInstanceOf($expected, $attributeName, $classOrObject, $message = '') {
    self::assertNotInstanceOf($expected, self::readAttribute($classOrObject, $attributeName), $message);
  }

  /**
   * Asserts that a variable is of a given type.
   *
   * @param string $expected
   * @param mixed  $actual
   * @param string $message
   * @since Method available since Release 3.5.0
   */
  public static function assertInternalType($expected, $actual, $message = '') {
    if (!is_string($expected)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'string');
    }
    $constraint = new PHPUnit_Framework_Constraint_IsType($expected);
    self::assertThat($actual, $constraint, $message);
  }

  /**
   * Asserts that an attribute is of a given type.
   *
   * @param string $expected
   * @param string $attributeName
   * @param mixed  $classOrObject
   * @param string $message
   * @since Method available since Release 3.5.0
   */
  public static function assertAttributeInternalType($expected, $attributeName, $classOrObject, $message = '') {
    self::assertInternalType($expected, self::readAttribute($classOrObject, $attributeName), $message);
  }

  /**
   * Asserts that a variable is not of a given type.
   *
   * @param string $expected
   * @param mixed  $actual
   * @param string $message
   * @since Method available since Release 3.5.0
   */
  public static function assertNotInternalType($expected, $actual, $message = '') {
    if (!is_string($expected)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'string');
    }
    $constraint = new PHPUnit_Framework_Constraint_Not(new PHPUnit_Framework_Constraint_IsType($expected));
    self::assertThat($actual, $constraint, $message);
  }

  /**
   * Asserts that an attribute is of a given type.
   *
   * @param string $expected
   * @param string $attributeName
   * @param mixed  $classOrObject
   * @param string $message
   * @since Method available since Release 3.5.0
   */
  public static function assertAttributeNotInternalType($expected, $attributeName, $classOrObject, $message = '') {
    self::assertNotInternalType($expected, self::readAttribute($classOrObject, $attributeName), $message);
  }

  /**
   * Asserts that a string matches a given regular expression.
   *
   * @param string $pattern
   * @param string $string
   * @param string $message
   */
  public static function assertRegExp($pattern, $string, $message = '') {
    if (!is_string($pattern)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'string');
    }
    if (!is_string($string)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(2, 'string');
    }
    $constraint = new PHPUnit_Framework_Constraint_PCREMatch($pattern);
    self::assertThat($string, $constraint, $message);
  }

  /**
   * Asserts that a string does not match a given regular expression.
   *
   * @param string $pattern
   * @param string $string
   * @param string $message
   * @since  Method available since Release 2.1.0
   */
  public static function assertNotRegExp($pattern, $string, $message = '') {
    if (!is_string($pattern)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'string');
    }
    if (!is_string($string)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(2, 'string');
    }
    $constraint = new PHPUnit_Framework_Constraint_Not(new PHPUnit_Framework_Constraint_PCREMatch($pattern));
    self::assertThat($string, $constraint, $message);
  }

  /**
   * Assert that the size of two arrays (or `Countable` or `Traversable` objects)
   * is the same.
   *
   * @param array|Countable|Traversable $expected
   * @param array|Countable|Traversable $actual
   * @param string                      $message
   */
  public static function assertSameSize($expected, $actual, $message = '') {
    if (!$expected instanceof Countable && !$expected instanceof Traversable && !is_array($expected)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'countable or traversable');
    }
    if (!$actual instanceof Countable && !$actual instanceof Traversable && !is_array($actual)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(2, 'countable or traversable');
    }
    self::assertThat($actual, new PHPUnit_Framework_Constraint_SameSize($expected), $message);
  }

  /**
   * Assert that the size of two arrays (or `Countable` or `Traversable` objects)
   * is not the same.
   *
   * @param array|Countable|Traversable $expected
   * @param array|Countable|Traversable $actual
   * @param string                      $message
   */
  public static function assertNotSameSize($expected, $actual, $message = '') {
    if (!$expected instanceof Countable && !$expected instanceof Traversable && !is_array($expected)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'countable or traversable');
    }
    if (!$actual instanceof Countable && !$actual instanceof Traversable && !is_array($actual)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(2, 'countable or traversable');
    }
    $constraint = new PHPUnit_Framework_Constraint_Not(new PHPUnit_Framework_Constraint_SameSize($expected));
    self::assertThat($actual, $constraint, $message);
  }

  /**
   * Asserts that a string matches a given format string.
   *
   * @param string $format
   * @param string $string
   * @param string $message
   * @since  Method available since Release 3.5.0
   */
  public static function assertStringMatchesFormat($format, $string, $message = '') {
    if (!is_string($format)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'string');
    }
    if (!is_string($string)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(2, 'string');
    }
    $constraint = new PHPUnit_Framework_Constraint_StringMatches($format);
    self::assertThat($string, $constraint, $message);
  }

  /**
   * Asserts that a string does not match a given format string.
   *
   * @param string $format
   * @param string $string
   * @param string $message
   * @since  Method available since Release 3.5.0
   */
  public static function assertStringNotMatchesFormat($format, $string, $message = '') {
    if (!is_string($format)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'string');
    }
    if (!is_string($string)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(2, 'string');
    }
    $constraint = new PHPUnit_Framework_Constraint_Not(new PHPUnit_Framework_Constraint_StringMatches($format));
    self::assertThat($string, $constraint, $message);
  }

  /**
   * Asserts that a string matches a given format file.
   *
   * @param string $formatFile
   * @param string $string
   * @param string $message
   * @since  Method available since Release 3.5.0
   */
  public static function assertStringMatchesFormatFile($formatFile, $string, $message = '') {
    self::assertFileExists($formatFile, $message);
    if (!is_string($string)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(2, 'string');
    }
    $constraint = new PHPUnit_Framework_Constraint_StringMatches(file_get_contents($formatFile));
    self::assertThat($string, $constraint, $message);
  }

  /**
   * Asserts that a string does not match a given format string.
   *
   * @param string $formatFile
   * @param string $string
   * @param string $message
   * @since  Method available since Release 3.5.0
   */
  public static function assertStringNotMatchesFormatFile($formatFile, $string, $message = '') {
    self::assertFileExists($formatFile, $message);
    if (!is_string($string)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(2, 'string');
    }
    $constraint = new PHPUnit_Framework_Constraint_Not(new PHPUnit_Framework_Constraint_StringMatches(file_get_contents($formatFile)));
    self::assertThat($string, $constraint, $message);
  }

  /**
   * Asserts that a string starts with a given prefix.
   *
   * @param string $prefix
   * @param string $string
   * @param string $message
   * @since  Method available since Release 3.4.0
   */
  public static function assertStringStartsWith($prefix, $string, $message = '') {
    if (!is_string($prefix)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'string');
    }
    if (!is_string($string)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(2, 'string');
    }
    $constraint = new PHPUnit_Framework_Constraint_StringStartsWith($prefix);
    self::assertThat($string, $constraint, $message);
  }

  /**
   * Asserts that a string starts not with a given prefix.
   *
   * @param string $prefix
   * @param string $string
   * @param string $message
   * @since  Method available since Release 3.4.0
   */
  public static function assertStringStartsNotWith($prefix, $string, $message = '') {
    if (!is_string($prefix)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'string');
    }
    if (!is_string($string)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(2, 'string');
    }
    $constraint = new PHPUnit_Framework_Constraint_Not(new PHPUnit_Framework_Constraint_StringStartsWith($prefix));
    self::assertThat($string, $constraint, $message);
  }

  /**
   * Asserts that a string ends with a given suffix.
   *
   * @param string $suffix
   * @param string $string
   * @param string $message
   * @since  Method available since Release 3.4.0
   */
  public static function assertStringEndsWith($suffix, $string, $message = '') {
    if (!is_string($suffix)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'string');
    }
    if (!is_string($string)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(2, 'string');
    }
    $constraint = new PHPUnit_Framework_Constraint_StringEndsWith($suffix);
    self::assertThat($string, $constraint, $message);
  }

  /**
   * Asserts that a string ends not with a given suffix.
   *
   * @param string $suffix
   * @param string $string
   * @param string $message
   * @since  Method available since Release 3.4.0
   */
  public static function assertStringEndsNotWith($suffix, $string, $message = '') {
    if (!is_string($suffix)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'string');
    }
    if (!is_string($string)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(2, 'string');
    }
    $constraint = new PHPUnit_Framework_Constraint_Not(new PHPUnit_Framework_Constraint_StringEndsWith($suffix));
    self::assertThat($string, $constraint, $message);
  }

  /**
   * Asserts that two XML files are equal.
   *
   * @param string $expectedFile
   * @param string $actualFile
   * @param string $message
   * @since  Method available since Release 3.1.0
   */
  public static function assertXmlFileEqualsXmlFile($expectedFile, $actualFile, $message = '') {
    $expected = PHPUnit_Util_XML::loadFile($expectedFile);
    $actual = PHPUnit_Util_XML::loadFile($actualFile);
    self::assertEquals($expected, $actual, $message);
  }

  /**
   * Asserts that two XML files are not equal.
   *
   * @param string $expectedFile
   * @param string $actualFile
   * @param string $message
   * @since  Method available since Release 3.1.0
   */
  public static function assertXmlFileNotEqualsXmlFile($expectedFile, $actualFile, $message = '') {
    $expected = PHPUnit_Util_XML::loadFile($expectedFile);
    $actual = PHPUnit_Util_XML::loadFile($actualFile);
    self::assertNotEquals($expected, $actual, $message);
  }

  /**
   * Asserts that two XML documents are equal.
   *
   * @param string $expectedFile
   * @param string $actualXml
   * @param string $message
   * @since  Method available since Release 3.3.0
   */
  public static function assertXmlStringEqualsXmlFile($expectedFile, $actualXml, $message = '') {
    $expected = PHPUnit_Util_XML::loadFile($expectedFile);
    $actual = PHPUnit_Util_XML::load($actualXml);
    self::assertEquals($expected, $actual, $message);
  }

  /**
   * Asserts that two XML documents are not equal.
   *
   * @param string $expectedFile
   * @param string $actualXml
   * @param string $message
   * @since  Method available since Release 3.3.0
   */
  public static function assertXmlStringNotEqualsXmlFile($expectedFile, $actualXml, $message = '') {
    $expected = PHPUnit_Util_XML::loadFile($expectedFile);
    $actual = PHPUnit_Util_XML::load($actualXml);
    self::assertNotEquals($expected, $actual, $message);
  }

  /**
   * Asserts that two XML documents are equal.
   *
   * @param string $expectedXml
   * @param string $actualXml
   * @param string $message
   * @since  Method available since Release 3.1.0
   */
  public static function assertXmlStringEqualsXmlString($expectedXml, $actualXml, $message = '') {
    $expected = PHPUnit_Util_XML::load($expectedXml);
    $actual = PHPUnit_Util_XML::load($actualXml);
    self::assertEquals($expected, $actual, $message);
  }

  /**
   * Asserts that two XML documents are not equal.
   *
   * @param string $expectedXml
   * @param string $actualXml
   * @param string $message
   * @since  Method available since Release 3.1.0
   */
  public static function assertXmlStringNotEqualsXmlString($expectedXml, $actualXml, $message = '') {
    $expected = PHPUnit_Util_XML::load($expectedXml);
    $actual = PHPUnit_Util_XML::load($actualXml);
    self::assertNotEquals($expected, $actual, $message);
  }

  /**
   * Asserts that a hierarchy of DOMElements matches.
   *
   * @param DOMElement $expectedElement
   * @param DOMElement $actualElement
   * @param bool       $checkAttributes
   * @param string     $message
   * @since  Method available since Release 3.3.0
   */
  public static function assertEqualXMLStructure(DOMElement $expectedElement, DOMElement $actualElement, $checkAttributes = false, $message = '') {
    $tmp = new DOMDocument();
    $expectedElement = $tmp
      ->importNode($expectedElement, true);
    $tmp = new DOMDocument();
    $actualElement = $tmp
      ->importNode($actualElement, true);
    unset($tmp);
    self::assertEquals($expectedElement->tagName, $actualElement->tagName, $message);
    if ($checkAttributes) {
      self::assertEquals($expectedElement->attributes->length, $actualElement->attributes->length, sprintf('%s%sNumber of attributes on node "%s" does not match', $message, !empty($message) ? "\n" : '', $expectedElement->tagName));
      for ($i = 0; $i < $expectedElement->attributes->length; $i++) {
        $expectedAttribute = $expectedElement->attributes
          ->item($i);
        $actualAttribute = $actualElement->attributes
          ->getNamedItem($expectedAttribute->name);
        if (!$actualAttribute) {
          self::fail(sprintf('%s%sCould not find attribute "%s" on node "%s"', $message, !empty($message) ? "\n" : '', $expectedAttribute->name, $expectedElement->tagName));
        }
      }
    }
    PHPUnit_Util_XML::removeCharacterDataNodes($expectedElement);
    PHPUnit_Util_XML::removeCharacterDataNodes($actualElement);
    self::assertEquals($expectedElement->childNodes->length, $actualElement->childNodes->length, sprintf('%s%sNumber of child nodes of "%s" differs', $message, !empty($message) ? "\n" : '', $expectedElement->tagName));
    for ($i = 0; $i < $expectedElement->childNodes->length; $i++) {
      self::assertEqualXMLStructure($expectedElement->childNodes
        ->item($i), $actualElement->childNodes
        ->item($i), $checkAttributes, $message);
    }
  }

  /**
   * Assert the presence, absence, or count of elements in a document matching
   * the CSS $selector, regardless of the contents of those elements.
   *
   * The first argument, $selector, is the CSS selector used to match
   * the elements in the $actual document.
   *
   * The second argument, $count, can be either boolean or numeric.
   * When boolean, it asserts for presence of elements matching the selector
   * (true) or absence of elements (false).
   * When numeric, it asserts the count of elements.
   *
   * assertSelectCount("#binder", true, $xml);  // any?
   * assertSelectCount(".binder", 3, $xml);     // exactly 3?
   *
   * @param array          $selector
   * @param int|bool|array $count
   * @param mixed          $actual
   * @param string         $message
   * @param bool           $isHtml
   * @since  Method available since Release 3.3.0
   * @deprecated
   * @codeCoverageIgnore
   */
  public static function assertSelectCount($selector, $count, $actual, $message = '', $isHtml = true) {
    trigger_error(__METHOD__ . ' is deprecated', E_USER_DEPRECATED);
    self::assertSelectEquals($selector, true, $count, $actual, $message, $isHtml);
  }

  /**
   * assertSelectRegExp("#binder .name", "/Mike|Derek/", true, $xml); // any?
   * assertSelectRegExp("#binder .name", "/Mike|Derek/", 3, $xml);    // 3?
   *
   * @param array          $selector
   * @param string         $pattern
   * @param int|bool|array $count
   * @param mixed          $actual
   * @param string         $message
   * @param bool           $isHtml
   * @since  Method available since Release 3.3.0
   * @deprecated
   * @codeCoverageIgnore
   */
  public static function assertSelectRegExp($selector, $pattern, $count, $actual, $message = '', $isHtml = true) {
    trigger_error(__METHOD__ . ' is deprecated', E_USER_DEPRECATED);
    self::assertSelectEquals($selector, "regexp:{$pattern}", $count, $actual, $message, $isHtml);
  }

  /**
   * assertSelectEquals("#binder .name", "Chuck", true,  $xml);  // any?
   * assertSelectEquals("#binder .name", "Chuck", false, $xml);  // none?
   *
   * @param array          $selector
   * @param string         $content
   * @param int|bool|array $count
   * @param mixed          $actual
   * @param string         $message
   * @param bool           $isHtml
   * @since  Method available since Release 3.3.0
   * @deprecated
   * @codeCoverageIgnore
   */
  public static function assertSelectEquals($selector, $content, $count, $actual, $message = '', $isHtml = true) {
    trigger_error(__METHOD__ . ' is deprecated', E_USER_DEPRECATED);
    $tags = PHPUnit_Util_XML::cssSelect($selector, $content, $actual, $isHtml);

    // assert specific number of elements
    if (is_numeric($count)) {
      $counted = $tags ? count($tags) : 0;
      self::assertEquals($count, $counted, $message);
    }
    elseif (is_bool($count)) {
      $any = count($tags) > 0 && $tags[0] instanceof DOMNode;
      if ($count) {
        self::assertTrue($any, $message);
      }
      else {
        self::assertFalse($any, $message);
      }
    }
    elseif (is_array($count) && (isset($count['>']) || isset($count['<']) || isset($count['>=']) || isset($count['<=']))) {
      $counted = $tags ? count($tags) : 0;
      if (isset($count['>'])) {
        self::assertTrue($counted > $count['>'], $message);
      }
      if (isset($count['>='])) {
        self::assertTrue($counted >= $count['>='], $message);
      }
      if (isset($count['<'])) {
        self::assertTrue($counted < $count['<'], $message);
      }
      if (isset($count['<='])) {
        self::assertTrue($counted <= $count['<='], $message);
      }
    }
    else {
      throw new PHPUnit_Framework_Exception();
    }
  }

  /**
   * Evaluate an HTML or XML string and assert its structure and/or contents.
   *
   * The first argument ($matcher) is an associative array that specifies the
   * match criteria for the assertion:
   *
   *  - `id`           : the node with the given id attribute must match the
   *                     corresponding value.
   *  - `tag`          : the node type must match the corresponding value.
   *  - `attributes`   : a hash. The node's attributes must match the
   *                     corresponding values in the hash.
   *  - `content`      : The text content must match the given value.
   *  - `parent`       : a hash. The node's parent must match the
   *                     corresponding hash.
   *  - `child`        : a hash. At least one of the node's immediate children
   *                     must meet the criteria described by the hash.
   *  - `ancestor`     : a hash. At least one of the node's ancestors must
   *                     meet the criteria described by the hash.
   *  - `descendant`   : a hash. At least one of the node's descendants must
   *                     meet the criteria described by the hash.
   *  - `children`     : a hash, for counting children of a node.
   *                     Accepts the keys:
   *    - `count`        : a number which must equal the number of children
   *                       that match
   *    - `less_than`    : the number of matching children must be greater
   *                       than this number
   *    - `greater_than` : the number of matching children must be less than
   *                       this number
   *    - `only`         : another hash consisting of the keys to use to match
   *                       on the children, and only matching children will be
   *                       counted
   *
   * <code>
   * // Matcher that asserts that there is an element with an id="my_id".
   * $matcher = array('id' => 'my_id');
   *
   * // Matcher that asserts that there is a "span" tag.
   * $matcher = array('tag' => 'span');
   *
   * // Matcher that asserts that there is a "span" tag with the content
   * // "Hello World".
   * $matcher = array('tag' => 'span', 'content' => 'Hello World');
   *
   * // Matcher that asserts that there is a "span" tag with content matching
   * // the regular expression pattern.
   * $matcher = array('tag' => 'span', 'content' => 'regexp:/Try P(HP|ython)/');
   *
   * // Matcher that asserts that there is a "span" with an "list" class
   * // attribute.
   * $matcher = array(
   *   'tag'        => 'span',
   *   'attributes' => array('class' => 'list')
   * );
   *
   * // Matcher that asserts that there is a "span" inside of a "div".
   * $matcher = array(
   *   'tag'    => 'span',
   *   'parent' => array('tag' => 'div')
   * );
   *
   * // Matcher that asserts that there is a "span" somewhere inside a
   * // "table".
   * $matcher = array(
   *   'tag'      => 'span',
   *   'ancestor' => array('tag' => 'table')
   * );
   *
   * // Matcher that asserts that there is a "span" with at least one "em"
   * // child.
   * $matcher = array(
   *   'tag'   => 'span',
   *   'child' => array('tag' => 'em')
   * );
   *
   * // Matcher that asserts that there is a "span" containing a (possibly
   * // nested) "strong" tag.
   * $matcher = array(
   *   'tag'        => 'span',
   *   'descendant' => array('tag' => 'strong')
   * );
   *
   * // Matcher that asserts that there is a "span" containing 5-10 "em" tags
   * // as immediate children.
   * $matcher = array(
   *   'tag'      => 'span',
   *   'children' => array(
   *     'less_than'    => 11,
   *     'greater_than' => 4,
   *     'only'         => array('tag' => 'em')
   *   )
   * );
   *
   * // Matcher that asserts that there is a "div", with an "ul" ancestor and
   * // a "li" parent (with class="enum"), and containing a "span" descendant
   * // that contains an element with id="my_test" and the text "Hello World".
   * $matcher = array(
   *   'tag'        => 'div',
   *   'ancestor'   => array('tag' => 'ul'),
   *   'parent'     => array(
   *     'tag'        => 'li',
   *     'attributes' => array('class' => 'enum')
   *   ),
   *   'descendant' => array(
   *     'tag'   => 'span',
   *     'child' => array(
   *       'id'      => 'my_test',
   *       'content' => 'Hello World'
   *     )
   *   )
   * );
   *
   * // Use assertTag() to apply a $matcher to a piece of $html.
   * $this->assertTag($matcher, $html);
   *
   * // Use assertTag() to apply a $matcher to a piece of $xml.
   * $this->assertTag($matcher, $xml, '', false);
   * </code>
   *
   * The second argument ($actual) is a string containing either HTML or
   * XML text to be tested.
   *
   * The third argument ($message) is an optional message that will be
   * used if the assertion fails.
   *
   * The fourth argument ($html) is an optional flag specifying whether
   * to load the $actual string into a DOMDocument using the HTML or
   * XML load strategy.  It is true by default, which assumes the HTML
   * load strategy.  In many cases, this will be acceptable for XML as well.
   *
   * @param array  $matcher
   * @param string $actual
   * @param string $message
   * @param bool   $isHtml
   * @since  Method available since Release 3.3.0
   * @deprecated
   * @codeCoverageIgnore
   */
  public static function assertTag($matcher, $actual, $message = '', $isHtml = true) {
    trigger_error(__METHOD__ . ' is deprecated', E_USER_DEPRECATED);
    $dom = PHPUnit_Util_XML::load($actual, $isHtml);
    $tags = PHPUnit_Util_XML::findNodes($dom, $matcher, $isHtml);
    $matched = count($tags) > 0 && $tags[0] instanceof DOMNode;
    self::assertTrue($matched, $message);
  }

  /**
   * This assertion is the exact opposite of assertTag().
   *
   * Rather than asserting that $matcher results in a match, it asserts that
   * $matcher does not match.
   *
   * @param array  $matcher
   * @param string $actual
   * @param string $message
   * @param bool   $isHtml
   * @since  Method available since Release 3.3.0
   * @deprecated
   * @codeCoverageIgnore
   */
  public static function assertNotTag($matcher, $actual, $message = '', $isHtml = true) {
    trigger_error(__METHOD__ . ' is deprecated', E_USER_DEPRECATED);
    $dom = PHPUnit_Util_XML::load($actual, $isHtml);
    $tags = PHPUnit_Util_XML::findNodes($dom, $matcher, $isHtml);
    $matched = count($tags) > 0 && $tags[0] instanceof DOMNode;
    self::assertFalse($matched, $message);
  }

  /**
   * Evaluates a PHPUnit_Framework_Constraint matcher object.
   *
   * @param mixed                        $value
   * @param PHPUnit_Framework_Constraint $constraint
   * @param string                       $message
   * @since  Method available since Release 3.0.0
   */
  public static function assertThat($value, PHPUnit_Framework_Constraint $constraint, $message = '') {
    self::$count += count($constraint);
    $constraint
      ->evaluate($value, $message);
  }

  /**
   * Asserts that a string is a valid JSON string.
   *
   * @param string $actualJson
   * @param string $message
   * @since  Method available since Release 3.7.20
   */
  public static function assertJson($actualJson, $message = '') {
    if (!is_string($actualJson)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'string');
    }
    self::assertThat($actualJson, self::isJson(), $message);
  }

  /**
   * Asserts that two given JSON encoded objects or arrays are equal.
   *
   * @param string $expectedJson
   * @param string $actualJson
   * @param string $message
   */
  public static function assertJsonStringEqualsJsonString($expectedJson, $actualJson, $message = '') {
    self::assertJson($expectedJson, $message);
    self::assertJson($actualJson, $message);
    $expected = json_decode($expectedJson);
    $actual = json_decode($actualJson);
    self::assertEquals($expected, $actual, $message);
  }

  /**
   * Asserts that two given JSON encoded objects or arrays are not equal.
   *
   * @param string $expectedJson
   * @param string $actualJson
   * @param string $message
   */
  public static function assertJsonStringNotEqualsJsonString($expectedJson, $actualJson, $message = '') {
    self::assertJson($expectedJson, $message);
    self::assertJson($actualJson, $message);
    $expected = json_decode($expectedJson);
    $actual = json_decode($actualJson);
    self::assertNotEquals($expected, $actual, $message);
  }

  /**
   * Asserts that the generated JSON encoded object and the content of the given file are equal.
   *
   * @param string $expectedFile
   * @param string $actualJson
   * @param string $message
   */
  public static function assertJsonStringEqualsJsonFile($expectedFile, $actualJson, $message = '') {
    self::assertFileExists($expectedFile, $message);
    $expectedJson = file_get_contents($expectedFile);
    self::assertJson($expectedJson, $message);
    self::assertJson($actualJson, $message);

    // call constraint
    $constraint = new PHPUnit_Framework_Constraint_JsonMatches($expectedJson);
    self::assertThat($actualJson, $constraint, $message);
  }

  /**
   * Asserts that the generated JSON encoded object and the content of the given file are not equal.
   *
   * @param string $expectedFile
   * @param string $actualJson
   * @param string $message
   */
  public static function assertJsonStringNotEqualsJsonFile($expectedFile, $actualJson, $message = '') {
    self::assertFileExists($expectedFile, $message);
    $expectedJson = file_get_contents($expectedFile);
    self::assertJson($expectedJson, $message);
    self::assertJson($actualJson, $message);

    // call constraint
    $constraint = new PHPUnit_Framework_Constraint_JsonMatches($expectedJson);
    self::assertThat($actualJson, new PHPUnit_Framework_Constraint_Not($constraint), $message);
  }

  /**
   * Asserts that two JSON files are not equal.
   *
   * @param string $expectedFile
   * @param string $actualFile
   * @param string $message
   */
  public static function assertJsonFileNotEqualsJsonFile($expectedFile, $actualFile, $message = '') {
    self::assertFileExists($expectedFile, $message);
    self::assertFileExists($actualFile, $message);
    $actualJson = file_get_contents($actualFile);
    $expectedJson = file_get_contents($expectedFile);
    self::assertJson($expectedJson, $message);
    self::assertJson($actualJson, $message);

    // call constraint
    $constraintExpected = new PHPUnit_Framework_Constraint_JsonMatches($expectedJson);
    $constraintActual = new PHPUnit_Framework_Constraint_JsonMatches($actualJson);
    self::assertThat($expectedJson, new PHPUnit_Framework_Constraint_Not($constraintActual), $message);
    self::assertThat($actualJson, new PHPUnit_Framework_Constraint_Not($constraintExpected), $message);
  }

  /**
   * Asserts that two JSON files are equal.
   *
   * @param string $expectedFile
   * @param string $actualFile
   * @param string $message
   */
  public static function assertJsonFileEqualsJsonFile($expectedFile, $actualFile, $message = '') {
    self::assertFileExists($expectedFile, $message);
    self::assertFileExists($actualFile, $message);
    $actualJson = file_get_contents($actualFile);
    $expectedJson = file_get_contents($expectedFile);
    self::assertJson($expectedJson, $message);
    self::assertJson($actualJson, $message);

    // call constraint
    $constraintExpected = new PHPUnit_Framework_Constraint_JsonMatches($expectedJson);
    $constraintActual = new PHPUnit_Framework_Constraint_JsonMatches($actualJson);
    self::assertThat($expectedJson, $constraintActual, $message);
    self::assertThat($actualJson, $constraintExpected, $message);
  }

  /**
   * Returns a PHPUnit_Framework_Constraint_And matcher object.
   *
   * @return PHPUnit_Framework_Constraint_And
   * @since  Method available since Release 3.0.0
   */
  public static function logicalAnd() {
    $constraints = func_get_args();
    $constraint = new PHPUnit_Framework_Constraint_And();
    $constraint
      ->setConstraints($constraints);
    return $constraint;
  }

  /**
   * Returns a PHPUnit_Framework_Constraint_Or matcher object.
   *
   * @return PHPUnit_Framework_Constraint_Or
   * @since  Method available since Release 3.0.0
   */
  public static function logicalOr() {
    $constraints = func_get_args();
    $constraint = new PHPUnit_Framework_Constraint_Or();
    $constraint
      ->setConstraints($constraints);
    return $constraint;
  }

  /**
   * Returns a PHPUnit_Framework_Constraint_Not matcher object.
   *
   * @param  PHPUnit_Framework_Constraint     $constraint
   * @return PHPUnit_Framework_Constraint_Not
   * @since  Method available since Release 3.0.0
   */
  public static function logicalNot(PHPUnit_Framework_Constraint $constraint) {
    return new PHPUnit_Framework_Constraint_Not($constraint);
  }

  /**
   * Returns a PHPUnit_Framework_Constraint_Xor matcher object.
   *
   * @return PHPUnit_Framework_Constraint_Xor
   * @since  Method available since Release 3.0.0
   */
  public static function logicalXor() {
    $constraints = func_get_args();
    $constraint = new PHPUnit_Framework_Constraint_Xor();
    $constraint
      ->setConstraints($constraints);
    return $constraint;
  }

  /**
   * Returns a PHPUnit_Framework_Constraint_IsAnything matcher object.
   *
   * @return PHPUnit_Framework_Constraint_IsAnything
   * @since  Method available since Release 3.0.0
   */
  public static function anything() {
    return new PHPUnit_Framework_Constraint_IsAnything();
  }

  /**
   * Returns a PHPUnit_Framework_Constraint_IsTrue matcher object.
   *
   * @return PHPUnit_Framework_Constraint_IsTrue
   * @since  Method available since Release 3.3.0
   */
  public static function isTrue() {
    return new PHPUnit_Framework_Constraint_IsTrue();
  }

  /**
   * Returns a PHPUnit_Framework_Constraint_Callback matcher object.
   *
   * @param  callable                              $callback
   * @return PHPUnit_Framework_Constraint_Callback
   */
  public static function callback($callback) {
    return new PHPUnit_Framework_Constraint_Callback($callback);
  }

  /**
   * Returns a PHPUnit_Framework_Constraint_IsFalse matcher object.
   *
   * @return PHPUnit_Framework_Constraint_IsFalse
   * @since  Method available since Release 3.3.0
   */
  public static function isFalse() {
    return new PHPUnit_Framework_Constraint_IsFalse();
  }

  /**
   * Returns a PHPUnit_Framework_Constraint_IsJson matcher object.
   *
   * @return PHPUnit_Framework_Constraint_IsJson
   * @since  Method available since Release 3.7.20
   */
  public static function isJson() {
    return new PHPUnit_Framework_Constraint_IsJson();
  }

  /**
   * Returns a PHPUnit_Framework_Constraint_IsNull matcher object.
   *
   * @return PHPUnit_Framework_Constraint_IsNull
   * @since  Method available since Release 3.3.0
   */
  public static function isNull() {
    return new PHPUnit_Framework_Constraint_IsNull();
  }

  /**
   * Returns a PHPUnit_Framework_Constraint_Attribute matcher object.
   *
   * @param  PHPUnit_Framework_Constraint           $constraint
   * @param  string                                 $attributeName
   * @return PHPUnit_Framework_Constraint_Attribute
   * @since  Method available since Release 3.1.0
   */
  public static function attribute(PHPUnit_Framework_Constraint $constraint, $attributeName) {
    return new PHPUnit_Framework_Constraint_Attribute($constraint, $attributeName);
  }

  /**
   * Returns a PHPUnit_Framework_Constraint_TraversableContains matcher
   * object.
   *
   * @param  mixed                                            $value
   * @param  bool                                             $checkForObjectIdentity
   * @param  bool                                             $checkForNonObjectIdentity
   * @return PHPUnit_Framework_Constraint_TraversableContains
   * @since  Method available since Release 3.0.0
   */
  public static function contains($value, $checkForObjectIdentity = true, $checkForNonObjectIdentity = false) {
    return new PHPUnit_Framework_Constraint_TraversableContains($value, $checkForObjectIdentity, $checkForNonObjectIdentity);
  }

  /**
   * Returns a PHPUnit_Framework_Constraint_TraversableContainsOnly matcher
   * object.
   *
   * @param  string                                               $type
   * @return PHPUnit_Framework_Constraint_TraversableContainsOnly
   * @since  Method available since Release 3.1.4
   */
  public static function containsOnly($type) {
    return new PHPUnit_Framework_Constraint_TraversableContainsOnly($type);
  }

  /**
   * Returns a PHPUnit_Framework_Constraint_TraversableContainsOnly matcher
   * object.
   *
   * @param  string                                               $classname
   * @return PHPUnit_Framework_Constraint_TraversableContainsOnly
   */
  public static function containsOnlyInstancesOf($classname) {
    return new PHPUnit_Framework_Constraint_TraversableContainsOnly($classname, false);
  }

  /**
   * Returns a PHPUnit_Framework_Constraint_ArrayHasKey matcher object.
   *
   * @param  mixed                                    $key
   * @return PHPUnit_Framework_Constraint_ArrayHasKey
   * @since  Method available since Release 3.0.0
   */
  public static function arrayHasKey($key) {
    return new PHPUnit_Framework_Constraint_ArrayHasKey($key);
  }

  /**
   * Returns a PHPUnit_Framework_Constraint_IsEqual matcher object.
   *
   * @param  mixed                                $value
   * @param  float                                $delta
   * @param  int                                  $maxDepth
   * @param  bool                                 $canonicalize
   * @param  bool                                 $ignoreCase
   * @return PHPUnit_Framework_Constraint_IsEqual
   * @since  Method available since Release 3.0.0
   */
  public static function equalTo($value, $delta = 0.0, $maxDepth = 10, $canonicalize = false, $ignoreCase = false) {
    return new PHPUnit_Framework_Constraint_IsEqual($value, $delta, $maxDepth, $canonicalize, $ignoreCase);
  }

  /**
   * Returns a PHPUnit_Framework_Constraint_IsEqual matcher object
   * that is wrapped in a PHPUnit_Framework_Constraint_Attribute matcher
   * object.
   *
   * @param  string                                 $attributeName
   * @param  mixed                                  $value
   * @param  float                                  $delta
   * @param  int                                    $maxDepth
   * @param  bool                                   $canonicalize
   * @param  bool                                   $ignoreCase
   * @return PHPUnit_Framework_Constraint_Attribute
   * @since  Method available since Release 3.1.0
   */
  public static function attributeEqualTo($attributeName, $value, $delta = 0.0, $maxDepth = 10, $canonicalize = false, $ignoreCase = false) {
    return self::attribute(self::equalTo($value, $delta, $maxDepth, $canonicalize, $ignoreCase), $attributeName);
  }

  /**
   * Returns a PHPUnit_Framework_Constraint_IsEmpty matcher object.
   *
   * @return PHPUnit_Framework_Constraint_IsEmpty
   * @since  Method available since Release 3.5.0
   */
  public static function isEmpty() {
    return new PHPUnit_Framework_Constraint_IsEmpty();
  }

  /**
   * Returns a PHPUnit_Framework_Constraint_FileExists matcher object.
   *
   * @return PHPUnit_Framework_Constraint_FileExists
   * @since  Method available since Release 3.0.0
   */
  public static function fileExists() {
    return new PHPUnit_Framework_Constraint_FileExists();
  }

  /**
   * Returns a PHPUnit_Framework_Constraint_GreaterThan matcher object.
   *
   * @param  mixed                                    $value
   * @return PHPUnit_Framework_Constraint_GreaterThan
   * @since  Method available since Release 3.0.0
   */
  public static function greaterThan($value) {
    return new PHPUnit_Framework_Constraint_GreaterThan($value);
  }

  /**
   * Returns a PHPUnit_Framework_Constraint_Or matcher object that wraps
   * a PHPUnit_Framework_Constraint_IsEqual and a
   * PHPUnit_Framework_Constraint_GreaterThan matcher object.
   *
   * @param  mixed                           $value
   * @return PHPUnit_Framework_Constraint_Or
   * @since  Method available since Release 3.1.0
   */
  public static function greaterThanOrEqual($value) {
    return self::logicalOr(new PHPUnit_Framework_Constraint_IsEqual($value), new PHPUnit_Framework_Constraint_GreaterThan($value));
  }

  /**
   * Returns a PHPUnit_Framework_Constraint_ClassHasAttribute matcher object.
   *
   * @param  string                                         $attributeName
   * @return PHPUnit_Framework_Constraint_ClassHasAttribute
   * @since  Method available since Release 3.1.0
   */
  public static function classHasAttribute($attributeName) {
    return new PHPUnit_Framework_Constraint_ClassHasAttribute($attributeName);
  }

  /**
   * Returns a PHPUnit_Framework_Constraint_ClassHasStaticAttribute matcher
   * object.
   *
   * @param  string                                               $attributeName
   * @return PHPUnit_Framework_Constraint_ClassHasStaticAttribute
   * @since  Method available since Release 3.1.0
   */
  public static function classHasStaticAttribute($attributeName) {
    return new PHPUnit_Framework_Constraint_ClassHasStaticAttribute($attributeName);
  }

  /**
   * Returns a PHPUnit_Framework_Constraint_ObjectHasAttribute matcher object.
   *
   * @param  string                                          $attributeName
   * @return PHPUnit_Framework_Constraint_ObjectHasAttribute
   * @since  Method available since Release 3.0.0
   */
  public static function objectHasAttribute($attributeName) {
    return new PHPUnit_Framework_Constraint_ObjectHasAttribute($attributeName);
  }

  /**
   * Returns a PHPUnit_Framework_Constraint_IsIdentical matcher object.
   *
   * @param  mixed                                    $value
   * @return PHPUnit_Framework_Constraint_IsIdentical
   * @since  Method available since Release 3.0.0
   */
  public static function identicalTo($value) {
    return new PHPUnit_Framework_Constraint_IsIdentical($value);
  }

  /**
   * Returns a PHPUnit_Framework_Constraint_IsInstanceOf matcher object.
   *
   * @param  string                                    $className
   * @return PHPUnit_Framework_Constraint_IsInstanceOf
   * @since  Method available since Release 3.0.0
   */
  public static function isInstanceOf($className) {
    return new PHPUnit_Framework_Constraint_IsInstanceOf($className);
  }

  /**
   * Returns a PHPUnit_Framework_Constraint_IsType matcher object.
   *
   * @param  string                              $type
   * @return PHPUnit_Framework_Constraint_IsType
   * @since  Method available since Release 3.0.0
   */
  public static function isType($type) {
    return new PHPUnit_Framework_Constraint_IsType($type);
  }

  /**
   * Returns a PHPUnit_Framework_Constraint_LessThan matcher object.
   *
   * @param  mixed                                 $value
   * @return PHPUnit_Framework_Constraint_LessThan
   * @since  Method available since Release 3.0.0
   */
  public static function lessThan($value) {
    return new PHPUnit_Framework_Constraint_LessThan($value);
  }

  /**
   * Returns a PHPUnit_Framework_Constraint_Or matcher object that wraps
   * a PHPUnit_Framework_Constraint_IsEqual and a
   * PHPUnit_Framework_Constraint_LessThan matcher object.
   *
   * @param  mixed                           $value
   * @return PHPUnit_Framework_Constraint_Or
   * @since  Method available since Release 3.1.0
   */
  public static function lessThanOrEqual($value) {
    return self::logicalOr(new PHPUnit_Framework_Constraint_IsEqual($value), new PHPUnit_Framework_Constraint_LessThan($value));
  }

  /**
   * Returns a PHPUnit_Framework_Constraint_PCREMatch matcher object.
   *
   * @param  string                                 $pattern
   * @return PHPUnit_Framework_Constraint_PCREMatch
   * @since  Method available since Release 3.0.0
   */
  public static function matchesRegularExpression($pattern) {
    return new PHPUnit_Framework_Constraint_PCREMatch($pattern);
  }

  /**
   * Returns a PHPUnit_Framework_Constraint_StringMatches matcher object.
   *
   * @param  string                                     $string
   * @return PHPUnit_Framework_Constraint_StringMatches
   * @since  Method available since Release 3.5.0
   */
  public static function matches($string) {
    return new PHPUnit_Framework_Constraint_StringMatches($string);
  }

  /**
   * Returns a PHPUnit_Framework_Constraint_StringStartsWith matcher object.
   *
   * @param  mixed                                         $prefix
   * @return PHPUnit_Framework_Constraint_StringStartsWith
   * @since  Method available since Release 3.4.0
   */
  public static function stringStartsWith($prefix) {
    return new PHPUnit_Framework_Constraint_StringStartsWith($prefix);
  }

  /**
   * Returns a PHPUnit_Framework_Constraint_StringContains matcher object.
   *
   * @param  string                                      $string
   * @param  bool                                        $case
   * @return PHPUnit_Framework_Constraint_StringContains
   * @since  Method available since Release 3.0.0
   */
  public static function stringContains($string, $case = true) {
    return new PHPUnit_Framework_Constraint_StringContains($string, $case);
  }

  /**
   * Returns a PHPUnit_Framework_Constraint_StringEndsWith matcher object.
   *
   * @param  mixed                                       $suffix
   * @return PHPUnit_Framework_Constraint_StringEndsWith
   * @since  Method available since Release 3.4.0
   */
  public static function stringEndsWith($suffix) {
    return new PHPUnit_Framework_Constraint_StringEndsWith($suffix);
  }

  /**
   * Returns a PHPUnit_Framework_Constraint_Count matcher object.
   *
   * @param  int                                $count
   * @return PHPUnit_Framework_Constraint_Count
   */
  public static function countOf($count) {
    return new PHPUnit_Framework_Constraint_Count($count);
  }

  /**
   * Fails a test with the given message.
   *
   * @param  string                                 $message
   * @throws PHPUnit_Framework_AssertionFailedError
   */
  public static function fail($message = '') {
    throw new PHPUnit_Framework_AssertionFailedError($message);
  }

  /**
   * Returns the value of an attribute of a class or an object.
   * This also works for attributes that are declared protected or private.
   *
   * @param  mixed                       $classOrObject
   * @param  string                      $attributeName
   * @return mixed
   * @throws PHPUnit_Framework_Exception
   */
  public static function readAttribute($classOrObject, $attributeName) {
    if (!is_string($attributeName)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(2, 'string');
    }
    if (!preg_match('/[a-zA-Z_\\x7f-\\xff][a-zA-Z0-9_\\x7f-\\xff]*/', $attributeName)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(2, 'valid attribute name');
    }
    if (is_string($classOrObject)) {
      if (!class_exists($classOrObject)) {
        throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'class name');
      }
      return self::getStaticAttribute($classOrObject, $attributeName);
    }
    elseif (is_object($classOrObject)) {
      return self::getObjectAttribute($classOrObject, $attributeName);
    }
    else {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'class name or object');
    }
  }

  /**
   * Returns the value of a static attribute.
   * This also works for attributes that are declared protected or private.
   *
   * @param  string                      $className
   * @param  string                      $attributeName
   * @return mixed
   * @throws PHPUnit_Framework_Exception
   * @since  Method available since Release 4.0.0
   */
  public static function getStaticAttribute($className, $attributeName) {
    if (!is_string($className)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'string');
    }
    if (!class_exists($className)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'class name');
    }
    if (!is_string($attributeName)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(2, 'string');
    }
    if (!preg_match('/[a-zA-Z_\\x7f-\\xff][a-zA-Z0-9_\\x7f-\\xff]*/', $attributeName)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(2, 'valid attribute name');
    }
    $class = new ReflectionClass($className);
    while ($class) {
      $attributes = $class
        ->getStaticProperties();
      if (array_key_exists($attributeName, $attributes)) {
        return $attributes[$attributeName];
      }
      $class = $class
        ->getParentClass();
    }
    throw new PHPUnit_Framework_Exception(sprintf('Attribute "%s" not found in class.', $attributeName));
  }

  /**
   * Returns the value of an object's attribute.
   * This also works for attributes that are declared protected or private.
   *
   * @param  object                      $object
   * @param  string                      $attributeName
   * @return mixed
   * @throws PHPUnit_Framework_Exception
   * @since  Method available since Release 4.0.0
   */
  public static function getObjectAttribute($object, $attributeName) {
    if (!is_object($object)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'object');
    }
    if (!is_string($attributeName)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(2, 'string');
    }
    if (!preg_match('/[a-zA-Z_\\x7f-\\xff][a-zA-Z0-9_\\x7f-\\xff]*/', $attributeName)) {
      throw PHPUnit_Util_InvalidArgumentHelper::factory(2, 'valid attribute name');
    }
    try {
      $attribute = new ReflectionProperty($object, $attributeName);
    } catch (ReflectionException $e) {
      $reflector = new ReflectionObject($object);
      while ($reflector = $reflector
        ->getParentClass()) {
        try {
          $attribute = $reflector
            ->getProperty($attributeName);
          break;
        } catch (ReflectionException $e) {
        }
      }
    }
    if (isset($attribute)) {
      if (!$attribute || $attribute
        ->isPublic()) {
        return $object->{$attributeName};
      }
      $attribute
        ->setAccessible(true);
      $value = $attribute
        ->getValue($object);
      $attribute
        ->setAccessible(false);
      return $value;
    }
    throw new PHPUnit_Framework_Exception(sprintf('Attribute "%s" not found in object.', $attributeName));
  }

  /**
   * Mark the test as incomplete.
   *
   * @param  string                                $message
   * @throws PHPUnit_Framework_IncompleteTestError
   * @since  Method available since Release 3.0.0
   */
  public static function markTestIncomplete($message = '') {
    throw new PHPUnit_Framework_IncompleteTestError($message);
  }

  /**
   * Mark the test as skipped.
   *
   * @param  string                             $message
   * @throws PHPUnit_Framework_SkippedTestError
   * @since  Method available since Release 3.0.0
   */
  public static function markTestSkipped($message = '') {
    throw new PHPUnit_Framework_SkippedTestError($message);
  }

  /**
   * Return the current assertion count.
   *
   * @return int
   * @since  Method available since Release 3.3.3
   */
  public static function getCount() {
    return self::$count;
  }

  /**
   * Reset the assertion counter.
   *
   * @since  Method available since Release 3.3.3
   */
  public static function resetCount() {
    self::$count = 0;
  }

}

Members

Namesort descending Modifiers Type Description Overrides
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.