expectation.php

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

<?php
/**
 *    base include file for SimpleTest
 *    @package    SimpleTest
 *    @subpackage    UnitTester
 *    @version    $Id: expectation.php 1723 2008-04-08 00:34:10Z lastcraft $
 */

/**#@+
 *    include other SimpleTest class files
 */
require_once(dirname(__FILE__) . '/dumper.php');
require_once(dirname(__FILE__) . '/compatibility.php');
/**#@-*/

/**
 *    Assertion that can display failure information.
 *    Also includes various helper methods.
 *    @package SimpleTest
 *    @subpackage UnitTester
 *    @abstract
 */
class SimpleExpectation {
    var $_dumper = false;
    var $_message;

    /**
     *    Creates a dumper for displaying values and sets
     *    the test message.
     *    @param string $message    Customised message on failure.
     */
    function SimpleExpectation($message = '%s') {
        $this->_message = $message;
    }

    /**
     *    Tests the expectation. True if correct.
     *    @param mixed $compare        Comparison value.
     *    @return boolean              True if correct.
     *    @access public
     *    @abstract
     */
    function test($compare) {
    }

    /**
     *    Returns a human readable test message.
     *    @param mixed $compare      Comparison value.
     *    @return string             Description of success
     *                               or failure.
     *    @access public
     *    @abstract
     */
    function testMessage($compare) {
    }

    /**
     *    Overlays the generated message onto the stored user
     *    message. An additional message can be interjected.
     *    @param mixed $compare        Comparison value.
     *    @param SimpleDumper $dumper  For formatting the results.
     *    @return string               Description of success
     *                                 or failure.
     *    @access public
     */
    function overlayMessage($compare, $dumper) {
        $this->_dumper = $dumper;
        return sprintf($this->_message, $this->testMessage($compare));
    }

    /**
     *    Accessor for the dumper.
     *    @return SimpleDumper    Current value dumper.
     *    @access protected
     */
    function &_getDumper() {
        if (! $this->_dumper) {
            $dumper = &new SimpleDumper();
            return $dumper;
        }
        return $this->_dumper;
    }

    /**
     *    Test to see if a value is an expectation object.
     *    A useful utility method.
     *    @param mixed $expectation    Hopefully an Epectation
     *                                 class.
     *    @return boolean              True if descended from
     *                                 this class.
     *    @access public
     *    @static
     */
    function isExpectation($expectation) {
        return is_object($expectation) &&
                SimpleTestCompatibility::isA($expectation, 'SimpleExpectation');
    }
}

/**
 *    A wildcard expectation always matches.
 *    @package SimpleTest
 *    @subpackage MockObjects
 */
class AnythingExpectation extends SimpleExpectation {

    /**
     *    Tests the expectation. Always true.
     *    @param mixed $compare  Ignored.
     *    @return boolean        True.
     *    @access public
     */
    function test($compare) {
        return true;
    }

    /**
     *    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 'Anything always matches [' . $dumper->describeValue($compare) . ']';
    }
}

/**
 *    An expectation that never matches.
 *    @package SimpleTest
 *    @subpackage MockObjects
 */
class FailedExpectation extends SimpleExpectation {

    /**
     *    Tests the expectation. Always false.
     *    @param mixed $compare  Ignored.
     *    @return boolean        True.
     *    @access public
     */
    function test($compare) {
        return false;
    }

    /**
     *    Returns a human readable test message.
     *    @param mixed $compare      Comparison value.
     *    @return string             Description of failure.
     *    @access public
     */
    function testMessage($compare) {
        $dumper = &$this->_getDumper();
        return 'Failed expectation never matches [' . $dumper->describeValue($compare) . ']';
    }
}

/**
 *    An expectation that passes on boolean true.
 *    @package SimpleTest
 *    @subpackage MockObjects
 */
class TrueExpectation extends SimpleExpectation {

    /**
     *    Tests the expectation.
     *    @param mixed $compare  Should be true.
     *    @return boolean        True on match.
     *    @access public
     */
    function test($compare) {
        return (boolean)$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 'Expected true, got [' . $dumper->describeValue($compare) . ']';
    }
}

/**
 *    An expectation that passes on boolean false.
 *    @package SimpleTest
 *    @subpackage MockObjects
 */
class FalseExpectation extends SimpleExpectation {

