expectation.php.svn-base

PHP 知识管理系统（基于树结构的知识管理系统）, 英文原版的PHP源码。

class ReferenceExpectation extends SimpleExpectation {
    var $_value;

    /**
     *    Sets the reference value to compare against.
     *    @param mixed $value       Test reference to match.
     *    @param string $message    Customised message on failure.
     *    @access public
     */
    function ReferenceExpectation(&$value, $message = '%s') {
        $this->SimpleExpectation($message);
        $this->_value =& $value;
    }

    /**
     *    Tests the expectation. True if it exactly
     *    references the held value.
     *    @param mixed $compare        Comparison reference.
     *    @return boolean              True if correct.
     *    @access public
     */
    function test(&$compare) {
        return SimpleTestCompatibility::isReference($this->_value, $compare);
    }

    /**
     *    Returns a human readable test message.
     *    @param mixed $compare      Comparison value.
     *    @return string             Description of success
     *                               or failure.
     *    @access public
     */
    function testMessage($compare) {
        if ($this->test($compare)) {
            return "Reference expectation [" . $this->_dumper->describeValue($this->_value) . "]";
        } else {
            return "Reference expectation fails " .
                    $this->_dumper->describeDifference($this->_value, $compare);
        }
    }

    function _getValue() {
        return $this->_value;
    }
}

/**
 *    Test for identity.
 *    @package SimpleTest
 *    @subpackage UnitTester
 */
class IdenticalExpectation extends EqualExpectation {

    /**
     *    Sets the value to compare against.
     *    @param mixed $value       Test value to match.
     *    @param string $message    Customised message on failure.
     *    @access public
     */
    function IdenticalExpectation($value, $message = '%s') {
        $this->EqualExpectation($value, $message);
    }

    /**
     *    Tests the expectation. True if it exactly
     *    matches the held value.
     *    @param mixed $compare        Comparison value.
     *    @return boolean              True if correct.
     *    @access public
     */
    function test($compare) {
        return SimpleTestCompatibility::isIdentical($this->_getValue(), $compare);
    }

    /**
     *    Returns a human readable test message.
     *    @param mixed $compare      Comparison value.
     *    @return string             Description of success
     *                               or failure.
     *    @access public
     */
    function testMessage($compare) {
        $dumper = &$this->_getDumper();
        if ($this->test($compare)) {
            return "Identical expectation [" . $dumper->describeValue($this->_getValue()) . "]";
        } else {
            return "Identical expectation [" . $dumper->describeValue($this->_getValue()) .
                    "] fails with [" .
                    $dumper->describeValue($compare) . "] " .
                    $dumper->describeDifference($this->_getValue(), $compare, TYPE_MATTERS);
        }
    }
}

/**
 *    Test for non-identity.
 *    @package SimpleTest
 *    @subpackage UnitTester
 */
class NotIdenticalExpectation extends IdenticalExpectation {

    /**
     *    Sets the value to compare against.
     *    @param mixed $value        Test value to match.
     *    @param string $message     Customised message on failure.
     *    @access public
     */
    function NotIdenticalExpectation($value, $message = '%s') {
        $this->IdenticalExpectation($value, $message);
    }

    /**
     *    Tests the expectation. True if it differs from the
     *    held value.
     *    @param mixed $compare        Comparison value.
     *    @return boolean              True if correct.
     *    @access public
     */
    function test($compare) {
        return ! parent::test($compare);
    }

    /**
     *    Returns a human readable test message.
     *    @param mixed $compare      Comparison value.
     *    @return string             Description of success
     *                               or failure.
     *    @access public
     */
    function testMessage($compare) {
        $dumper = &$this->_getDumper();
        if ($this->test($compare)) {
            return "Not identical expectation passes " .
                    $dumper->describeDifference($this->_getValue(), $compare, TYPE_MATTERS);
        } else {
            return "Not identical expectation [" . $dumper->describeValue($this->_getValue()) . "] matches";
        }
    }
}

