Source for file expectation.php

Documentation is available at expectation.php

  1. <?php
  2. /**
  3.  *    base include file for SimpleTest
  4.  *    @package    SimpleTest
  5.  *    @subpackage    UnitTester
  6.  *    @version    $Id: expectation.php 1723 2008-04-08 00:34:10Z lastcraft $
  7.  */
  8.  
  9. /**#@+
  10.  *    include other SimpleTest class files
  11.  */
  12. require_once(dirname(__FILE__) . '/dumper.php');
  13. require_once(dirname(__FILE__) . '/compatibility.php');
  14. /**#@-*/
  15.  
  16.  *    Assertion that can display failure information.
  17.  *    Also includes various helper methods.
  18.  *    @package SimpleTest
  19.  *    @subpackage UnitTester
  20.  *    @abstract
  21.  */
  22. class SimpleExpectation {
  23.     var $_dumper = false;
  24.     var $_message;
  25.  
  26.     /**
  27.      *    Creates a dumper for displaying values and sets
  28.      *    the test message.
  29.      *    @param string $message    Customised message on failure.
  30.      */
  31.     function SimpleExpectation($message = '%s') {
  32.         $this->_message = $message;
  33.     }
  34.  
  35.     /**
  36.      *    Tests the expectation. True if correct.
  37.      *    @param mixed $compare        Comparison value.
  38.      *    @return boolean              True if correct.
  39.      *    @access public
  40.      *    @abstract
  41.      */
  42.     function test($compare) {
  43.     }
  44.  
  45.     /**
  46.      *    Returns a human readable test message.
  47.      *    @param mixed $compare      Comparison value.
  48.      *    @return string             Description of success
  49.      *                                or failure.
  50.      *    @access public
  51.      *    @abstract
  52.      */
  53.     function testMessage($compare) {
  54.     }
  55.  
  56.     /**
  57.      *    Overlays the generated message onto the stored user
  58.      *    message. An additional message can be interjected.
  59.      *    @param mixed $compare        Comparison value.
  60.      *    @param SimpleDumper $dumper  For formatting the results.
  61.      *    @return string               Description of success
  62.      *                                  or failure.
  63.      *    @access public
  64.      */
  65.     function overlayMessage($compare, $dumper) {
  66.         $this->_dumper = $dumper;
  67.         return sprintf($this->_message, $this->testMessage($compare));
  68.     }
  69.  
  70.     /**
  71.      *    Accessor for the dumper.
  72.      *    @return SimpleDumper    Current value dumper.
  73.      *    @access protected
  74.      */
  75.     function &_getDumper() {
  76.         if (! $this->_dumper) {
  77.             $dumper = &new SimpleDumper();
  78.             return $dumper;
  79.         }
  80.         return $this->_dumper;
  81.     }
  82.  
  83.     /**
  84.      *    Test to see if a value is an expectation object.
  85.      *    A useful utility method.
  86.      *    @param mixed $expectation    Hopefully an Epectation
  87.      *                                  class.
  88.      *    @return boolean              True if descended from
  89.      *                                  this class.
  90.      *    @access public
  91.      *    @static
  92.      */
  93.     function isExpectation($expectation) {
  94.         return is_object($expectation) &&
  95.                 SimpleTestCompatibility::isA($expectation, 'SimpleExpectation');
  96.     }
  97. }
  98.  
  99. /**
  100.  *    A wildcard expectation always matches.
  101.  *    @package SimpleTest
  102.  *    @subpackage MockObjects
  103.  */
  104. class AnythingExpectation extends SimpleExpectation {
  105.  
  106.     /**
  107.      *    Tests the expectation. Always true.
  108.      *    @param mixed $compare  Ignored.
  109.      *    @return boolean        True.
  110.      *    @access public
  111.      */
  112.     function test($compare) {
  113.         return true;
  114.     }
  115.  
  116.     /**
  117.      *    Returns a human readable test message.
  118.      *    @param mixed $compare      Comparison value.
  119.      *    @return string             Description of success
  120.      *                                or failure.
  121.      *    @access public
  122.      */
  123.     function testMessage($compare) {
  124.         $dumper = &$this->_getDumper();
  125.         return 'Anything always matches [' . $dumper->describeValue($compare) . ']';
  126.     }
  127. }
  128.  
  129. /**
  130.  *    An expectation that never matches.
  131.  *    @package SimpleTest
  132.  *    @subpackage MockObjects
  133.  */
  134. class FailedExpectation extends SimpleExpectation {
  135.  
  136.     /**
  137.      *    Tests the expectation. Always false.
  138.      *    @param mixed $compare  Ignored.
  139.      *    @return boolean        True.
  140.      *    @access public
  141.      */
  142.     function test($compare) {
  143.         return false;
  144.     }
  145.  
  146.     /**
  147.      *    Returns a human readable test message.
  148.      *    @param mixed $compare      Comparison value.
  149.      *    @return string             Description of failure.
  150.      *    @access public
  151.      */
  152.     function testMessage($compare) {
  153.         $dumper = &$this->_getDumper();
  154.         return 'Failed expectation never matches [' . $dumper->describeValue($compare) . ']';
  155.     }
  156. }
  157.  
  158. /**
  159.  *    An expectation that passes on boolean true.
  160.  *    @package SimpleTest
  161.  *    @subpackage MockObjects
  162.  */
  163. class TrueExpectation extends SimpleExpectation {
  164.  
  165.     /**
  166.      *    Tests the expectation.
  167.      *    @param mixed $compare  Should be true.
  168.      *    @return boolean        True on match.
  169.      *    @access public
  170.      */
  171.     function test($compare) {
  172.         return (boolean)$compare;
  173.     }
  174.  
  175.     /**
  176.      *    Returns a human readable test message.
  177.      *    @param mixed $compare      Comparison value.
  178.      *    @return string             Description of success
  179.      *                                or failure.
  180.      *    @access public
  181.      */
  182.     function testMessage($compare) {
  183.         $dumper = &$this->_getDumper();
  184.         return 'Expected true, got [' . $dumper->describeValue($compare) . ']';
  185.     }
  186. }
  187.  
  188. /**
  189.  *    An expectation that passes on boolean false.
  190.  *    @package SimpleTest
  191.  *    @subpackage MockObjects
  192.  */
  193. class FalseExpectation extends SimpleExpectation {
  194.  
  195.     /**
  196.      *    Tests the expectation.
  197.      *    @param mixed $compare  Should be false.
  198.      *    @return boolean        True on match.
  199.      *    @access public
  200.      */
  201.     function test($compare) {
  202.         return ! (boolean)$compare;
  203.     }
  204.  
  205.     /**
  206.      *    Returns a human readable test message.
  207.      *    @param mixed $compare      Comparison value.
  208.      *    @return string             Description of success
  209.      *                                or failure.
  210.      *    @access public
  211.      */
  212.     function testMessage($compare) {
  213.         $dumper = &$this->_getDumper();
  214.         return 'Expected false, got [' . $dumper->describeValue($compare) . ']';
  215.     }
  216. }
  217.  
  218. /**
  219.  *    Test for equality.
  220.  *    @package SimpleTest
  221.  *    @subpackage UnitTester
  222.  */
  223. class EqualExpectation extends SimpleExpectation {
  224.     var $_value;
  225.  
  226.     /**
  227.      *    Sets the value to compare against.
  228.      *    @param mixed $value        Test value to match.
  229.      *    @param string $message     Customised message on failure.
  230.      *    @access public
  231.      */
  232.     function EqualExpectation($value, $message = '%s') {
  233.         $this->SimpleExpectation($message);
  234.         $this->_value = $value;
  235.     }
  236.  
  237.     /**
  238.      *    Tests the expectation. True if it matches the
  239.      *    held value.
  240.      *    @param mixed $compare        Comparison value.
  241.      *    @return boolean              True if correct.
  242.      *    @access public
  243.      */
  244.     function test($compare) {
  245.         return (($this->_value == $compare) && ($compare == $this->_value));
  246.     }
  247.  
  248.     /**
  249.      *    Returns a human readable test message.
  250.      *    @param mixed $compare      Comparison value.
  251.      *    @return string             Description of success
  252.      *                                or failure.
  253.      *    @access public
  254.      */
  255.     function testMessage($compare) {
  256.         if ($this->test($compare)) {
  257.             return "Equal expectation [" . $this->_dumper->describeValue($this->_value) . "]";
  258.         } else {
  259.             return "Equal expectation fails " .
  260.                     $this->_dumper->describeDifference($this->_value, $compare);
  261.         }
  262.     }
  263.  
  264.     /**
  265.      *    Accessor for comparison value.
  266.      *    @return mixed       Held value to compare with.
  267.      *    @access protected
  268.      */
  269.     function _getValue() {
  270.         return $this->_value;
  271.     }
  272. }
  273.  
  274. /**
  275.  *    Test for inequality.
  276.  *    @package SimpleTest
  277.  *    @subpackage UnitTester
  278.  */
  279. class NotEqualExpectation extends EqualExpectation {
  280.  
  281.     /**
  282.      *    Sets the value to compare against.
  283.      *    @param mixed $value       Test value to match.
  284.      *    @param string $message    Customised message on failure.
  285.      *    @access public
  286.      */
  287.     function NotEqualExpectation($value, $message = '%s') {
  288.         $this->EqualExpectation($value, $message);
  289.     }
  290.  
  291.     /**
  292.      *    Tests the expectation. True if it differs from the
  293.      *    held value.
  294.      *    @param mixed $compare        Comparison value.
  295.      *    @return boolean              True if correct.
  296.      *    @access public
  297.      */
  298.     function test($compare) {
  299.         return ! parent::test($compare);
  300.     }
  301.  
  302.     /**
  303.      *    Returns a human readable test message.
  304.      *    @param mixed $compare      Comparison value.
  305.      *    @return string             Description of success
  306.      *                                or failure.
  307.      *    @access public
  308.      */
  309.     function testMessage($compare) {
  310.         $dumper = &$this->_getDumper();
  311.         if ($this->test($compare)) {
  312.             return "Not equal expectation passes " .
  313.                     $dumper->describeDifference($this->_getValue(), $compare);
  314.         } else {
  315.             return "Not equal expectation fails [" .
  316.                     $dumper->describeValue($this->_getValue()) .
  317.                     "] matches";
  318.         }
  319.     }
  320. }
  321.  
  322. /**
  323.  *    Test for being within a range.
  324.  *    @package SimpleTest
  325.  *    @subpackage UnitTester
  326.  */
  327. class WithinMarginExpectation extends SimpleExpectation {
  328.     var $_upper;
  329.     var $_lower;
  330.  
  331.     /**
  332.      *    Sets the value to compare against and the fuzziness of
  333.      *    the match. Used for comparing floating point values.
  334.      *    @param mixed $value        Test value to match.
  335.      *    @param mixed $margin       Fuzziness of match.
  336.      *    @param string $message     Customised message on failure.
  337.      *    @access public
  338.      */
  339.     function WithinMarginExpectation($value, $margin, $message = '%s') {
  340.         $this->SimpleExpectation($message);
  341.         $this->_upper = $value + $margin;
  342.         $this->_lower = $value - $margin;
  343.     }
  344.  
  345.     /**
  346.      *    Tests the expectation. True if it matches the
  347.      *    held value.
  348.      *    @param mixed $compare        Comparison value.
  349.      *    @return boolean              True if correct.
  350.      *    @access public
  351.      */
  352.     function test($compare) {
  353.         return (($compare <= $this->_upper) && ($compare >= $this->_lower));
  354.     }
  355.  
  356.     /**
  357.      *    Returns a human readable test message.
  358.      *    @param mixed $compare      Comparison value.
  359.      *    @return string             Description of success
  360.      *                                or failure.
  361.      *    @access public
  362.      */
  363.     function testMessage($compare) {
  364.         if ($this->test($compare)) {
  365.             return $this->_withinMessage($compare);
  366.         } else {
  367.             return $this->_outsideMessage($compare);
  368.         }
  369.     }
  370.  
  371.     /**
  372.      *    Creates a the message for being within the range.
  373.      *    @param mixed $compare        Value being tested.
  374.      *    @access private
  375.      */
  376.     function _withinMessage($compare) {
  377.         return "Within expectation [" . $this->_dumper->describeValue($this->_lower) . "] and [" .
  378.                 $this->_dumper->describeValue($this->_upper) . "]";
  379.     }
  380.  
  381.     /**
  382.      *    Creates a the message for being within the range.
  383.      *    @param mixed $compare        Value being tested.
  384.      *    @access private
  385.      */
  386.     function _outsideMessage($compare) {
  387.         if ($compare > $this->_upper) {
  388.             return "Outside expectation " .
  389.                     $this->_dumper->describeDifference($compare, $this->_upper);
  390.         } else {
  391.             return "Outside expectation " .
  392.                     $this->_dumper->describeDifference($compare, $this->_lower);
  393.         }
  394.     }
  395. }
  396.  
  397. /**
  398.  *    Test for being outside of a range.
  399.  *    @package SimpleTest
  400.  *    @subpackage UnitTester
  401.  */
  402. class OutsideMarginExpectation extends WithinMarginExpectation {
  403.  
  404.     /**
  405.      *    Sets the value to compare against and the fuzziness of
  406.      *    the match. Used for comparing floating point values.
  407.      *    @param mixed $value        Test value to not match.
  408.      *    @param mixed $margin       Fuzziness of match.
  409.      *    @param string $message     Customised message on failure.
  410.      *    @access public
  411.      */
  412.     function OutsideMarginExpectation($value, $margin, $message = '%s') {
  413.         $this->WithinMarginExpectation($value, $margin, $message);
  414.     }
  415.  
  416.     /**
  417.      *    Tests the expectation. True if it matches the
  418.      *    held value.
  419.      *    @param mixed $compare        Comparison value.
  420.      *    @return boolean              True if correct.
  421.      *    @access public
  422.      */
  423.     function test($compare) {
  424.         return ! parent::test($compare);
  425.     }
  426.  
  427.     /**
  428.      *    Returns a human readable test message.
  429.      *    @param mixed $compare      Comparison value.
  430.      *    @return string             Description of success
  431.      *                                or failure.
  432.      *    @access public
  433.      */
  434.     function testMessage($compare) {
  435.         if (! $this->test($compare)) {
  436.             return $this->_withinMessage($compare);
  437.         } else {
  438.             return $this->_outsideMessage($compare);
  439.         }
  440.     }
  441. }
  442.  
  443. /**
  444.  *    Test for reference.
  445.  *    @package SimpleTest
  446.  *    @subpackage UnitTester
  447.  */
  448. class ReferenceExpectation extends SimpleExpectation {
  449.     var $_value;
  450.  
  451.     /**
  452.      *    Sets the reference value to compare against.
  453.      *    @param mixed $value       Test reference to match.
  454.      *    @param string $message    Customised message on failure.
  455.      *    @access public
  456.      */
  457.     function ReferenceExpectation(&$value, $message = '%s') {
  458.         $this->SimpleExpectation($message);
  459.         $this->_value =& $value;
  460.     }
  461.  
  462.     /**
  463.      *    Tests the expectation. True if it exactly
  464.      *    references the held value.
  465.      *    @param mixed $compare        Comparison reference.
  466.      *    @return boolean              True if correct.
  467.      *    @access public
  468.      */
  469.     function test(&$compare) {
  470.         return SimpleTestCompatibility::isReference($this->_value, $compare);
  471.     }
  472.  
  473.     /**
  474.      *    Returns a human readable test message.
  475.      *    @param mixed $compare      Comparison value.
  476.      *    @return string             Description of success
  477.      *                                or failure.
  478.      *    @access public
  479.      */
  480.     function testMessage($compare) {
  481.         if ($this->test($compare)) {
  482.             return "Reference expectation [" . $this->_dumper->describeValue($this->_value) . "]";
  483.         } else {
  484.             return "Reference expectation fails " .
  485.                     $this->_dumper->describeDifference($this->_value, $compare);
  486.         }
  487.     }
  488.  
  489.     function _getValue() {
  490.         return $this->_value;
  491.     }
  492. }
  493.  
  494. /**
  495.  *    Test for identity.
  496.  *    @package SimpleTest
  497.  *    @subpackage UnitTester
  498.  */
  499. class IdenticalExpectation extends EqualExpectation {
  500.  
  501.     /**
  502.      *    Sets the value to compare against.
  503.      *    @param mixed $value       Test value to match.
  504.      *    @param string $message    Customised message on failure.
  505.      *    @access public
  506.      */
  507.     function IdenticalExpectation($value, $message = '%s') {
  508.         $this->EqualExpectation($value, $message);
  509.     }
  510.  
  511.     /**
  512.      *    Tests the expectation. True if it exactly
  513.      *    matches the held value.
  514.      *    @param mixed $compare        Comparison value.
  515.      *    @return boolean              True if correct.
  516.      *    @access public
  517.      */
  518.     function test($compare) {
  519.         return SimpleTestCompatibility::isIdentical($this->_getValue(), $compare);
  520.     }
  521.  
  522.     /**
  523.      *    Returns a human readable test message.
  524.      *    @param mixed $compare      Comparison value.
  525.      *    @return string             Description of success
  526.      *                                or failure.
  527.      *    @access public
  528.      */
  529.     function testMessage($compare) {
  530.         $dumper = &$this->_getDumper();
  531.         if ($this->test($compare)) {
  532.             return "Identical expectation [" . $dumper->describeValue($this->_getValue()) . "]";
  533.         } else {
  534.             return "Identical expectation [" . $dumper->describeValue($this->_getValue()) .
  535.                     "] fails with [" .
  536.                     $dumper->describeValue($compare) . "] " .
  537.                     $dumper->describeDifference($this->_getValue(), $compare, TYPE_MATTERS);
  538.         }
  539.     }
  540. }
  541.  
  542. /**
  543.  *    Test for non-identity.
  544.  *    @package SimpleTest
  545.  *    @subpackage UnitTester
  546.  */
  547. class NotIdenticalExpectation extends IdenticalExpectation {
  548.  
  549.     /**
  550.      *    Sets the value to compare against.
  551.      *    @param mixed $value        Test value to match.
  552.      *    @param string $message     Customised message on failure.
  553.      *    @access public
  554.      */
  555.     function NotIdenticalExpectation($value, $message = '%s') {
  556.         $this->IdenticalExpectation($value, $message);
  557.     }
  558.  
  559.     /**
  560.      *    Tests the expectation. True if it differs from the
  561.      *    held value.
  562.      *    @param mixed $compare        Comparison value.
  563.      *    @return boolean              True if correct.
  564.      *    @access public
  565.      */
  566.     function test($compare) {
  567.         return ! parent::test($compare);
  568.     }
  569.  
  570.     /**
  571.      *    Returns a human readable test message.
  572.      *    @param mixed $compare      Comparison value.
  573.      *    @return string             Description of success
  574.      *                                or failure.
  575.      *    @access public
  576.      */
  577.     function testMessage($compare) {
  578.         $dumper = &$this->_getDumper();
  579.         if ($this->test($compare)) {
  580.             return "Not identical expectation passes " .
  581.                     $dumper->describeDifference($this->_getValue(), $compare, TYPE_MATTERS);
  582.         } else {
  583.             return "Not identical expectation [" . $dumper->describeValue($this->_getValue()) . "] matches";
  584.         }
  585.     }
  586. }
  587.  
  588. /**
  589.  *    Test for a pattern using Perl regex rules.
  590.  *    @package SimpleTest
  591.  *    @subpackage UnitTester
  592.  */
  593. class PatternExpectation extends SimpleExpectation {
  594.     var $_pattern;
  595.  
  596.     /**
  597.      *    Sets the value to compare against.
  598.      *    @param string $pattern    Pattern to search for.
  599.      *    @param string $message    Customised message on failure.
  600.      *    @access public
  601.      */
  602.     function PatternExpectation($pattern, $message = '%s') {
  603.         $this->SimpleExpectation($message);
  604.         $this->_pattern = $pattern;
  605.     }
  606.  
  607.     /**
  608.      *    Accessor for the pattern.
  609.      *    @return string       Perl regex as string.
  610.      *    @access protected
  611.      */
  612.     function _getPattern() {
  613.         return $this->_pattern;
  614.     }
  615.  
  616.     /**
  617.      *    Tests the expectation. True if the Perl regex
  618.      *    matches the comparison value.
  619.      *    @param string $compare        Comparison value.
  620.      *    @return boolean               True if correct.
  621.      *    @access public
  622.      */
  623.     function test($compare) {
  624.         return (boolean)preg_match($this->_getPattern(), $compare);
  625.     }
  626.  
  627.     /**
  628.      *    Returns a human readable test message.
  629.      *    @param mixed $compare      Comparison value.
  630.      *    @return string             Description of success
  631.      *                                or failure.
  632.      *    @access public
  633.      */
  634.     function testMessage($compare) {
  635.         if ($this->test($compare)) {
  636.             return $this->_describePatternMatch($this->_getPattern(), $compare);
  637.         } else {
  638.             $dumper = &$this->_getDumper();
  639.             return "Pattern [" . $this->_getPattern() .
  640.                     "] not detected in [" .
  641.                     $dumper->describeValue($compare) . "]";
  642.         }
  643.     }
  644.  
  645.     /**
  646.      *    Describes a pattern match including the string
  647.      *    found and it's position.
  648.      *    @param string $pattern        Regex to match against.
  649.      *    @param string $subject        Subject to search.
  650.      *    @access protected
  651.      */
  652.     function _describePatternMatch($pattern, $subject) {
  653.         preg_match($pattern, $subject, $matches);
  654.         $position = strpos($subject, $matches[0]);
  655.         $dumper = $this->_getDumper();
  656.         return "Pattern [$pattern] detected at character [$position] in [" .
  657.                 $dumper->describeValue($subject) . "] as [" .
  658.                 $matches[0] . "] in region [" .
  659.                 $dumper->clipString($subject, 100, $position) . "]";
  660.     }
  661. }
  662.  
  663. /**
  664.  *    @package SimpleTest
  665.  *    @subpackage UnitTester
  666.  *    @deprecated
  667.  */
  668. class WantedPatternExpectation extends PatternExpectation {
  669. }
  670.  
  671. /**
  672.  *    Fail if a pattern is detected within the
  673.  *    comparison.
  674.  *    @package SimpleTest
  675.  *    @subpackage UnitTester
  676.  */
  677. class NoPatternExpectation extends PatternExpectation {
  678.  
  679.     /**
  680.      *    Sets the reject pattern
  681.      *    @param string $pattern    Pattern to search for.
  682.      *    @param string $message    Customised message on failure.
  683.      *    @access public
  684.      */
  685.     function NoPatternExpectation($pattern, $message = '%s') {
  686.         $this->PatternExpectation($pattern, $message);
  687.     }
  688.  
  689.     /**
  690.      *    Tests the expectation. False if the Perl regex
  691.      *    matches the comparison value.
  692.      *    @param string $compare        Comparison value.
  693.      *    @return boolean               True if correct.
  694.      *    @access public
  695.      */
  696.     function test($compare) {
  697.         return ! parent::test($compare);
  698.     }
  699.  
  700.     /**
  701.      *    Returns a human readable test message.
  702.      *    @param string $compare      Comparison value.
  703.      *    @return string              Description of success
  704.      *                                 or failure.
  705.      *    @access public
  706.      */
  707.     function testMessage($compare) {
  708.         if ($this->test($compare)) {
  709.             $dumper = &$this->_getDumper();
  710.             return "Pattern [" . $this->_getPattern() .
  711.                     "] not detected in [" .
  712.                     $dumper->describeValue($compare) . "]";
  713.         } else {
  714.             return $this->_describePatternMatch($this->_getPattern(), $compare);
  715.         }
  716.     }
  717. }
  718.  
  719. /**
  720.  *    @package SimpleTest
  721.  *    @subpackage UnitTester
  722.  *      @deprecated
  723.  */
  724. class UnwantedPatternExpectation extends NoPatternExpectation {
  725. }
  726.  
  727. /**
  728.  *    Tests either type or class name if it's an object.
  729.  *      @package SimpleTest
  730.  *      @subpackage UnitTester
  731.  */
  732. class IsAExpectation extends SimpleExpectation {
  733.     var $_type;
  734.  
  735.     /**
  736.      *    Sets the type to compare with.
  737.      *    @param string $type       Type or class name.
  738.      *    @param string $message    Customised message on failure.
  739.      *    @access public
  740.      */
  741.     function IsAExpectation($type, $message = '%s') {
  742.         $this->SimpleExpectation($message);
  743.         $this->_type = $type;
  744.     }
  745.  
  746.     /**
  747.      *    Accessor for type to check against.
  748.      *    @return string    Type or class name.
  749.      *    @access protected
  750.      */
  751.     function _getType() {
  752.         return $this->_type;
  753.     }
  754.  
  755.     /**
  756.      *    Tests the expectation. True if the type or
  757.      *    class matches the string value.
  758.      *    @param string $compare        Comparison value.
  759.      *    @return boolean               True if correct.
  760.      *    @access public
  761.      */
  762.     function test($compare) {
  763.         if (is_object($compare)) {
  764.             return SimpleTestCompatibility::isA($compare, $this->_type);
  765.         } else {
  766.             return (strtolower(gettype($compare)) == $this->_canonicalType($this->_type));
  767.         }
  768.     }
  769.  
  770.     /**
  771.      *    Coerces type name into a gettype() match.
  772.      *    @param string $type        User type.
  773.      *    @return string             Simpler type.
  774.      *    @access private
  775.      */
  776.     function _canonicalType($type) {
  777.         $type = strtolower($type);
  778.         $map = array(
  779.                 'bool' => 'boolean',
  780.                 'float' => 'double',
  781.                 'real' => 'double',
  782.                 'int' => 'integer');
  783.         if (isset($map[$type])) {
  784.             $type = $map[$type];
  785.         }
  786.         return $type;
  787.     }
  788.  
  789.     /**
  790.      *    Returns a human readable test message.
  791.      *    @param mixed $compare      Comparison value.
  792.      *    @return string             Description of success
  793.      *                                or failure.
  794.      *    @access public
  795.      */
  796.     function testMessage($compare) {
  797.         $dumper = &$this->_getDumper();
  798.         return "Value [" . $dumper->describeValue($compare) .
  799.                 "] should be type [" . $this->_type . "]";
  800.     }
  801. }
  802.  
  803. /**
  804.  *    Tests either type or class name if it's an object.
  805.  *    Will succeed if the type does not match.
  806.  *      @package SimpleTest
  807.  *      @subpackage UnitTester
  808.  */
  809. class NotAExpectation extends IsAExpectation {
  810.     var $_type;
  811.  
  812.     /**
  813.      *    Sets the type to compare with.
  814.      *    @param string $type       Type or class name.
  815.      *    @param string $message    Customised message on failure.
  816.      *    @access public
  817.      */
  818.     function NotAExpectation($type, $message = '%s') {
  819.         $this->IsAExpectation($type, $message);
  820.     }
  821.  
  822.     /**
  823.      *    Tests the expectation. False if the type or
  824.      *    class matches the string value.
  825.      *    @param string $compare        Comparison value.
  826.      *    @return boolean               True if different.
  827.      *    @access public
  828.      */
  829.     function test($compare) {
  830.         return ! parent::test($compare);
  831.     }
  832.  
  833.     /**
  834.      *    Returns a human readable test message.
  835.      *    @param mixed $compare      Comparison value.
  836.      *    @return string             Description of success
  837.      *                                or failure.
  838.      *    @access public
  839.      */
  840.     function testMessage($compare) {
  841.         $dumper = &$this->_getDumper();
  842.         return "Value [" . $dumper->describeValue($compare) .
  843.                 "] should not be type [" . $this->_getType() . "]";
  844.     }
  845. }
  846.  
  847. /**
  848.  *    Tests for existance of a method in an object
  849.  *      @package SimpleTest
  850.  *      @subpackage UnitTester
  851.  */
  852. class MethodExistsExpectation extends SimpleExpectation {
  853.     var $_method;
  854.  
  855.     /**
  856.      *    Sets the value to compare against.
  857.      *    @param string $method     Method to check.
  858.      *    @param string $message    Customised message on failure.
  859.      *    @access public
  860.      *    @return void 
  861.      */
  862.     function MethodExistsExpectation($method, $message = '%s') {
  863.         $this->SimpleExpectation($message);
  864.         $this->_method = &$method;
  865.     }
  866.  
  867.     /**
  868.      *    Tests the expectation. True if the method exists in the test object.
  869.      *    @param string $compare        Comparison method name.
  870.      *    @return boolean               True if correct.
  871.      *    @access public
  872.      */
  873.     function test($compare) {
  874.         return (boolean)(is_object($compare) && method_exists($compare, $this->_method));
  875.     }
  876.  
  877.     /**
  878.      *    Returns a human readable test message.
  879.      *    @param mixed $compare      Comparison value.
  880.      *    @return string             Description of success
  881.      *                                or failure.
  882.      *    @access public
  883.      */
  884.     function testMessage($compare) {
  885.         $dumper = &$this->_getDumper();
  886.         if (! is_object($compare)) {
  887.             return 'No method on non-object [' . $dumper->describeValue($compare) . ']';
  888.         }
  889.         $method = $this->_method;
  890.         return "Object [" . $dumper->describeValue($compare) .
  891.                 "] should contain method [$method]";
  892.     }
  893. }
  894. ?>

Documentation generated on Sun, 04 May 2008 09:21:34 -0500 by phpDocumentor 1.3.0