XMLDB/simpletest/expectation.php
Chouchen 69b9eb42e2 More SQL command (drop table, drop database)
delete, select & insert upgraded 
More utility function (node to array, arrayToNode)
XMLDB special move command
PHP Unit Test
2010-10-11 14:03:38 +00:00

895 lines
27 KiB
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
*/
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]";
}
}
?>