/**
 *    Test for a pattern using Perl regex rules.
 *    @package SimpleTest
 *    @subpackage UnitTester
 */
class PatternExpectation extends SimpleExpectation {
    var $_pattern;

    /**
     *    Sets the value to compare against.
     *    @param string $pattern    Pattern to search for.
     *    @param string $message    Customised message on failure.
     *    @access public
     */
    function PatternExpectation($pattern, $message = '%s') {
        $this->SimpleExpectation($message);
        $this->_pattern = $pattern;
    }

    /**
     *    Accessor for the pattern.
     *    @return string       Perl regex as string.
     *    @access protected
     */
    function _getPattern() {
        return $this->_pattern;
    }

    /**
     *    Tests the expectation. True if the Perl regex
     *    matches the comparison value.
     *    @param string $compare        Comparison value.
     *    @return boolean               True if correct.
     *    @access public
     */
    function test($compare) {
        return (boolean)preg_match($this->_getPattern(), $compare);
    }

    /**
     *    Returns a human readable test message.
     *    @param mixed $compare      Comparison value.
     *    @return string             Description of success
     *                               or failure.
     *    @access public
     */
    function testMessage($compare) {
        if ($this->test($compare)) {
            return $this->_describePatternMatch($this->_getPattern(), $compare);
        } else {
            $dumper = &$this->_getDumper();
            return "Pattern [" . $this->_getPattern() .
                    "] not detected in [" .
                    $dumper->describeValue($compare) . "]";
        }
    }

    /**
     *    Describes a pattern match including the string
     *    found and it's position.
     *    @param string $pattern        Regex to match against.
     *    @param string $subject        Subject to search.
     *    @access protected
     */
    function _describePatternMatch($pattern, $subject) {
        preg_match($pattern, $subject, $matches);
        $position = strpos($subject, $matches[0]);
        $dumper = $this->_getDumper();
        return "Pattern [$pattern] detected at character [$position] in [" .
                $dumper->describeValue($subject) . "] as [" .
                $matches[0] . "] in region [" .
                $dumper->clipString($subject, 100, $position) . "]";
    }
}

/**
 *    @package SimpleTest
 *    @subpackage UnitTester
 *    @deprecated
 */
class WantedPatternExpectation extends PatternExpectation {
}

/**
 *    Fail if a pattern is detected within the
 *    comparison.
 *    @package SimpleTest
 *    @subpackage UnitTester
 */
class NoPatternExpectation extends PatternExpectation {

    /**
     *    Sets the reject pattern
     *    @param string $pattern    Pattern to search for.
     *    @param string $message    Customised message on failure.
     *    @access public
     */
    function NoPatternExpectation($pattern, $message = '%s') {
        $this->PatternExpectation($pattern, $message);
    }

    /**
     *    Tests the expectation. False if the Perl regex
     *    matches the comparison value.
     *    @param string $compare        Comparison value.
     *    @return boolean               True if correct.
     *    @access public
     */
    function test($compare) {
        return ! parent::test($compare);
    }

    /**
     *    Returns a human readable test message.
     *    @param string $compare      Comparison value.
     *    @return string              Description of success
     *                                or failure.
     *    @access public
     */
    function testMessage($compare) {
        if ($this->test($compare)) {
            $dumper = &$this->_getDumper();
            return "Pattern [" . $this->_getPattern() .
                    "] not detected in [" .
                    $dumper->describeValue($compare) . "]";
        } else {
            return $this->_describePatternMatch($this->_getPattern(), $compare);
        }
    }
}

/**
 *    @package SimpleTest
 *    @subpackage UnitTester
 *      @deprecated
 */
class UnwantedPatternExpectation extends NoPatternExpectation {
}

/**
 *    Tests either type or class name if it's an object.
 *      @package SimpleTest
 *      @subpackage UnitTester
 */
class IsAExpectation extends SimpleExpectation {
    var $_type;