    /**
     *    Tests the expectation.
     *    @param mixed $compare  Should be false.
     *    @return boolean        True on match.
     *    @access public
     */
    function test($compare) {
        return ! (boolean)$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 'Expected false, got [' . $dumper->describeValue($compare) . ']';
    }
}

/**
 *    Test for equality.
 *    @package SimpleTest
 *    @subpackage UnitTester
 */
class EqualExpectation extends SimpleExpectation {
    var $_value;

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

    /**
     *    Tests the expectation. True if it matches the
     *    held value.
     *    @param mixed $compare        Comparison value.
     *    @return boolean              True if correct.
     *    @access public
     */
    function test($compare) {
        return (($this->_value == $compare) && ($compare == $this->_value));
    }

    /**
     *    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 "Equal expectation [" . $this->_dumper->describeValue($this->_value) . "]";
        } else {
            return "Equal expectation fails " .
                    $this->_dumper->describeDifference($this->_value, $compare);
        }
    }

    /**
     *    Accessor for comparison value.
     *    @return mixed       Held value to compare with.
     *    @access protected
     */
    function _getValue() {
        return $this->_value;
    }
}

/**
 *    Test for inequality.
 *    @package SimpleTest
 *    @subpackage UnitTester
 */
class NotEqualExpectation 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 NotEqualExpectation($value, $message = '%s') {
        $this->EqualExpectation($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 equal expectation passes " .
                    $dumper->describeDifference($this->_getValue(), $compare);
        } else {
            return "Not equal expectation fails [" .
                    $dumper->describeValue($this->_getValue()) .
                    "] matches";
        }
    }
}

/**
 *    Test for being within a range.
 *    @package SimpleTest
 *    @subpackage UnitTester
 */
class WithinMarginExpectation extends SimpleExpectation {
    var $_upper;
    var $_lower;

    /**
     *    Sets the value to compare against and the fuzziness of
     *    the match. Used for comparing floating point values.
     *    @param mixed $value        Test value to match.
     *    @param mixed $margin       Fuzziness of match.
     *    @param string $message     Customised message on failure.
     *    @access public
     */
    function WithinMarginExpectation($value, $margin, $message = '%s') {
        $this->SimpleExpectation($message);
        $this->_upper = $value + $margin;
        $this->_lower = $value - $margin;
    }

    /**
     *    Tests the expectation. True if it matches the
     *    held value.
     *    @param mixed $compare        Comparison value.
     *    @return boolean              True if correct.
     *    @access public
     */
    function test($compare) {
        return (($compare <= $this->_upper) && ($compare >= $this->_lower));
    }

    /**
     *    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->_withinMessage($compare);
        } else {
            return $this->_outsideMessage($compare);
        }
    }

    /**
     *    Creates a the message for being within the range.
     *    @param mixed $compare        Value being tested.
     *    @access private
     */
    function _withinMessage($compare) {
        return "Within expectation [" . $this->_dumper->describeValue($this->_lower) . "] and [" .
                $this->_dumper->describeValue($this->_upper) . "]";
    }

    /**
     *    Creates a the message for being within the range.
     *    @param mixed $compare        Value being tested.
     *    @access private
     */
    function _outsideMessage($compare) {
        if ($compare > $this->_upper) {
            return "Outside expectation " .
                    $this->_dumper->describeDifference($compare, $this->_upper);
        } else {
            return "Outside expectation " .
                    $this->_dumper->describeDifference($compare, $this->_lower);
        }
    }
}

/**
 *    Test for being outside of a range.
 *    @package SimpleTest
 *    @subpackage UnitTester
 */
class OutsideMarginExpectation extends WithinMarginExpectation {

    /**
     *    Sets the value to compare against and the fuzziness of
     *    the match. Used for comparing floating point values.
     *    @param mixed $value        Test value to not match.
     *    @param mixed $margin       Fuzziness of match.
     *    @param string $message     Customised message on failure.
     *    @access public
     */
    function OutsideMarginExpectation($value, $margin, $message = '%s') {
        $this->WithinMarginExpectation($value, $margin, $message);
    }

    /**
     *    Tests the expectation. True if it matches 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) {
        if (! $this->test($compare)) {
            return $this->_withinMessage($compare);
        } else {
            return $this->_outsideMessage($compare);
        }
    }
}

/**
 *    Test for reference.
 *    @package SimpleTest
 *    @subpackage UnitTester
 */