Source for file mock_objects.php

Documentation is available at mock_objects.php

  1. <?php
  2. /**
  3.  *  base include file for SimpleTest
  4.  *  @package    SimpleTest
  5.  *  @subpackage MockObjects
  6.  *  @version    $Id: mock_objects.php 1953 2009-09-20 01:26:25Z jsweat $
  7.  */
  8.  
  9. /**#@+
  10.  * include SimpleTest files
  11.  */
  12. require_once(dirname(__FILE__) . '/expectation.php');
  13. require_once(dirname(__FILE__) . '/simpletest.php');
  14. require_once(dirname(__FILE__) . '/dumper.php');
  15. require_once(dirname(__FILE__) . '/reflection_php5.php');
  16. /**#@-*/
  17.  
  18. /**
  19.  * Default character simpletest will substitute for any value
  20.  */
  21. if (! defined('MOCK_ANYTHING')) {
  22.     define('MOCK_ANYTHING', '*');
  23. }
  24.  
  25. /**
  26.  *    Parameter comparison assertion.
  27.  *    @package SimpleTest
  28.  *    @subpackage MockObjects
  29.  */
  30. class ParametersExpectation extends SimpleExpectation {
  31.     private $expected;
  32.  
  33.     /**
  34.      *    Sets the expected parameter list.
  35.      *    @param array $parameters  Array of parameters including
  36.      *                               those that are wildcarded.
  37.      *                               If the value is not an array
  38.      *                               then it is considered to match any.
  39.      *    @param string $message    Customised message on failure.
  40.      *    @access public
  41.      */
  42.     function __construct($expected = false, $message = '%s') {
  43.         parent::__construct($message);
  44.         $this->expected = $expected;
  45.     }
  46.  
  47.     /**
  48.      *    Tests the assertion. True if correct.
  49.      *    @param array $parameters     Comparison values.
  50.      *    @return boolean              True if correct.
  51.      *    @access public
  52.      */
  53.     function test($parameters) {
  54.         if (! is_array($this->expected)) {
  55.             return true;
  56.         }
  57.         if (count($this->expected) != count($parameters)) {
  58.             return false;
  59.         }
  60.         for ($i = 0; $i < count($this->expected); $i++) {
  61.             if (! $this->testParameter($parameters[$i], $this->expected[$i])) {
  62.                 return false;
  63.             }
  64.         }
  65.         return true;
  66.     }
  67.  
  68.     /**
  69.      *    Tests an individual parameter.
  70.      *    @param mixed $parameter    Value to test.
  71.      *    @param mixed $expected     Comparison value.
  72.      *    @return boolean            True if expectation
  73.      *                                fulfilled.
  74.      *    @access private
  75.      */
  76.     protected function testParameter($parameter, $expected) {
  77.         $comparison = $this->coerceToExpectation($expected);
  78.         return $comparison->test($parameter);
  79.     }
  80.  
  81.     /**
  82.      *    Returns a human readable test message.
  83.      *    @param array $comparison   Incoming parameter list.
  84.      *    @return string             Description of success
  85.      *                                or failure.
  86.      *    @access public
  87.      */
  88.     function testMessage($parameters) {
  89.         if ($this->test($parameters)) {
  90.             return "Expectation of " . count($this->expected) .
  91.                     " arguments of [" . $this->renderArguments($this->expected) .
  92.                     "] is correct";
  93.         } else {
  94.             return $this->describeDifference($this->expected, $parameters);
  95.         }
  96.     }
  97.  
  98.     /**
  99.      *    Message to display if expectation differs from
  100.      *    the parameters actually received.
  101.      *    @param array $expected      Expected parameters as list.
  102.      *    @param array $parameters    Actual parameters received.
  103.      *    @return string              Description of difference.
  104.      *    @access private
  105.      */
  106.     protected function describeDifference($expected, $parameters) {
  107.         if (count($expected) != count($parameters)) {
  108.             return "Expected " . count($expected) .
  109.                     " arguments of [" . $this->renderArguments($expected) .
  110.                     "] but got " . count($parameters) .
  111.                     " arguments of [" . $this->renderArguments($parameters) . "]";
  112.         }
  113.         $messages = array();
  114.         for ($i = 0; $i < count($expected); $i++) {
  115.             $comparison = $this->coerceToExpectation($expected[$i]);
  116.             if (! $comparison->test($parameters[$i])) {
  117.                 $messages[] = "parameter " . ($i + 1) . " with [" .
  118.                         $comparison->overlayMessage($parameters[$i], $this->getDumper()) . "]";
  119.             }
  120.         }
  121.         return "Parameter expectation differs at " . implode(" and ", $messages);
  122.     }
  123.  
  124.     /**
  125.      *    Creates an identical expectation if the
  126.      *    object/value is not already some type
  127.      *    of expectation.
  128.      *    @param mixed $expected      Expected value.
  129.      *    @return SimpleExpectation   Expectation object.
  130.      *    @access private
  131.      */
  132.     protected function coerceToExpectation($expected) {
  133.         if (SimpleExpectation::isExpectation($expected)) {
  134.             return $expected;
  135.         }
  136.         return new IdenticalExpectation($expected);
  137.     }
  138.  
  139.     /**
  140.      *    Renders the argument list as a string for
  141.      *    messages.
  142.      *    @param array $args    Incoming arguments.
  143.      *    @return string        Simple description of type and value.
  144.      *    @access private
  145.      */
  146.     protected function renderArguments($args) {
  147.         $descriptions = array();
  148.         if (is_array($args)) {
  149.             foreach ($args as $arg) {
  150.                 $dumper = new SimpleDumper();
  151.                 $descriptions[] = $dumper->describeValue($arg);
  152.             }
  153.         }
  154.         return implode(', ', $descriptions);
  155.     }
  156. }
  157.  
  158. /**
  159.  *    Confirms that the number of calls on a method is as expected.
  160.  *  @package    SimpleTest
  161.  *  @subpackage MockObjects
  162.  */
  163. class CallCountExpectation extends SimpleExpectation {
  164.     private $method;
  165.     private $count;
  166.  
  167.     /**
  168.      *    Stashes the method and expected count for later
  169.      *    reporting.
  170.      *    @param string $method    Name of method to confirm against.
  171.      *    @param integer $count    Expected number of calls.
  172.      *    @param string $message   Custom error message.
  173.      */
  174.     function __construct($method, $count, $message = '%s') {
  175.         $this->method = $method;
  176.         $this->count = $count;
  177.         parent::__construct($message);
  178.     }
  179.  
  180.     /**
  181.      *    Tests the assertion. True if correct.
  182.      *    @param integer $compare     Measured call count.
  183.      *    @return boolean             True if expected.
  184.      *    @access public
  185.      */
  186.     function test($compare) {
  187.         return ($this->count == $compare);
  188.     }
  189.  
  190.     /**
  191.      *    Reports the comparison.
  192.      *    @param integer $compare     Measured call count.
  193.      *    @return string              Message to show.
  194.      *    @access public
  195.      */
  196.     function testMessage($compare) {
  197.         return 'Expected call count for [' . $this->method .
  198.                 '] was [' . $this->count .
  199.                 '] got [' . $compare . ']';
  200.     }
  201. }
  202.  
  203. /**
  204.  *    Confirms that the number of calls on a method is as expected.
  205.  *  @package    SimpleTest
  206.  *  @subpackage MockObjects
  207.  */
  208. class MinimumCallCountExpectation extends SimpleExpectation {
  209.     private $method;
  210.     private $count;
  211.  
  212.     /**
  213.      *    Stashes the method and expected count for later
  214.      *    reporting.
  215.      *    @param string $method    Name of method to confirm against.
  216.      *    @param integer $count    Minimum number of calls.
  217.      *    @param string $message   Custom error message.
  218.      */
  219.     function __construct($method, $count, $message = '%s') {
  220.         $this->method = $method;
  221.         $this->count = $count;
  222.         parent::__construct($message);
  223.     }
  224.  
  225.     /**
  226.      *    Tests the assertion. True if correct.
  227.      *    @param integer $compare     Measured call count.
  228.      *    @return boolean             True if enough.
  229.      *    @access public
  230.      */
  231.     function test($compare) {
  232.         return ($this->count <= $compare);
  233.     }
  234.  
  235.     /**
  236.      *    Reports the comparison.
  237.      *    @param integer $compare     Measured call count.
  238.      *    @return string              Message to show.
  239.      *    @access public
  240.      */
  241.     function testMessage($compare) {
  242.         return 'Minimum call count for [' . $this->method .
  243.                 '] was [' . $this->count .
  244.                 '] got [' . $compare . ']';
  245.     }
  246. }
  247.  
  248. /**
  249.  *    Confirms that the number of calls on a method is as expected.
  250.  *    @package      SimpleTest
  251.  *    @subpackage   MockObjects
  252.  */
  253. class MaximumCallCountExpectation extends SimpleExpectation {
  254.     private $method;
  255.     private $count;
  256.  
  257.     /**
  258.      *    Stashes the method and expected count for later
  259.      *    reporting.
  260.      *    @param string $method    Name of method to confirm against.
  261.      *    @param integer $count    Minimum number of calls.
  262.      *    @param string $message   Custom error message.
  263.      */
  264.     function __construct($method, $count, $message = '%s') {
  265.         $this->method = $method;
  266.         $this->count = $count;
  267.         parent::__construct($message);
  268.     }
  269.  
  270.     /**
  271.      *    Tests the assertion. True if correct.
  272.      *    @param integer $compare     Measured call count.
  273.      *    @return boolean             True if not over.
  274.      *    @access public
  275.      */
  276.     function test($compare) {
  277.         return ($this->count >= $compare);
  278.     }
  279.  
  280.     /**
  281.      *    Reports the comparison.
  282.      *    @param integer $compare     Measured call count.
  283.      *    @return string              Message to show.
  284.      *    @access public
  285.      */
  286.     function testMessage($compare) {
  287.         return 'Maximum call count for [' . $this->method .
  288.                 '] was [' . $this->count .
  289.                 '] got [' . $compare . ']';
  290.     }
  291. }
  292.  
  293. /**
  294.  *    Retrieves method actions by searching the
  295.  *    parameter lists until an expected match is found.
  296.  *    @package SimpleTest
  297.  *    @subpackage MockObjects
  298.  */
  299. class SimpleSignatureMap {
  300.     private $map;
  301.  
  302.     /**
  303.      *    Creates an empty call map.
  304.      *    @access public
  305.      */
  306.     function __construct() {
  307.         $this->map = array();
  308.     }
  309.  
  310.     /**
  311.      *    Stashes a reference against a method call.
  312.      *    @param array $parameters    Array of arguments (including wildcards).
  313.      *    @param mixed $action        Reference placed in the map.
  314.      *    @access public
  315.      */
  316.     function add($parameters, $action) {
  317.         $place = count($this->map);
  318.         $this->map[$place] = array();
  319.         $this->map[$place]['params'] = new ParametersExpectation($parameters);
  320.         $this->map[$place]['content'] = $action;
  321.     }
  322.  
  323.     /**
  324.      *    Searches the call list for a matching parameter
  325.      *    set. Returned by reference.
  326.      *    @param array $parameters    Parameters to search by
  327.      *                                 without wildcards.
  328.      *    @return object              Object held in the first matching
  329.      *                                 slot, otherwise null.
  330.      *    @access public
  331.      */
  332.     function &findFirstAction($parameters) {
  333.         $slot = $this->findFirstSlot($parameters);
  334.         if (isset($slot) && isset($slot['content'])) {
  335.             return $slot['content'];
  336.         }
  337.         $null = null;
  338.         return $null;
  339.     }
  340.  
  341.     /**
  342.      *    Searches the call list for a matching parameter
  343.      *    set. True if successful.
  344.      *    @param array $parameters    Parameters to search by
  345.      *                                 without wildcards.
  346.      *    @return boolean             True if a match is present.
  347.      *    @access public
  348.      */
  349.     function isMatch($parameters) {
  350.         return ($this->findFirstSlot($parameters) != null);
  351.     }
  352.     
  353.     /**
  354.      *    Compares the incoming parameters with the
  355.      *    internal expectation. Uses the incoming $test
  356.      *    to dispatch the test message.
  357.      *    @param SimpleTestCase $test   Test to dispatch to.
  358.      *    @param array $parameters      The actual calling arguments.
  359.      *    @param string $message        The message to overlay.
  360.      *    @access public
  361.      */
  362.     function test($test, $parameters, $message) {
  363.     }
  364.  
  365.     /**
  366.      *    Searches the map for a matching item.
  367.      *    @param array $parameters    Parameters to search by
  368.      *                                 without wildcards.
  369.      *    @return array               Reference to slot or null.
  370.      *    @access private
  371.      */
  372.     function &findFirstSlot($parameters) {
  373.         $count = count($this->map);
  374.         for ($i = 0; $i < $count; $i++) {
  375.             if ($this->map[$i]["params"]->test($parameters)) {
  376.                 return $this->map[$i];
  377.             }
  378.         }
  379.         $null = null;
  380.         return $null;
  381.     }
  382. }
  383.  
  384. /**
  385.  *    Allows setting of actions against call signatures either
  386.  *    at a specific time, or always. Specific time settings
  387.  *    trump lasting ones, otherwise the most recently added
  388.  *    will mask an earlier match.
  389.  *    @package SimpleTest
  390.  *    @subpackage MockObjects
  391.  */
  392. class SimpleCallSchedule {
  393.     private $wildcard = MOCK_ANYTHING;
  394.     private $always;
  395.     private $at;
  396.     
  397.     /**
  398.      *    Sets up an empty response schedule.
  399.      *    Creates an empty call map.
  400.      */
  401.     function __construct() {
  402.         $this->always = array();
  403.         $this->at = array();
  404.     }
  405.     
  406.     /**
  407.      *    Stores an action against a signature that
  408.      *    will always fire unless masked by a time
  409.      *    specific one.
  410.      *    @param string $method        Method name.
  411.      *    @param array $args           Calling parameters.
  412.      *    @param SimpleAction $action  Actually simpleByValue, etc.
  413.      *    @access public
  414.      */
  415.     function register($method, $args, $action) {
  416.         $args = $this->replaceWildcards($args);
  417.         $method = strtolower($method);
  418.         if (! isset($this->always[$method])) {
  419.             $this->always[$method] = new SimpleSignatureMap();
  420.         }
  421.         $this->always[$method]->add($args, $action);
  422.     }
  423.     
  424.     /**
  425.      *    Stores an action against a signature that
  426.      *    will fire at a specific time in the future.
  427.      *    @param integer $step         delay of calls to this method,
  428.      *                                  0 is next.
  429.      *    @param string $method        Method name.
  430.      *    @param array $args           Calling parameters.
  431.      *    @param SimpleAction $action  Actually SimpleByValue, etc.
  432.      *    @access public
  433.      */
  434.     function registerAt($step, $method, $args, $action) {
  435.         $args = $this->replaceWildcards($args);
  436.         $method = strtolower($method);
  437.         if (! isset($this->at[$method])) {
  438.             $this->at[$method] = array();
  439.         }
  440.         if (! isset($this->at[$method][$step])) {
  441.             $this->at[$method][$step] = new SimpleSignatureMap();
  442.         }
  443.         $this->at[$method][$step]->add($args, $action);
  444.     }
  445.     
  446.     /**
  447.      *  Sets up an expectation on the argument list.
  448.      *  @param string $method       Method to test.
  449.      *  @param array $args          Bare arguments or list of
  450.      *                               expectation objects.
  451.      *  @param string $message      Failure message.
  452.      */
  453.     function expectArguments($method, $args, $message) {
  454.         $args = $this->replaceWildcards($args);
  455.         $message .= Mock::getExpectationLine();
  456.         $this->expected_args[strtolower($method)] =
  457.                 new ParametersExpectation($args, $message);
  458.  
  459.     }
  460.     
  461.     /**
  462.      *    Actually carry out the action stored previously,
  463.      *    if the parameters match.
  464.      *    @param integer $step      Time of call.
  465.      *    @param string $method     Method name.
  466.      *    @param array $args        The parameters making up the
  467.      *                               rest of the call.
  468.      *    @return mixed             The result of the action.
  469.      */
  470.     function &respond($step, $method, $args) {
  471.         $method = strtolower($method);
  472.         if (isset($this->at[$method][$step])) {
  473.             if ($this->at[$method][$step]->isMatch($args)) {
  474.                 $action = $this->at[$method][$step]->findFirstAction($args);
  475.                 if (isset($action)) {
  476.                     return $action->act();
  477.                 }
  478.             }
  479.         }
  480.         if (isset($this->always[$method])) {
  481.             $action = $this->always[$method]->findFirstAction($args);
  482.             if (isset($action)) {
  483.                 return $action->act();
  484.             }
  485.         }
  486.         $null = null;
  487.         return $null;
  488.     }
  489.     
  490.     /**
  491.      *    Replaces wildcard matches with wildcard
  492.      *    expectations in the argument list.
  493.      *    @param array $args      Raw argument list.
  494.      *    @return array           Argument list with
  495.      *                             expectations.
  496.      *    @access private
  497.      */
  498.     protected function replaceWildcards($args) {
  499.         if ($args === false) {
  500.             return false;
  501.         }
  502.         for ($i = 0; $i < count($args); $i++) {
  503.             if ($args[$i] === $this->wildcard) {
  504.                 $args[$i] = new AnythingExpectation();
  505.             }
  506.         }
  507.         return $args;
  508.     }
  509. }
  510.  
  511. /**
  512.  *    A type of SimpleMethodAction.
  513.  *    Stashes a value for returning later. Follows usual
  514.  *    PHP5 semantics of objects being returned by reference.
  515.  *    @package SimpleTest
  516.  *    @subpackage MockObjects
  517.  */
  518. class SimpleReturn {
  519.     private $value;
  520.     
  521.     /**
  522.      *    Stashes it for later.
  523.      *    @param mixed $value     You need to clone objects
  524.      *                             if you want copy semantics
  525.      *                             for these.
  526.      *    @access public
  527.      */
  528.     function __construct($value) {
  529.         $this->value = $value;
  530.     }
  531.     
  532.     /**
  533.      *    Returns the value stored earlier.
  534.      *    @return mixed    Whatever was stashed.
  535.      *    @access public
  536.      */
  537.     function act() {
  538.         return $this->value;
  539.     }
  540. }
  541.  
  542. /**
  543.  *    A type of SimpleMethodAction.
  544.  *    Stashes a reference for returning later.
  545.  *    @package SimpleTest
  546.  *    @subpackage MockObjects
  547.  */
  548. class SimpleByReference {
  549.     private $reference;
  550.     
  551.     /**
  552.      *    Stashes it for later.
  553.      *    @param mixed $reference     Actual PHP4 style reference.
  554.      *    @access public
  555.      */
  556.     function __construct(&$reference) {
  557.         $this->reference = &$reference;
  558.     }
  559.     
  560.     /**
  561.      *    Returns the reference stored earlier.
  562.      *    @return mixed    Whatever was stashed.
  563.      *    @access public
  564.      */
  565.     function &act() {
  566.         return $this->reference;
  567.     }
  568. }
  569.  
  570. /**
  571.  *    A type of SimpleMethodAction.
  572.  *    Stashes a value for returning later.
  573.  *    @package SimpleTest
  574.  *    @subpackage MockObjects
  575.  */
  576. class SimpleByValue {
  577.     private $value;
  578.     
  579.     /**
  580.      *    Stashes it for later.
  581.      *    @param mixed $value     You need to clone objects
  582.      *                             if you want copy semantics
  583.      *                             for these.
  584.      *    @access public
  585.      */
  586.     function __construct($value) {
  587.         $this->value = $value;
  588.     }
  589.     
  590.     /**
  591.      *    Returns the value stored earlier.
  592.      *    @return mixed    Whatever was stashed.
  593.      *    @access public
  594.      */
  595.     function &act() {
  596.         $dummy = $this->value;
  597.         return $dummy;
  598.     }
  599. }
  600.  
  601. /**
  602.  *    A type of SimpleMethodAction.
  603.  *    Stashes an exception for throwing later.
  604.  *    @package SimpleTest
  605.  *    @subpackage MockObjects
  606.  */
  607. class SimpleThrower {
  608.     private $exception;
  609.     
  610.     /**
  611.      *    Stashes it for later.
  612.      *    @param Exception $exception    The exception object to throw.
  613.      *    @access public
  614.      */
  615.     function __construct($exception) {
  616.         $this->exception = $exception;
  617.     }
  618.     
  619.     /**
  620.      *    Throws the exceptins stashed earlier.
  621.      *    @access public
  622.      */
  623.     function act() {
  624.         throw $this->exception;
  625.     }
  626. }
  627.  
  628. /**
  629.  *    A type of SimpleMethodAction.
  630.  *    Stashes an error for emitting later.
  631.  *    @package SimpleTest
  632.  *    @subpackage MockObjects
  633.  */
  634. class SimpleErrorThrower {
  635.     private $error;
  636.     private $severity;
  637.     
  638.     /**
  639.      *    Stashes an error to throw later.
  640.      *    @param string $error      Error message.
  641.      *    @param integer $severity  PHP error constant, e.g E_USER_ERROR.
  642.      *    @access public
  643.      */
  644.     function __construct($error, $severity) {
  645.         $this->error = $error;
  646.         $this->severity = $severity;
  647.     }
  648.     
  649.     /**
  650.      *    Triggers the stashed error.
  651.      *    @access public
  652.      */
  653.     function &act() {
  654.         trigger_error($this->error, $this->severity);
  655.         $null = null;
  656.         return $null;
  657.     }
  658. }
  659.  
  660. /**
  661.  *    A base class or delegate that extends an
  662.  *    empty collection of methods that can have their
  663.  *    return values set and expectations made of the
  664.  *    calls upon them. The mock will assert the
  665.  *    expectations against it's attached test case in
  666.  *    addition to the server stub behaviour or returning
  667.  *    preprogrammed responses.
  668.  *    @package SimpleTest
  669.  *    @subpackage MockObjects
  670.  */
  671. class SimpleMock {
  672.     private $actions;
  673.     private $expectations;
  674.     private $wildcard = MOCK_ANYTHING;
  675.     private $is_strict = true;
  676.     private $call_counts;
  677.     private $expected_counts;
  678.     private $max_counts;
  679.     private $expected_args;
  680.     private $expected_args_at;
  681.  
  682.     /**
  683.      *    Creates an empty action list and expectation list.
  684.      *    All call counts are set to zero.
  685.      *    @access public
  686.      */
  687.     function SimpleMock() {
  688.         $this->actions = new SimpleCallSchedule();
  689.         $this->expectations = new SimpleCallSchedule();
  690.         $this->call_counts = array();
  691.         $this->expected_counts = array();
  692.         $this->max_counts = array();
  693.         $this->expected_args = array();
  694.         $this->expected_args_at = array();
  695.         $this->getCurrentTestCase()->tell($this);
  696.     }
  697.     
  698.     /**
  699.      *    Disables a name check when setting expectations.
  700.      *    This hack is needed for the partial mocks.
  701.      *    @access public
  702.      */
  703.     function disableExpectationNameChecks() {
  704.         $this->is_strict = false;
  705.     }
  706.  
  707.     /**
  708.      *    Finds currently running test.
  709.      *    @return SimpeTestCase    Current test case.
  710.      *    @access protected
  711.      */
  712.     protected function getCurrentTestCase() {
  713.         return SimpleTest::getContext()->getTest();
  714.     }
  715.  
  716.     /**
  717.      *    Die if bad arguments array is passed.
  718.      *    @param mixed $args     The arguments value to be checked.
  719.      *    @param string $task    Description of task attempt.
  720.      *    @return boolean        Valid arguments
  721.      *    @access private
  722.      */
  723.     protected function checkArgumentsIsArray($args, $task) {
  724.         if (! is_array($args)) {
  725.             trigger_error(
  726.                 "Cannot $task as \$args parameter is not an array",
  727.                 E_USER_ERROR);
  728.         }
  729.     }
  730.  
  731.     /**
  732.      *    Triggers a PHP error if the method is not part
  733.      *    of this object.
  734.      *    @param string $method        Name of method.
  735.      *    @param string $task          Description of task attempt.
  736.      *    @access protected
  737.      */
  738.     protected function dieOnNoMethod($method, $task) {
  739.         if ($this->is_strict && ! method_exists($this, $method)) {
  740.             trigger_error(
  741.                     "Cannot $task as no ${method}() in class " . get_class($this),
  742.                     E_USER_ERROR);
  743.         }
  744.     }
  745.  
  746.     /**
  747.      *    Replaces wildcard matches with wildcard
  748.      *    expectations in the argument list.
  749.      *    @param array $args      Raw argument list.
  750.      *    @return array           Argument list with
  751.      *                             expectations.
  752.      *    @access private
  753.      */
  754.     function replaceWildcards($args) {
  755.         if ($args === false) {
  756.             return false;
  757.         }
  758.         for ($i = 0; $i < count($args); $i++) {
  759.             if ($args[$i] === $this->wildcard) {
  760.                 $args[$i] = new AnythingExpectation();
  761.             }
  762.         }
  763.         return $args;
  764.     }
  765.  
  766.     /**
  767.      *    Adds one to the call count of a method.
  768.      *    @param string $method        Method called.
  769.      *    @param array $args           Arguments as an array.
  770.      *    @access protected
  771.      */
  772.     protected function addCall($method, $args) {
  773.         if (! isset($this->call_counts[$method])) {
  774.             $this->call_counts[$method] = 0;
  775.         }
  776.         $this->call_counts[$method]++;
  777.     }
  778.  
  779.     /**
  780.      *    Fetches the call count of a method so far.
  781.      *    @param string $method        Method name called.
  782.      *    @return integer              Number of calls so far.
  783.      *    @access public
  784.      */
  785.     function getCallCount($method) {
  786.         $this->dieOnNoMethod($method, "get call count");
  787.         $method = strtolower($method);
  788.         if (! isset($this->call_counts[$method])) {
  789.             return 0;
  790.         }
  791.         return $this->call_counts[$method];
  792.     }
  793.  
  794.     /**
  795.      *    Sets a return for a parameter list that will
  796.      *    be passed on by all calls to this method that match.
  797.      *    @param string $method       Method name.
  798.      *    @param mixed $value         Result of call by value/handle.
  799.      *    @param array $args          List of parameters to match
  800.      *                                 including wildcards.
  801.      *    @access public
  802.      */
  803.     function returns($method, $value, $args = false) {
  804.         $this->dieOnNoMethod($method, "set return");
  805.         $this->actions->register($method, $args, new SimpleReturn($value));
  806.     }
  807.  
  808.     /**
  809.      *    Sets a return for a parameter list that will
  810.      *    be passed only when the required call count
  811.      *    is reached.
  812.      *    @param integer $timing   Number of calls in the future
  813.      *                              to which the result applies. If
  814.      *                              not set then all calls will return
  815.      *                              the value.
  816.      *    @param string $method    Method name.
  817.      *    @param mixed $value      Result of call passed.
  818.      *    @param array $args       List of parameters to match
  819.      *                              including wildcards.
  820.      *    @access public
  821.      */
  822.     function returnsAt($timing, $method, $value, $args = false) {
  823.         $this->dieOnNoMethod($method, "set return value sequence");
  824.         $this->actions->registerAt($timing, $method, $args, new SimpleReturn($value));
  825.     }
  826.  
  827.     /**
  828.      *    Sets a return for a parameter list that will
  829.      *    be passed by value for all calls to this method.
  830.      *    @param string $method       Method name.
  831.      *    @param mixed $value         Result of call passed by value.
  832.      *    @param array $args          List of parameters to match
  833.      *                                 including wildcards.
  834.      *    @access public
  835.      */
  836.     function returnsByValue($method, $value, $args = false) {
  837.         $this->dieOnNoMethod($method, "set return value");
  838.         $this->actions->register($method, $args, new SimpleByValue($value));
  839.     }
  840.     
  841.     /** @deprecated */
  842.     function setReturnValue($method, $value, $args = false) {
  843.         $this->returnsByValue($method, $value, $args);
  844.     }
  845.  
  846.     /**
  847.      *    Sets a return for a parameter list that will
  848.      *    be passed by value only when the required call count
  849.      *    is reached.
  850.      *    @param integer $timing   Number of calls in the future
  851.      *                              to which the result applies. If
  852.      *                              not set then all calls will return
  853.      *                              the value.
  854.      *    @param string $method    Method name.
  855.      *    @param mixed $value      Result of call passed by value.
  856.      *    @param array $args       List of parameters to match
  857.      *                              including wildcards.
  858.      *    @access public
  859.      */
  860.     function returnsByValueAt($timing, $method, $value, $args = false) {
  861.         $this->dieOnNoMethod($method, "set return value sequence");
  862.         $this->actions->registerAt($timing, $method, $args, new SimpleByValue($value));
  863.     }
  864.     
  865.     /** @deprecated */
  866.     function setReturnValueAt($timing, $method, $value, $args = false) {
  867.         $this->returnsByValueAt($timing, $method, $value, $args);
  868.     }
  869.  
  870.     /**
  871.      *    Sets a return for a parameter list that will
  872.      *    be passed by reference for all calls.
  873.      *    @param string $method       Method name.
  874.      *    @param mixed $reference     Result of the call will be this object.
  875.      *    @param array $args          List of parameters to match
  876.      *                                 including wildcards.
  877.      *    @access public
  878.      */
  879.     function returnsByReference($method, &$reference, $args = false) {
  880.         $this->dieOnNoMethod($method, "set return reference");
  881.         $this->actions->register($method, $args, new SimpleByReference($reference));
  882.     }
  883.     
  884.     /** @deprecated */
  885.     function setReturnReference($method, &$reference, $args = false) {
  886.         $this->returnsByReference($method, $reference, $args);
  887.     }
  888.     
  889.     /**
  890.      *    Sets a return for a parameter list that will
  891.      *    be passed by value only when the required call count
  892.      *    is reached.
  893.      *    @param integer $timing    Number of calls in the future
  894.      *                               to which the result applies. If
  895.      *                               not set then all calls will return
  896.      *                               the value.
  897.      *    @param string $method     Method name.
  898.      *    @param mixed $reference   Result of the call will be this object.
  899.      *    @param array $args        List of parameters to match
  900.      *                               including wildcards.
  901.      *    @access public
  902.      */
  903.     function returnsByReferenceAt($timing, $method, &$reference, $args = false) {
  904.         $this->dieOnNoMethod($method, "set return reference sequence");
  905.         $this->actions->registerAt($timing, $method, $args, new SimpleByReference($reference));
  906.     }
  907.     
  908.     /** @deprecated */
  909.     function setReturnReferenceAt($timing, $method, &$reference, $args = false) {
  910.         $this->returnsByReferenceAt($timing, $method, $reference, $args);
  911.     }
  912.     
  913.     /**
  914.      *    Sets up an expected call with a set of
  915.      *    expected parameters in that call. All
  916.      *    calls will be compared to these expectations
  917.      *    regardless of when the call is made.
  918.      *    @param string $method        Method call to test.
  919.      *    @param array $args           Expected parameters for the call
  920.      *                                  including wildcards.
  921.      *    @param string $message       Overridden message.
  922.      *    @access public
  923.      */
  924.     function expect($method, $args, $message = '%s') {
  925.         $this->dieOnNoMethod($method, 'set expected arguments');
  926.         $this->checkArgumentsIsArray($args, 'set expected arguments');
  927.         $this->expectations->expectArguments($method, $args, $message);
  928.         $args = $this->replaceWildcards($args);
  929.         $message .= Mock::getExpectationLine();
  930.         $this->expected_args[strtolower($method)] =
  931.                 new ParametersExpectation($args, $message);
  932.     }
  933.  
  934.     /**
  935.      *    Sets up an expected call with a set of
  936.      *    expected parameters in that call. The
  937.      *    expected call count will be adjusted if it
  938.      *    is set too low to reach this call.
  939.      *    @param integer $timing    Number of calls in the future at
  940.      *                               which to test. Next call is 0.
  941.      *    @param string $method     Method call to test.
  942.      *    @param array $args        Expected parameters for the call
  943.      *                               including wildcards.
  944.      *    @param string $message    Overridden message.
  945.      *    @access public
  946.      */
  947.     function expectAt($timing, $method, $args, $message = '%s') {
  948.         $this->dieOnNoMethod($method, 'set expected arguments at time');
  949.         $this->checkArgumentsIsArray($args, 'set expected arguments at time');
  950.         $args = $this->replaceWildcards($args);
  951.         if (! isset($this->expected_args_at[$timing])) {
  952.             $this->expected_args_at[$timing] = array();
  953.         }
  954.         $method = strtolower($method);
  955.         $message .= Mock::getExpectationLine();
  956.         $this->expected_args_at[$timing][$method] =
  957.                 new ParametersExpectation($args, $message);
  958.     }
  959.  
  960.     /**
  961.      *    Sets an expectation for the number of times
  962.      *    a method will be called. The tally method
  963.      *    is used to check this.
  964.      *    @param string $method        Method call to test.
  965.      *    @param integer $count        Number of times it should
  966.      *                                  have been called at tally.
  967.      *    @param string $message       Overridden message.
  968.      *    @access public
  969.      */
  970.     function expectCallCount($method, $count, $message = '%s') {
  971.         $this->dieOnNoMethod($method, 'set expected call count');
  972.         $message .= Mock::getExpectationLine();
  973.         $this->expected_counts[strtolower($method)] =
  974.                 new CallCountExpectation($method, $count, $message);
  975.     }
  976.  
  977.     /**
  978.      *    Sets the number of times a method may be called
  979.      *    before a test failure is triggered.
  980.      *    @param string $method        Method call to test.
  981.      *    @param integer $count        Most number of times it should
  982.      *                                  have been called.
  983.      *    @param string $message       Overridden message.
  984.      *    @access public
  985.      */
  986.     function expectMaximumCallCount($method, $count, $message = '%s') {
  987.         $this->dieOnNoMethod($method, 'set maximum call count');
  988.         $message .= Mock::getExpectationLine();
  989.         $this->max_counts[strtolower($method)] =
  990.                 new MaximumCallCountExpectation($method, $count, $message);
  991.     }
  992.  
  993.     /**
  994.      *    Sets the number of times to call a method to prevent
  995.      *    a failure on the tally.
  996.      *    @param string $method      Method call to test.
  997.      *    @param integer $count      Least number of times it should
  998.      *                                have been called.
  999.      *    @param string $message     Overridden message.
  1000.      *    @access public
  1001.      */
  1002.     function expectMinimumCallCount($method, $count, $message = '%s') {
  1003.         $this->dieOnNoMethod($method, 'set minimum call count');
  1004.         $message .= Mock::getExpectationLine();
  1005.         $this->expected_counts[strtolower($method)] =
  1006.                 new MinimumCallCountExpectation($method, $count, $message);
  1007.     }
  1008.  
  1009.     /**
  1010.      *    Convenience method for barring a method
  1011.      *    call.
  1012.      *    @param string $method        Method call to ban.
  1013.      *    @param string $message       Overridden message.
  1014.      *    @access public
  1015.      */
  1016.     function expectNever($method, $message = '%s') {
  1017.         $this->expectMaximumCallCount($method, 0, $message);
  1018.     }
  1019.  
  1020.     /**
  1021.      *    Convenience method for a single method
  1022.      *    call.
  1023.      *    @param string $method     Method call to track.
  1024.      *    @param array $args        Expected argument list or
  1025.      *                               false for any arguments.
  1026.      *    @param string $message    Overridden message.
  1027.      *    @access public
  1028.      */
  1029.     function expectOnce($method, $args = false, $message = '%s') {
  1030.         $this->expectCallCount($method, 1, $message);
  1031.         if ($args !== false) {
  1032.             $this->expect($method, $args, $message);
  1033.         }
  1034.     }
  1035.  
  1036.     /**
  1037.      *    Convenience method for requiring a method
  1038.      *    call.
  1039.      *    @param string $method       Method call to track.
  1040.      *    @param array $args          Expected argument list or
  1041.      *                                 false for any arguments.
  1042.      *    @param string $message      Overridden message.
  1043.      *    @access public
  1044.      */
  1045.     function expectAtLeastOnce($method, $args = false, $message = '%s') {
  1046.         $this->expectMinimumCallCount($method, 1, $message);
  1047.         if ($args !== false) {
  1048.             $this->expect($method, $args, $message);
  1049.         }
  1050.     }
  1051.     
  1052.     /**
  1053.      *    Sets up a trigger to throw an exception upon the
  1054.      *    method call.
  1055.      *    @param string $method     Method name to throw on.
  1056.      */
  1057.     function throwOn($method, $exception = false, $args = false) {
  1058.         $this->dieOnNoMethod($method, "throw on");
  1059.         $this->actions->register($method, $args,
  1060.                 new SimpleThrower($exception ? $exception : new Exception()));
  1061.     }
  1062.     
  1063.     /**
  1064.      *    Sets up a trigger to throw an exception upon the
  1065.      *    method call.
  1066.      */
  1067.     function throwAt($timing, $method, $exception = false, $args = false) {
  1068.         $this->dieOnNoMethod($method, "throw at");
  1069.         $this->actions->registerAt($timing, $method, $args,
  1070.                 new SimpleThrower($exception ? $exception : new Exception()));
  1071.     }
  1072.     
  1073.     /**
  1074.      *    Sets up a trigger to throw an error upon the
  1075.      *    method call.
  1076.      */
  1077.     function errorOn($method, $error = 'A mock error', $args = false, $severity = E_USER_ERROR) {
  1078.         $this->dieOnNoMethod($method, "error on");
  1079.         $this->actions->register($method, $args, new SimpleErrorThrower($error, $severity));
  1080.     }
  1081.     
  1082.     /**
  1083.      *    Sets up a trigger to throw an error upon the
  1084.      *    method call.
  1085.      */
  1086.     function errorAt($timing, $method, $error = 'A mock error', $args = false, $severity = E_USER_ERROR) {
  1087.         $this->dieOnNoMethod($method, "error at");
  1088.         $this->actions->registerAt($timing, $method, $args, new SimpleErrorThrower($error, $severity));
  1089.     }
  1090.  
  1091.     /**
  1092.      *    Receives event from unit test that the current
  1093.      *    test method has finished. Totals up the call
  1094.      *    counts and triggers a test assertion if a test
  1095.      *    is present for expected call counts.
  1096.      *    @param string $test_method      Current method name.
  1097.      *    @param SimpleTestCase $test     Test to send message to.
  1098.      *    @access public
  1099.      */
  1100.     function atTestEnd($test_method, &$test) {
  1101.         foreach ($this->expected_counts as $method => $expectation) {
  1102.             $test->assert($expectation, $this->getCallCount($method));
  1103.         }
  1104.         foreach ($this->max_counts as $method => $expectation) {
  1105.             if ($expectation->test($this->getCallCount($method))) {
  1106.                 $test->assert($expectation, $this->getCallCount($method));
  1107.             }
  1108.         }
  1109.     }
  1110.  
  1111.     /**
  1112.      *    Returns the expected value for the method name
  1113.      *    and checks expectations. Will generate any
  1114.      *    test assertions as a result of expectations
  1115.      *    if there is a test present.
  1116.      *    @param string $method       Name of method to simulate.
  1117.      *    @param array $args          Arguments as an array.
  1118.      *    @return mixed               Stored return.
  1119.      *    @access private
  1120.      */
  1121.     function &invoke($method, $args) {
  1122.         $method = strtolower($method);
  1123.         $step = $this->getCallCount($method);
  1124.         $this->addCall($method, $args);
  1125.         $this->checkExpectations($method, $args, $step);
  1126.         $was = $this->disableEStrict();
  1127.         try {
  1128.             $result = &$this->emulateCall($method, $args, $step);
  1129.         } catch (Exception $e) {
  1130.             $this->restoreEStrict($was);
  1131.             throw $e;
  1132.         }
  1133.         $this->restoreEStrict($was);
  1134.         return $result;
  1135.     }
  1136.     
  1137.     /**
  1138.      *    Finds the return value matching the incoming
  1139.      *    arguments. If there is no matching value found
  1140.      *    then an error is triggered.
  1141.      *    @param string $method      Method name.
  1142.      *    @param array $args         Calling arguments.
  1143.      *    @param integer $step       Current position in the
  1144.      *                                call history.
  1145.      *    @return mixed              Stored return or other action.
  1146.      *    @access protected
  1147.      */
  1148.     protected function &emulateCall($method, $args, $step) {
  1149.         return $this->actions->respond($step, $method, $args);
  1150.     }
  1151.  
  1152.     /**
  1153.      *    Tests the arguments against expectations.
  1154.      *    @param string $method        Method to check.
  1155.      *    @param array $args           Argument list to match.
  1156.      *    @param integer $timing       The position of this call
  1157.      *                                  in the call history.
  1158.      *    @access private
  1159.      */
  1160.     protected function checkExpectations($method, $args, $timing) {
  1161.         $test = $this->getCurrentTestCase();
  1162.         if (isset($this->max_counts[$method])) {
  1163.             if (! $this->max_counts[$method]->test($timing + 1)) {
  1164.                 $test->assert($this->max_counts[$method], $timing + 1);
  1165.             }
  1166.         }
  1167.         if (isset($this->expected_args_at[$timing][$method])) {
  1168.             $test->assert(
  1169.                     $this->expected_args_at[$timing][$method],
  1170.                     $args,
  1171.                     "Mock method [$method] at [$timing] -> %s");
  1172.         } elseif (isset($this->expected_args[$method])) {
  1173.             $test->assert(
  1174.                     $this->expected_args[$method],
  1175.                     $args,
  1176.                     "Mock method [$method] -> %s");
  1177.         }
  1178.     }
  1179.     
  1180.     private function disableEStrict() {
  1181.         $was = error_reporting();
  1182.         error_reporting($was & ~E_STRICT);
  1183.         return $was;
  1184.     }
  1185.     
  1186.     private function restoreEStrict($was) {
  1187.         error_reporting($was);
  1188.     }
  1189. }
  1190.  
  1191. /**
  1192.  *    Static methods only service class for code generation of
  1193.  *    mock objects.
  1194.  *    @package SimpleTest
  1195.  *    @subpackage MockObjects
  1196.  */
  1197. class Mock {
  1198.  
  1199.     /**
  1200.      *    Factory for mock object classes.
  1201.      *    @access public
  1202.      */
  1203.     function __construct() {
  1204.         trigger_error('Mock factory methods are static.');
  1205.     }
  1206.  
  1207.     /**
  1208.      *    Clones a class' interface and creates a mock version
  1209.      *    that can have return values and expectations set.
  1210.      *    @param string $class         Class to clone.
  1211.      *    @param string $mock_class    New class name. Default is
  1212.      *                                  the old name with "Mock"
  1213.      *                                  prepended.
  1214.      *    @param array $methods        Additional methods to add beyond
  1215.      *                                  those in the cloned class. Use this
  1216.      *                                  to emulate the dynamic addition of
  1217.      *                                  methods in the cloned class or when
  1218.      *                                  the class hasn't been written yet.sta
  1219.      *    @access public
  1220.      */
  1221.     static function generate($class, $mock_class = false, $methods = false) {
  1222.         $generator = new MockGenerator($class, $mock_class);
  1223.         return @$generator->generateSubclass($methods);
  1224.     }
  1225.  
  1226.     /**
  1227.      *    Generates a version of a class with selected
  1228.      *    methods mocked only. Inherits the old class
  1229.      *    and chains the mock methods of an aggregated
  1230.      *    mock object.
  1231.      *    @param string $class            Class to clone.
  1232.      *    @param string $mock_class       New class name.
  1233.      *    @param array $methods           Methods to be overridden
  1234.      *                                     with mock versions.
  1235.      *    @access public
  1236.      */
  1237.     static function generatePartial($class, $mock_class, $methods) {
  1238.         $generator = new MockGenerator($class, $mock_class);
  1239.         return @$generator->generatePartial($methods);
  1240.     }
  1241.  
  1242.     /**
  1243.      *    Uses a stack trace to find the line of an assertion.
  1244.      *    @access public
  1245.      */
  1246.     static function getExpectationLine() {
  1247.         $trace = new SimpleStackTrace(array('expect'));
  1248.         return $trace->traceMethod();
  1249.     }
  1250. }
  1251.  
  1252. /**
  1253.  *    Service class for code generation of mock objects.
  1254.  *    @package SimpleTest
  1255.  *    @subpackage MockObjects
  1256.  */
  1257. class MockGenerator {
  1258.     private $class;
  1259.     private $mock_class;
  1260.     private $mock_base;
  1261.     private $reflection;
  1262.  
  1263.     /**
  1264.      *    Builds initial reflection object.
  1265.      *    @param string $class        Class to be mocked.
  1266.      *    @param string $mock_class   New class with identical interface,
  1267.      *                                 but no behaviour.
  1268.      */
  1269.     function __construct($class, $mock_class) {
  1270.         $this->class = $class;
  1271.         $this->mock_class = $mock_class;
  1272.         if (! $this->mock_class) {
  1273.             $this->mock_class = 'Mock' . $this->class;
  1274.         }
  1275.         $this->mock_base = SimpleTest::getMockBaseClass();
  1276.         $this->reflection = new SimpleReflection($this->class);
  1277.     }
  1278.  
  1279.     /**
  1280.      *    Clones a class' interface and creates a mock version
  1281.      *    that can have return values and expectations set.
  1282.      *    @param array $methods        Additional methods to add beyond
  1283.      *                                  those in th cloned class. Use this
  1284.      *                                  to emulate the dynamic addition of
  1285.      *                                  methods in the cloned class or when
  1286.      *                                  the class hasn't been written yet.
  1287.      *    @access public
  1288.      */
  1289.     function generate($methods) {
  1290.         if (! $this->reflection->classOrInterfaceExists()) {
  1291.             return false;
  1292.         }
  1293.         $mock_reflection = new SimpleReflection($this->mock_class);
  1294.         if ($mock_reflection->classExistsSansAutoload()) {
  1295.             return false;
  1296.         }
  1297.         $code = $this->createClassCode($methods ? $methods : array());
  1298.         return eval("$code return \$code;");
  1299.     }
  1300.     
  1301.     /**
  1302.      *    Subclasses a class and overrides every method with a mock one
  1303.      *    that can have return values and expectations set. Chains
  1304.      *    to an aggregated SimpleMock.
  1305.      *    @param array $methods        Additional methods to add beyond
  1306.      *                                  those in the cloned class. Use this
  1307.      *                                  to emulate the dynamic addition of
  1308.      *                                  methods in the cloned class or when
  1309.      *                                  the class hasn't been written yet.
  1310.      *    @access public
  1311.      */
  1312.     function generateSubclass($methods) {
  1313.         if (! $this->reflection->classOrInterfaceExists()) {
  1314.             return false;
  1315.         }
  1316.         $mock_reflection = new SimpleReflection($this->mock_class);
  1317.         if ($mock_reflection->classExistsSansAutoload()) {
  1318.             return false;
  1319.         }
  1320.         if ($this->reflection->isInterface() || $this->reflection->hasFinal()) {
  1321.             $code = $this->createClassCode($methods ? $methods : array());
  1322.             return eval("$code return \$code;");
  1323.         } else {
  1324.             $code = $this->createSubclassCode($methods ? $methods : array());
  1325.             return eval("$code return \$code;");
  1326.         }
  1327.     }
  1328.  
  1329.     /**
  1330.      *    Generates a version of a class with selected
  1331.      *    methods mocked only. Inherits the old class
  1332.      *    and chains the mock methods of an aggregated
  1333.      *    mock object.
  1334.      *    @param array $methods           Methods to be overridden
  1335.      *                                     with mock versions.
  1336.      *    @access public
  1337.      */
  1338.     function generatePartial($methods) {
  1339.         if (! $this->reflection->classExists($this->class)) {
  1340.             return false;
  1341.         }
  1342.         $mock_reflection = new SimpleReflection($this->mock_class);
  1343.         if ($mock_reflection->classExistsSansAutoload()) {
  1344.             trigger_error('Partial mock class [' . $this->mock_class . '] already exists');
  1345.             return false;
  1346.         }
  1347.         $code = $this->extendClassCode($methods);
  1348.         return eval("$code return \$code;");
  1349.     }
  1350.  
  1351.     /**
  1352.      *    The new mock class code as a string.
  1353.      *    @param array $methods          Additional methods.
  1354.      *    @return string                 Code for new mock class.
  1355.      *    @access private
  1356.      */
  1357.     protected function createClassCode($methods) {
  1358.         $implements = '';
  1359.         $interfaces = $this->reflection->getInterfaces();
  1360.         if (function_exists('spl_classes')) {
  1361.             $interfaces = array_diff($interfaces, array('Traversable'));
  1362.         }
  1363.         if (count($interfaces) > 0) {
  1364.             $implements = 'implements ' . implode(', ', $interfaces);
  1365.         }
  1366.         $code = "class " . $this->mock_class . " extends " . $this->mock_base . " $implements {\n";
  1367.         $code .= "    function " . $this->mock_class . "() {\n";
  1368.         $code .= "        \$this->" . $this->mock_base . "();\n";
  1369.         $code .= "    }\n";
  1370.         if (in_array('__construct', $this->reflection->getMethods())) {
  1371.             $code .= "    function __construct() {\n";
  1372.             $code .= "        \$this->" . $this->mock_base . "();\n";
  1373.             $code .= "    }\n";
  1374.         }
  1375.         $code .= $this->createHandlerCode($methods);
  1376.         $code .= "}\n";
  1377.         return $code;
  1378.     }
  1379.  
  1380.     /**
  1381.      *    The new mock class code as a string. The mock will
  1382.      *    be a subclass of the original mocked class.
  1383.      *    @param array $methods          Additional methods.
  1384.      *    @return string                 Code for new mock class.
  1385.      *    @access private
  1386.      */
  1387.     protected function createSubclassCode($methods) {
  1388.         $code  = "class " . $this->mock_class . " extends " . $this->class . " {\n";
  1389.         $code .= "    public \$mock;\n";
  1390.         $code .= $this->addMethodList(array_merge($methods, $this->reflection->getMethods()));
  1391.         $code .= "\n";
  1392.         $code .= "    function " . $this->mock_class . "() {\n";
  1393.         $code .= "        \$this->mock = new " . $this->mock_base . "();\n";
  1394.         $code .= "        \$this->mock->disableExpectationNameChecks();\n";
  1395.         $code .= "    }\n";
  1396.         $code .= $this->chainMockReturns();
  1397.         $code .= $this->chainMockExpectations();
  1398.         $code .= $this->chainThrowMethods();
  1399.         $code .= $this->overrideMethods($this->reflection->getMethods());
  1400.         $code .= $this->createNewMethodCode($methods);
  1401.         $code .= "}\n";
  1402.         return $code;
  1403.     }
  1404.  
  1405.     /**
  1406.      *    The extension class code as a string. The class
  1407.      *    composites a mock object and chains mocked methods
  1408.      *    to it.
  1409.      *    @param array  $methods       Mocked methods.
  1410.      *    @return string               Code for a new class.
  1411.      *    @access private
  1412.      */
  1413.     protected function extendClassCode($methods) {
  1414.         $code  = "class " . $this->mock_class . " extends " . $this->class . " {\n";
  1415.         $code .= "    protected \$mock;\n";
  1416.         $code .= $this->addMethodList($methods);
  1417.         $code .= "\n";
  1418.         $code .= "    function " . $this->mock_class . "() {\n";
  1419.         $code .= "        \$this->mock = new " . $this->mock_base . "();\n";
  1420.         $code .= "        \$this->mock->disableExpectationNameChecks();\n";
  1421.         $code .= "    }\n";
  1422.         $code .= $this->chainMockReturns();
  1423.         $code .= $this->chainMockExpectations();
  1424.         $code .= $this->chainThrowMethods();
  1425.         $code .= $this->overrideMethods($methods);
  1426.         $code .= "}\n";
  1427.         return $code;
  1428.     }
  1429.  
  1430.     /**
  1431.      *    Creates code within a class to generate replaced
  1432.      *    methods. All methods call the invoke() handler
  1433.      *    with the method name and the arguments in an
  1434.      *    array.
  1435.      *    @param array $methods    Additional methods.
  1436.      *    @access private
  1437.      */
  1438.     protected function createHandlerCode($methods) {
  1439.         $code = '';
  1440.         $methods = array_merge($methods, $this->reflection->getMethods());
  1441.         foreach ($methods as $method) {
  1442.             if ($this->isConstructor($method)) {
  1443.                 continue;
  1444.             }
  1445.             $mock_reflection = new SimpleReflection($this->mock_base);
  1446.             if (in_array($method, $mock_reflection->getMethods())) {
  1447.                 continue;
  1448.             }
  1449.             $code .= "    " . $this->reflection->getSignature($method) . " {\n";
  1450.             $code .= "        \$args = func_get_args();\n";
  1451.             $code .= "        \$result = &\$this->invoke(\"$method\", \$args);\n";
  1452.             $code .= "        return \$result;\n";
  1453.             $code .= "    }\n";
  1454.         }
  1455.         return $code;
  1456.     }
  1457.  
  1458.     /**
  1459.      *    Creates code within a class to generate a new
  1460.      *    methods. All methods call the invoke() handler
  1461.      *    on the internal mock with the method name and
  1462.      *    the arguments in an array.
  1463.      *    @param array $methods    Additional methods.
  1464.      *    @access private
  1465.      */
  1466.     protected function createNewMethodCode($methods) {
  1467.         $code = '';
  1468.         foreach ($methods as $method) {
  1469.             if ($this->isConstructor($method)) {
  1470.                 continue;
  1471.             }
  1472.             $mock_reflection = new SimpleReflection($this->mock_base);
  1473.             if (in_array($method, $mock_reflection->getMethods())) {
  1474.                 continue;
  1475.             }
  1476.             $code .= "    " . $this->reflection->getSignature($method) . " {\n";
  1477.             $code .= "        \$args = func_get_args();\n";
  1478.             $code .= "        \$result = &\$this->mock->invoke(\"$method\", \$args);\n";
  1479.             $code .= "        return \$result;\n";
  1480.             $code .= "    }\n";
  1481.         }
  1482.         return $code;
  1483.     }
  1484.  
  1485.     /**
  1486.      *    Tests to see if a special PHP method is about to
  1487.      *    be stubbed by mistake.
  1488.      *    @param string $method    Method name.
  1489.      *    @return boolean          True if special.
  1490.      *    @access private
  1491.      */
  1492.     protected function isConstructor($method) {
  1493.         return in_array(
  1494.                 strtolower($method),
  1495.                 array('__construct', '__destruct'));
  1496.     }
  1497.  
  1498.     /**
  1499.      *    Creates a list of mocked methods for error checking.
  1500.      *    @param array $methods       Mocked methods.
  1501.      *    @return string              Code for a method list.
  1502.      *    @access private
  1503.      */
  1504.     protected function addMethodList($methods) {
  1505.         return "    protected \$mocked_methods = array('" .
  1506.                 implode("', '", array_map('strtolower', $methods)) .
  1507.                 "');\n";
  1508.     }
  1509.  
  1510.     /**
  1511.      *    Creates code to abandon the expectation if not mocked.
  1512.      *    @param string $alias       Parameter name of method name.
  1513.      *    @return string             Code for bail out.
  1514.      *    @access private
  1515.      */
  1516.     protected function bailOutIfNotMocked($alias) {
  1517.         $code  = "        if (! in_array(strtolower($alias), \$this->mocked_methods)) {\n";
  1518.         $code .= "            trigger_error(\"Method [$alias] is not mocked\");\n";
  1519.         $code .= "            \$null = null;\n";
  1520.         $code .= "            return \$null;\n";
  1521.         $code .= "        }\n";
  1522.         return $code;
  1523.     }
  1524.  
  1525.     /**
  1526.      *    Creates source code for chaining to the composited
  1527.      *    mock object.
  1528.      *    @return string           Code for mock set up.
  1529.      *    @access private
  1530.      */
  1531.     protected function chainMockReturns() {
  1532.         $code  = "    function returns(\$method, \$value, \$args = false) {\n";
  1533.         $code .= $this->bailOutIfNotMocked("\$method");
  1534.         $code .= "        \$this->mock->returns(\$method, \$value, \$args);\n";
  1535.         $code .= "    }\n";
  1536.         $code .= "    function returnsAt(\$timing, \$method, \$value, \$args = false) {\n";
  1537.         $code .= $this->bailOutIfNotMocked("\$method");
  1538.         $code .= "        \$this->mock->returnsAt(\$timing, \$method, \$value, \$args);\n";
  1539.         $code .= "    }\n";
  1540.         $code .= "    function returnsByValue(\$method, \$value, \$args = false) {\n";
  1541.         $code .= $this->bailOutIfNotMocked("\$method");
  1542.         $code .= "        \$this->mock->setReturnValue(\$method, \$value, \$args);\n";
  1543.         $code .= "    }\n";
  1544.         $code .= "    function returnsByValueAt(\$timing, \$method, \$value, \$args = false) {\n";
  1545.         $code .= $this->bailOutIfNotMocked("\$method");
  1546.         $code .= "        \$this->mock->setReturnValueAt(\$timing, \$method, \$value, \$args);\n";
  1547.         $code .= "    }\n";
  1548.         $code .= "    function returnsByReference(\$method, &\$ref, \$args = false) {\n";
  1549.         $code .= $this->bailOutIfNotMocked("\$method");
  1550.         $code .= "        \$this->mock->setReturnReference(\$method, \$ref, \$args);\n";
  1551.         $code .= "    }\n";
  1552.         $code .= "    function returnsByReferenceAt(\$timing, \$method, &\$ref, \$args = false) {\n";
  1553.         $code .= $this->bailOutIfNotMocked("\$method");
  1554.         $code .= "        \$this->mock->setReturnReferenceAt(\$timing, \$method, \$ref, \$args);\n";
  1555.         $code .= "    }\n";
  1556.         $code .= "    function setReturnValue(\$method, \$value, \$args = false) {\n";
  1557.         $code .= $this->bailOutIfNotMocked("\$method");
  1558.         $code .= "        \$this->mock->setReturnValue(\$method, \$value, \$args);\n";
  1559.         $code .= "    }\n";
  1560.         $code .= "    function setReturnValueAt(\$timing, \$method, \$value, \$args = false) {\n";
  1561.         $code .= $this->bailOutIfNotMocked("\$method");
  1562.         $code .= "        \$this->mock->setReturnValueAt(\$timing, \$method, \$value, \$args);\n";
  1563.         $code .= "    }\n";
  1564.         $code .= "    function setReturnReference(\$method, &\$ref, \$args = false) {\n";
  1565.         $code .= $this->bailOutIfNotMocked("\$method");
  1566.         $code .= "        \$this->mock->setReturnReference(\$method, \$ref, \$args);\n";
  1567.         $code .= "    }\n";
  1568.         $code .= "    function setReturnReferenceAt(\$timing, \$method, &\$ref, \$args = false) {\n";
  1569.         $code .= $this->bailOutIfNotMocked("\$method");
  1570.         $code .= "        \$this->mock->setReturnReferenceAt(\$timing, \$method, \$ref, \$args);\n";
  1571.         $code .= "    }\n";
  1572.         return $code;
  1573.     }
  1574.  
  1575.     /**
  1576.      *    Creates source code for chaining to an aggregated
  1577.      *    mock object.
  1578.      *    @return string                 Code for expectations.
  1579.      *    @access private
  1580.      */
  1581.     protected function chainMockExpectations() {
  1582.         $code  = "    function expect(\$method, \$args = false, \$msg = '%s') {\n";
  1583.         $code .= $this->bailOutIfNotMocked("\$method");
  1584.         $code .= "        \$this->mock->expect(\$method, \$args, \$msg);\n";
  1585.         $code .= "    }\n";
  1586.         $code .= "    function expectAt(\$timing, \$method, \$args = false, \$msg = '%s') {\n";
  1587.         $code .= $this->bailOutIfNotMocked("\$method");
  1588.         $code .= "        \$this->mock->expectAt(\$timing, \$method, \$args, \$msg);\n";
  1589.         $code .= "    }\n";
  1590.         $code .= "    function expectCallCount(\$method, \$count) {\n";
  1591.         $code .= $this->bailOutIfNotMocked("\$method");
  1592.         $code .= "        \$this->mock->expectCallCount(\$method, \$count, \$msg = '%s');\n";
  1593.         $code .= "    }\n";
  1594.         $code .= "    function expectMaximumCallCount(\$method, \$count, \$msg = '%s') {\n";
  1595.         $code .= $this->bailOutIfNotMocked("\$method");
  1596.         $code .= "        \$this->mock->expectMaximumCallCount(\$method, \$count, \$msg = '%s');\n";
  1597.         $code .= "    }\n";
  1598.         $code .= "    function expectMinimumCallCount(\$method, \$count, \$msg = '%s') {\n";
  1599.         $code .= $this->bailOutIfNotMocked("\$method");
  1600.         $code .= "        \$this->mock->expectMinimumCallCount(\$method, \$count, \$msg = '%s');\n";
  1601.         $code .= "    }\n";
  1602.         $code .= "    function expectNever(\$method) {\n";
  1603.         $code .= $this->bailOutIfNotMocked("\$method");
  1604.         $code .= "        \$this->mock->expectNever(\$method);\n";
  1605.         $code .= "    }\n";
  1606.         $code .= "    function expectOnce(\$method, \$args = false, \$msg = '%s') {\n";
  1607.         $code .= $this->bailOutIfNotMocked("\$method");
  1608.         $code .= "        \$this->mock->expectOnce(\$method, \$args, \$msg);\n";
  1609.         $code .= "    }\n";
  1610.         $code .= "    function expectAtLeastOnce(\$method, \$args = false, \$msg = '%s') {\n";
  1611.         $code .= $this->bailOutIfNotMocked("\$method");
  1612.         $code .= "        \$this->mock->expectAtLeastOnce(\$method, \$args, \$msg);\n";
  1613.         $code .= "    }\n";
  1614.         return $code;
  1615.     }
  1616.     
  1617.     /**
  1618.      *    Adds code for chaining the throw methods.
  1619.      *    @return string           Code for chains.
  1620.      *    @access private
  1621.      */
  1622.     protected function chainThrowMethods() {
  1623.         $code  = "    function throwOn(\$method, \$exception = false, \$args = false) {\n";
  1624.         $code .= $this->bailOutIfNotMocked("\$method");
  1625.         $code .= "        \$this->mock->throwOn(\$method, \$exception, \$args);\n";
  1626.         $code .= "    }\n";
  1627.         $code .= "    function throwAt(\$timing, \$method, \$exception = false, \$args = false) {\n";
  1628.         $code .= $this->bailOutIfNotMocked("\$method");
  1629.         $code .= "        \$this->mock->throwAt(\$timing, \$method, \$exception, \$args);\n";
  1630.         $code .= "    }\n";
  1631.         $code .= "    function errorOn(\$method, \$error = 'A mock error', \$args = false, \$severity = E_USER_ERROR) {\n";
  1632.         $code .= $this->bailOutIfNotMocked("\$method");
  1633.         $code .= "        \$this->mock->errorOn(\$method, \$error, \$args, \$severity);\n";
  1634.         $code .= "    }\n";
  1635.         $code .= "    function errorAt(\$timing, \$method, \$error = 'A mock error', \$args = false, \$severity = E_USER_ERROR) {\n";
  1636.         $code .= $this->bailOutIfNotMocked("\$method");
  1637.         $code .= "        \$this->mock->errorAt(\$timing, \$method, \$error, \$args, \$severity);\n";
  1638.         $code .= "    }\n";
  1639.         return $code;
  1640.     }
  1641.  
  1642.     /**
  1643.      *    Creates source code to override a list of methods
  1644.      *    with mock versions.
  1645.      *    @param array $methods    Methods to be overridden
  1646.      *                              with mock versions.
  1647.      *    @return string           Code for overridden chains.
  1648.      *    @access private
  1649.      */
  1650.     protected function overrideMethods($methods) {
  1651.         $code = "";
  1652.         foreach ($methods as $method) {
  1653.             if ($this->isConstructor($method)) {
  1654.                 continue;
  1655.             }
  1656.             $code .= "    " . $this->reflection->getSignature($method) . " {\n";
  1657.             $code .= "        \$args = func_get_args();\n";
  1658.             $code .= "        \$result = &\$this->mock->invoke(\"$method\", \$args);\n";
  1659.             $code .= "        return \$result;\n";
  1660.             $code .= "    }\n";
  1661.         }
  1662.         return $code;
  1663.     }
  1664. }
  1665. ?>

Documentation generated on Thu, 01 Oct 2009 20:55:11 -0500 by phpDocumentor 1.4.2