    /**
     *    Sets the type to compare with.
     *    @param string $type       Type or class name.
     *    @param string $message    Customised message on failure.
     *    @access public
     */
    function IsAExpectation($type, $message = '%s') {
        $this->SimpleExpectation($message);
        $this->_type = $type;
    }

    /**
     *    Accessor for type to check against.
     *    @return string    Type or class name.
     *    @access protected
     */
    function _getType() {
        return $this->_type;
    }

    /**
     *    Tests the expectation. True if the type or
     *    class matches the string value.
     *    @param string $compare        Comparison value.
     *    @return boolean               True if correct.
     *    @access public
     */
    function test($compare) {
        if (is_object($compare)) {
            return SimpleTestCompatibility::isA($compare, $this->_type);
        } else {
            return (strtolower(gettype($compare)) == $this->_canonicalType($this->_type));
        }
    }

    /**
     *    Coerces type name into a gettype() match.
     *    @param string $type        User type.
     *    @return string             Simpler type.
     *    @access private
     */
    function _canonicalType($type) {
        $type = strtolower($type);
        $map = array(
                'bool' => 'boolean',
                'float' => 'double',
                'real' => 'double',
                'int' => 'integer');
        if (isset($map[$type])) {
            $type = $map[$type];
        }
        return $type;
    }

    /**
     *    Returns a human readable test message.
     *    @param mixed $compare      Comparison value.
     *    @return string             Description of success
     *                               or failure.
     *    @access public
     */
    function testMessage($compare) {
        $dumper = &$this->_getDumper();
        return "Value [" . $dumper->describeValue($compare) .
                "] should be type [" . $this->_type . "]";
    }
}

/**
 *    Tests either type or class name if it's an object.
 *    Will succeed if the type does not match.
 *      @package SimpleTest
 *      @subpackage UnitTester
 */
class NotAExpectation extends IsAExpectation {
    var $_type;

    /**
     *    Sets the type to compare with.
     *    @param string $type       Type or class name.
     *    @param string $message    Customised message on failure.
     *    @access public
     */
    function NotAExpectation($type, $message = '%s') {
        $this->IsAExpectation($type, $message);
    }

    /**
     *    Tests the expectation. False if the type or
     *    class matches the string value.
     *    @param string $compare        Comparison value.
     *    @return boolean               True if different.
     *    @access public
     */
    function test($compare) {
        return ! parent::test($compare);
    }

    /**
     *    Returns a human readable test message.
     *    @param mixed $compare      Comparison value.
     *    @return string             Description of success
     *                               or failure.
     *    @access public
     */
    function testMessage($compare) {
        $dumper = &$this->_getDumper();
        return "Value [" . $dumper->describeValue($compare) .
                "] should not be type [" . $this->_getType() . "]";
    }
}

/**
 *    Tests for existance of a method in an object
 *      @package SimpleTest
 *      @subpackage UnitTester
 */
class MethodExistsExpectation extends SimpleExpectation {
    var $_method;

    /**
     *    Sets the value to compare against.
     *    @param string $method     Method to check.
     *    @param string $message    Customised message on failure.
     *    @access public
     *    @return void
     */
    function MethodExistsExpectation($method, $message = '%s') {
        $this->SimpleExpectation($message);
        $this->_method = &$method;
    }

    /**
     *    Tests the expectation. True if the method exists in the test object.
     *    @param string $compare        Comparison method name.
     *    @return boolean               True if correct.
     *    @access public
     */
    function test($compare) {
        return (boolean)(is_object($compare) && method_exists($compare, $this->_method));
    }

    /**
     *    Returns a human readable test message.
     *    @param mixed $compare      Comparison value.
     *    @return string             Description of success
     *                               or failure.
     *    @access public
     */
    function testMessage($compare) {
        $dumper = &$this->_getDumper();
        if (! is_object($compare)) {
            return 'No method on non-object [' . $dumper->describeValue($compare) . ']';
        }
        $method = $this->_method;
        return "Object [" . $dumper->describeValue($compare) .
                "] should contain method [$method]";
    }
}
?>