Added simpletest and start of unit tests.

git-svn-id: http://code.elgg.org/elgg/trunk@3503 36083f99-b078-4883-b0ff-0f9b5a30f544

1 files changed, 1581 insertions, 0 deletions

diff --git a/vendors/simpletest/mock_objects.php b/vendors/simpletest/mock_objects.php
new file mode 100755
index 000000000..5ef15751d
--- /dev/null
+++ b/vendors/simpletest/mock_objects.php
@@ -0,0 +1,1581 @@
+<?php
+/**
+ *  base include file for SimpleTest
+ *  @package    SimpleTest
+ *  @subpackage MockObjects
+ *  @version    $Id: mock_objects.php 1672 2008-03-02 04:47:34Z edwardzyang $
+ */
+
+/**#@+
+ * include SimpleTest files
+ */
+require_once(dirname(__FILE__) . '/expectation.php');
+require_once(dirname(__FILE__) . '/simpletest.php');
+require_once(dirname(__FILE__) . '/dumper.php');
+if (version_compare(phpversion(), '5') >= 0) {
+    require_once(dirname(__FILE__) . '/reflection_php5.php');
+} else {
+    require_once(dirname(__FILE__) . '/reflection_php4.php');
+}
+/**#@-*/
+
+/**
+ * Default character simpletest will substitute for any value
+ */
+if (! defined('MOCK_ANYTHING')) {
+    define('MOCK_ANYTHING', '*');
+}
+
+/**
+ *    Parameter comparison assertion.
+ *    @package SimpleTest
+ *    @subpackage MockObjects
+ */
+class ParametersExpectation extends SimpleExpectation {
+    var $_expected;
+
+    /**
+     *    Sets the expected parameter list.
+     *    @param array $parameters  Array of parameters including
+     *                              those that are wildcarded.
+     *                              If the value is not an array
+     *                              then it is considered to match any.
+     *    @param string $message    Customised message on failure.
+     *    @access public
+     */
+    function ParametersExpectation($expected = false, $message = '%s') {
+        $this->SimpleExpectation($message);
+        $this->_expected = $expected;
+    }
+
+    /**
+     *    Tests the assertion. True if correct.
+     *    @param array $parameters     Comparison values.
+     *    @return boolean              True if correct.
+     *    @access public
+     */
+    function test($parameters) {
+        if (! is_array($this->_expected)) {
+            return true;
+        }
+        if (count($this->_expected) != count($parameters)) {
+            return false;
+        }
+        for ($i = 0; $i < count($this->_expected); $i++) {
+            if (! $this->_testParameter($parameters[$i], $this->_expected[$i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     *    Tests an individual parameter.
+     *    @param mixed $parameter    Value to test.
+     *    @param mixed $expected     Comparison value.
+     *    @return boolean            True if expectation
+     *                               fulfilled.
+     *    @access private
+     */
+    function _testParameter($parameter, $expected) {
+        $comparison = $this->_coerceToExpectation($expected);
+        return $comparison->test($parameter);
+    }
+
+    /**
+     *    Returns a human readable test message.
+     *    @param array $comparison   Incoming parameter list.
+     *    @return string             Description of success
+     *                               or failure.
+     *    @access public
+     */
+    function testMessage($parameters) {
+        if ($this->test($parameters)) {
+            return "Expectation of " . count($this->_expected) .
+                    " arguments of [" . $this->_renderArguments($this->_expected) .
+                    "] is correct";
+        } else {
+            return $this->_describeDifference($this->_expected, $parameters);
+        }
+    }
+
+    /**
+     *    Message to display if expectation differs from
+     *    the parameters actually received.
+     *    @param array $expected      Expected parameters as list.
+     *    @param array $parameters    Actual parameters received.
+     *    @return string              Description of difference.
+     *    @access private
+     */
+    function _describeDifference($expected, $parameters) {
+        if (count($expected) != count($parameters)) {
+            return "Expected " . count($expected) .
+                    " arguments of [" . $this->_renderArguments($expected) .
+                    "] but got " . count($parameters) .
+                    " arguments of [" . $this->_renderArguments($parameters) . "]";
+        }
+        $messages = array();
+        for ($i = 0; $i < count($expected); $i++) {
+            $comparison = $this->_coerceToExpectation($expected[$i]);
+            if (! $comparison->test($parameters[$i])) {
+                $messages[] = "parameter " . ($i + 1) . " with [" .
+                        $comparison->overlayMessage($parameters[$i], $this->_getDumper()) . "]";
+            }
+        }
+        return "Parameter expectation differs at " . implode(" and ", $messages);
+    }
+
+    /**
+     *    Creates an identical expectation if the
+     *    object/value is not already some type
+     *    of expectation.
+     *    @param mixed $expected      Expected value.
+     *    @return SimpleExpectation   Expectation object.
+     *    @access private
+     */
+    function _coerceToExpectation($expected) {
+        if (SimpleExpectation::isExpectation($expected)) {
+            return $expected;
+        }
+        return new IdenticalExpectation($expected);
+    }
+
+    /**
+     *    Renders the argument list as a string for
+     *    messages.
+     *    @param array $args    Incoming arguments.
+     *    @return string        Simple description of type and value.
+     *    @access private
+     */
+    function _renderArguments($args) {
+        $descriptions = array();
+        if (is_array($args)) {
+            foreach ($args as $arg) {
+                $dumper = &new SimpleDumper();
+                $descriptions[] = $dumper->describeValue($arg);
+            }
+        }
+        return implode(', ', $descriptions);
+    }
+}
+
+/**
+ *    Confirms that the number of calls on a method is as expected.
+ *  @package    SimpleTest
+ *  @subpackage MockObjects
+ */
+class CallCountExpectation extends SimpleExpectation {
+    var $_method;
+    var $_count;
+
+    /**
+     *    Stashes the method and expected count for later
+     *    reporting.
+     *    @param string $method    Name of method to confirm against.
+     *    @param integer $count    Expected number of calls.
+     *    @param string $message   Custom error message.
+     */
+    function CallCountExpectation($method, $count, $message = '%s') {
+        $this->_method = $method;
+        $this->_count = $count;
+        $this->SimpleExpectation($message);
+    }
+
+    /**
+     *    Tests the assertion. True if correct.
+     *    @param integer $compare     Measured call count.
+     *    @return boolean             True if expected.
+     *    @access public
+     */
+    function test($compare) {
+        return ($this->_count == $compare);
+    }
+
+    /**
+     *    Reports the comparison.
+     *    @param integer $compare     Measured call count.
+     *    @return string              Message to show.
+     *    @access public
+     */
+    function testMessage($compare) {
+        return 'Expected call count for [' . $this->_method .
+                '] was [' . $this->_count .
+                '] got [' . $compare . ']';
+    }
+}
+
+/**
+ *    Confirms that the number of calls on a method is as expected.
+ *  @package    SimpleTest
+ *  @subpackage MockObjects
+ */
+class MinimumCallCountExpectation extends SimpleExpectation {
+    var $_method;
+    var $_count;
+
+    /**
+     *    Stashes the method and expected count for later
+     *    reporting.
+     *    @param string $method    Name of method to confirm against.
+     *    @param integer $count    Minimum number of calls.
+     *    @param string $message   Custom error message.
+     */
+    function MinimumCallCountExpectation($method, $count, $message = '%s') {
+        $this->_method = $method;
+        $this->_count = $count;
+        $this->SimpleExpectation($message);
+    }
+
+    /**
+     *    Tests the assertion. True if correct.
+     *    @param integer $compare     Measured call count.
+     *    @return boolean             True if enough.
+     *    @access public
+     */
+    function test($compare) {
+        return ($this->_count <= $compare);
+    }
+
+    /**
+     *    Reports the comparison.
+     *    @param integer $compare     Measured call count.
+     *    @return string              Message to show.
+     *    @access public
+     */
+    function testMessage($compare) {
+        return 'Minimum call count for [' . $this->_method .
+                '] was [' . $this->_count .
+                '] got [' . $compare . ']';
+    }
+}
+
+/**
+ *    Confirms that the number of calls on a method is as expected.
+ *    @package      SimpleTest
+ *    @subpackage   MockObjects
+ */
+class MaximumCallCountExpectation extends SimpleExpectation {
+    var $_method;
+    var $_count;
+
+    /**
+     *    Stashes the method and expected count for later
+     *    reporting.
+     *    @param string $method    Name of method to confirm against.
+     *    @param integer $count    Minimum number of calls.
+     *    @param string $message   Custom error message.
+     */
+    function MaximumCallCountExpectation($method, $count, $message = '%s') {
+        $this->_method = $method;
+        $this->_count = $count;
+        $this->SimpleExpectation($message);
+    }
+
+    /**
+     *    Tests the assertion. True if correct.
+     *    @param integer $compare     Measured call count.
+     *    @return boolean             True if not over.
+     *    @access public
+     */
+    function test($compare) {
+        return ($this->_count >= $compare);
+    }
+
+    /**
+     *    Reports the comparison.
+     *    @param integer $compare     Measured call count.
+     *    @return string              Message to show.
+     *    @access public
+     */
+    function testMessage($compare) {
+        return 'Maximum call count for [' . $this->_method .
+                '] was [' . $this->_count .
+                '] got [' . $compare . ']';
+    }
+}
+
+/**
+ *    Retrieves method actions by searching the
+ *    parameter lists until an expected match is found.
+ *    @package SimpleTest
+ *    @subpackage MockObjects
+ */
+class SimpleSignatureMap {
+    var $_map;
+
+    /**
+     *    Creates an empty call map.
+     *    @access public
+     */
+    function SimpleSignatureMap() {
+        $this->_map = array();
+    }
+
+    /**
+     *    Stashes a reference against a method call.
+     *    @param array $parameters    Array of arguments (including wildcards).
+     *    @param mixed $action        Reference placed in the map.
+     *    @access public
+     */
+    function add($parameters, &$action) {
+        $place = count($this->_map);
+        $this->_map[$place] = array();
+        $this->_map[$place]['params'] = new ParametersExpectation($parameters);
+        $this->_map[$place]['content'] = &$action;
+    }
+
+    /**
+     *    Searches the call list for a matching parameter
+     *    set. Returned by reference.
+     *    @param array $parameters    Parameters to search by
+     *                                without wildcards.
+     *    @return object              Object held in the first matching
+     *                                slot, otherwise null.
+     *    @access public
+     */
+    function &findFirstAction($parameters) {
+        $slot = $this->_findFirstSlot($parameters);
+        if (isset($slot) && isset($slot['content'])) {
+            return $slot['content'];
+        }
+        $null = null;
+        return $null;
+    }
+
+    /**
+     *    Searches the call list for a matching parameter
+     *    set. True if successful.
+     *    @param array $parameters    Parameters to search by
+     *                                without wildcards.
+     *    @return boolean             True if a match is present.
+     *    @access public
+     */
+    function isMatch($parameters) {
+        return ($this->_findFirstSlot($parameters) != null);
+    }
+    
+    /**
+     *    Compares the incoming parameters with the
+     *    internal expectation. Uses the incoming $test
+     *    to dispatch the test message.
+     *    @param SimpleTestCase $test   Test to dispatch to.
+     *    @param array $parameters      The actual calling arguments.
+     *    @param string $message        The message to overlay.
+     *    @access public
+     */
+    function test(&$test, $parameters, $message) {
+    }
+
+    /**
+     *    Searches the map for a matching item.
+     *    @param array $parameters    Parameters to search by
+     *                                without wildcards.
+     *    @return array               Reference to slot or null.
+     *    @access private
+     */
+    function &_findFirstSlot($parameters) {
+        $count = count($this->_map);
+        for ($i = 0; $i < $count; $i++) {
+            if ($this->_map[$i]["params"]->test($parameters)) {
+                return $this->_map[$i];
+            }
+        }
+        $null = null;
+        return $null;
+    }
+}
+
+/**
+ *    Allows setting of actions against call signatures either
+ *    at a specific time, or always. Specific time settings
+ *    trump lasting ones, otherwise the most recently added
+ *    will mask an earlier match.
+ *    @package SimpleTest
+ *    @subpackage MockObjects
+ */
+class SimpleCallSchedule {
+    var $_wildcard = MOCK_ANYTHING;
+    var $_always;
+    var $_at;
+    
+    /**
+     *    Sets up an empty response schedule.
+     *    Creates an empty call map.
+     */
+    function SimpleCallSchedule() {
+        $this->_always = array();
+        $this->_at = array();
+    }
+    
+    /**
+     *    Stores an action against a signature that
+     *    will always fire unless masked by a time
+     *    specific one.
+     *    @param string $method        Method name.
+     *    @param array $args           Calling parameters.
+     *    @param SimpleAction $action  Actually simpleByValue, etc.
+     *    @access public
+     */
+    function register($method, $args, &$action) {
+        $args = $this->_replaceWildcards($args);
+        $method = strtolower($method);
+        if (! isset($this->_always[$method])) {
+            $this->_always[$method] = new SimpleSignatureMap();
+        }
+        $this->_always[$method]->add($args, $action);
+    }
+    
+    /**
+     *    Stores an action against a signature that
+     *    will fire at a specific time in the future.
+     *    @param integer $step         delay of calls to this method,
+     *                                 0 is next.
+     *    @param string $method        Method name.
+     *    @param array $args           Calling parameters.
+     *    @param SimpleAction $action  Actually SimpleByValue, etc.
+     *    @access public
+     */
+    function registerAt($step, $method, $args, &$action) {
+        $args = $this->_replaceWildcards($args);
+        $method = strtolower($method);
+        if (! isset($this->_at[$method])) {
+            $this->_at[$method] = array();
+        }
+        if (! isset($this->_at[$method][$step])) {
+            $this->_at[$method][$step] = new SimpleSignatureMap();
+        }
+        $this->_at[$method][$step]->add($args, $action);
+    }
+    
+    function expectArguments($method, $args, $message) {
+        $args = $this->_replaceWildcards($args);
+        $message .= Mock::getExpectationLine();
+        $this->_expected_args[strtolower($method)] =
+                new ParametersExpectation($args, $message);
+
+    }
+    
+    /**
+     *    Actually carry out the action stored previously,
+     *    if the parameters match.
+     *    @param integer $step      Time of call.
+     *    @param string $method     Method name.
+     *    @param array $args        The parameters making up the
+     *                              rest of the call.
+     *    @return mixed             The result of the action.
+     *    @access public.
+     */
+    function &respond($step, $method, $args) {
+        $method = strtolower($method);
+        if (isset($this->_at[$method][$step])) {
+            if ($this->_at[$method][$step]->isMatch($args)) {
+                $action = &$this->_at[$method][$step]->findFirstAction($args);
+                if (isset($action)) {
+                    return $action->act();
+                }
+            }
+        }
+        if (isset($this->_always[$method])) {
+            $action = &$this->_always[$method]->findFirstAction($args);
+            if (isset($action)) {
+                return $action->act();
+            }
+        }
+        $null = null;
+        return $null;
+    }
+    
+    /**
+     *    Replaces wildcard matches with wildcard
+     *    expectations in the argument list.
+     *    @param array $args      Raw argument list.
+     *    @return array           Argument list with
+     *                            expectations.
+     *    @access private
+     */
+    function _replaceWildcards($args) {
+        if ($args === false) {
+            return false;
+        }
+        for ($i = 0; $i < count($args); $i++) {
+            if ($args[$i] === $this->_wildcard) {
+                $args[$i] = new AnythingExpectation();
+            }
+        }
+        return $args;
+    }
+}
+
+/**
+ *    A type of SimpleMethodAction.
+ *    Stashes a reference for returning later.
+ *    @package SimpleTest
+ *    @subpackage MockObjects
+ */
+class SimpleByReference {
+    var $_reference;
+    
+    /**
+     *    Stashes it for later.
+     *    @param mixed $reference     Actual PHP4 style reference.
+     *    @access public
+     */
+    function SimpleByReference(&$reference) {
+        $this->_reference = &$reference;
+    }
+    
+    /**
+     *    Returns the reference stored earlier.
+     *    @return mixed    Whatever was stashed.
+     *    @access public
+     */
+    function &act() {
+        return $this->_reference;
+    }
+}
+
+/**
+ *    A type of SimpleMethodAction.
+ *    Stashes a value for returning later.
+ *    @package SimpleTest
+ *    @subpackage MockObjects
+ */
+class SimpleByValue {
+    var $_value;
+    
+    /**
+     *    Stashes it for later.
+     *    @param mixed $value     You need to clone objects
+     *                            if you want copy semantics
+     *                            for these.
+     *    @access public
+     */
+    function SimpleByValue($value) {
+        $this->_value = $value;
+    }
+    
+    /**
+     *    Returns the value stored earlier.
+     *    @return mixed    Whatever was stashed.
+     *    @access public
+     */
+    function &act() {
+        $dummy = $this->_value;
+        return $dummy;
+    }
+}
+
+/**
+ *    A type of SimpleMethodAction.
+ *    Stashes an exception for throwing later.
+ *    @package SimpleTest
+ *    @subpackage MockObjects
+ */
+class SimpleThrower {
+    var $_exception;
+    
+    /**
+     *    Stashes it for later.
+     *    @param Exception $exception    The exception object to throw.
+     *    @access public
+     */
+    function SimpleThrower($exception) {
+        $this->_exception = $exception;
+    }
+    
+    /**
+     *    Throws the exceptins stashed earlier.
+     *    @access public
+     */
+    function act() {
+        eval('throw $this->_exception;');
+    }
+}
+
+/**
+ *    A type of SimpleMethodAction.
+ *    Stashes an error for emitting later.
+ *    @package SimpleTest
+ *    @subpackage MockObjects
+ */
+class SimpleErrorThrower {
+    var $_error;
+    var $_severity;
+    
+    /**
+     *    Stashes an error to throw later.
+     *    @param string $error      Error message.
+     *    @param integer $severity  PHP error constant, e.g E_USER_ERROR.
+     *    @access public
+     */
+    function SimpleErrorThrower($error, $severity) {
+        $this->_error = $error;
+        $this->_severity = $severity;
+    }
+    
+    /**
+     *    Triggers the stashed error.
+     *    @return null        The usual PHP4.4 shenanigans are needed here.
+     *    @access public
+     */
+    function &act() {
+        trigger_error($this->_error, $this->_severity);
+        $null = null;
+        return $null;
+    }
+}
+
+/**
+ *    A base class or delegate that extends an
+ *    empty collection of methods that can have their
+ *    return values set and expectations made of the
+ *    calls upon them. The mock will assert the
+ *    expectations against it's attached test case in
+ *    addition to the server stub behaviour or returning
+ *    preprogrammed responses.
+ *    @package SimpleTest
+ *    @subpackage MockObjects
+ */
+class SimpleMock {
+    var $_actions;
+    var $_wildcard = MOCK_ANYTHING;
+    var $_is_strict = true;
+    var $_call_counts;
+    var $_expected_counts;
+    var $_max_counts;
+    var $_expected_args;
+    var $_expected_args_at;
+
+    /**
+     *    Creates an empty action list and expectation list.
+     *    All call counts are set to zero.
+     *    @access public
+     */
+    function SimpleMock() {
+        $this->_actions = &new SimpleCallSchedule();
+        $this->_expectations = &new SimpleCallSchedule();
+        $this->_call_counts = array();
+        $this->_expected_counts = array();
+        $this->_max_counts = array();
+        $this->_expected_args = array();
+        $this->_expected_args_at = array();
+        $test = &$this->_getCurrentTestCase();
+        $test->tell($this);
+    }
+    
+    /**
+     *    Disables a name check when setting expectations.
+     *    This hack is needed for the partial mocks.
+     *    @access public
+     */
+    function disableExpectationNameChecks() {
+        $this->_is_strict = false;
+    }
+
+    /**
+     *    Finds currently running test.
+     *    @return SimpeTestCase    Current test case.
+     *    @access protected
+     */
+    function &_getCurrentTestCase() {
+        $context = &SimpleTest::getContext();
+        return $context->getTest();
+    }
+
+    /**
+     *    Die if bad arguments array is passed.
+     *    @param mixed $args     The arguments value to be checked.
+     *    @param string $task    Description of task attempt.
+     *    @return boolean        Valid arguments
+     *    @access private
+     */
+    function _checkArgumentsIsArray($args, $task) {
+        if (! is_array($args)) {
+            trigger_error(
+                "Cannot $task as \$args parameter is not an array",
+                E_USER_ERROR);
+        }
+    }
+
+    /**
+     *    Triggers a PHP error if the method is not part
+     *    of this object.
+     *    @param string $method        Name of method.
+     *    @param string $task          Description of task attempt.
+     *    @access protected
+     */
+    function _dieOnNoMethod($method, $task) {
+        if ($this->_is_strict && ! method_exists($this, $method)) {
+            trigger_error(
+                    "Cannot $task as no ${method}() in class " . get_class($this),
+                    E_USER_ERROR);
+        }
+    }
+
+    /**
+     *    Replaces wildcard matches with wildcard
+     *    expectations in the argument list.
+     *    @param array $args      Raw argument list.
+     *    @return array           Argument list with
+     *                            expectations.
+     *    @access private
+     */
+    function _replaceWildcards($args) {
+        if ($args === false) {
+            return false;
+        }
+        for ($i = 0; $i < count($args); $i++) {
+            if ($args[$i] === $this->_wildcard) {
+                $args[$i] = new AnythingExpectation();
+            }
+        }
+        return $args;
+    }
+
+    /**
+     *    Adds one to the call count of a method.
+     *    @param string $method        Method called.
+     *    @param array $args           Arguments as an array.
+     *    @access protected
+     */
+    function _addCall($method, $args) {
+        if (! isset($this->_call_counts[$method])) {
+            $this->_call_counts[$method] = 0;
+        }
+        $this->_call_counts[$method]++;
+    }
+
+    /**
+     *    Fetches the call count of a method so far.
+     *    @param string $method        Method name called.
+     *    @return integer              Number of calls so far.
+     *    @access public
+     */
+    function getCallCount($method) {
+        $this->_dieOnNoMethod($method, "get call count");
+        $method = strtolower($method);
+        if (! isset($this->_call_counts[$method])) {
+            return 0;
+        }
+        return $this->_call_counts[$method];
+    }
+
+    /**
+     *    Sets a return for a parameter list that will
+     *    be passed by value for all calls to this method.
+     *    @param string $method       Method name.
+     *    @param mixed $value         Result of call passed by value.
+     *    @param array $args          List of parameters to match
+     *                                including wildcards.
+     *    @access public
+     */
+    function setReturnValue($method, $value, $args = false) {
+        $this->_dieOnNoMethod($method, "set return value");
+        $this->_actions->register($method, $args, new SimpleByValue($value));
+    }
+
+    /**
+     *    Sets a return for a parameter list that will
+     *    be passed by value only when the required call count
+     *    is reached.
+     *    @param integer $timing   Number of calls in the future
+     *                             to which the result applies. If
+     *                             not set then all calls will return
+     *                             the value.
+     *    @param string $method    Method name.
+     *    @param mixed $value      Result of call passed by value.
+     *    @param array $args       List of parameters to match
+     *                             including wildcards.
+     *    @access public
+     */
+    function setReturnValueAt($timing, $method, $value, $args = false) {
+        $this->_dieOnNoMethod($method, "set return value sequence");
+        $this->_actions->registerAt($timing, $method, $args, new SimpleByValue($value));
+    }
+
+    /**
+     *    Sets a return for a parameter list that will
+     *    be passed by reference for all calls.
+     *    @param string $method       Method name.
+     *    @param mixed $reference     Result of the call will be this object.
+     *    @param array $args          List of parameters to match
+     *                                including wildcards.
+     *    @access public
+     */
+    function setReturnReference($method, &$reference, $args = false) {
+        $this->_dieOnNoMethod($method, "set return reference");
+        $this->_actions->register($method, $args, new SimpleByReference($reference));
+    }
+
+    /**
+     *    Sets a return for a parameter list that will
+     *    be passed by value only when the required call count
+     *    is reached.
+     *    @param integer $timing    Number of calls in the future
+     *                              to which the result applies. If
+     *                              not set then all calls will return
+     *                              the value.
+     *    @param string $method     Method name.
+     *    @param mixed $reference   Result of the call will be this object.
+     *    @param array $args        List of parameters to match
+     *                              including wildcards.
+     *    @access public
+     */
+    function setReturnReferenceAt($timing, $method, &$reference, $args = false) {
+        $this->_dieOnNoMethod($method, "set return reference sequence");
+        $this->_actions->registerAt($timing, $method, $args, new SimpleByReference($reference));
+    }
+
+    /**
+     *    Sets up an expected call with a set of
+     *    expected parameters in that call. All
+     *    calls will be compared to these expectations
+     *    regardless of when the call is made.
+     *    @param string $method        Method call to test.
+     *    @param array $args           Expected parameters for the call
+     *                                 including wildcards.
+     *    @param string $message       Overridden message.
+     *    @access public
+     */
+    function expect($method, $args, $message = '%s') {
+        $this->_dieOnNoMethod($method, 'set expected arguments');
+        $this->_checkArgumentsIsArray($args, 'set expected arguments');
+        $this->_expectations->expectArguments($method, $args, $message);
+        $args = $this->_replaceWildcards($args);
+        $message .= Mock::getExpectationLine();
+        $this->_expected_args[strtolower($method)] =
+                new ParametersExpectation($args, $message);
+    }
+
+    /**
+     *    @deprecated
+     */
+    function expectArguments($method, $args, $message = '%s') {
+        return $this->expect($method, $args, $message);
+    }
+
+    /**
+     *    Sets up an expected call with a set of
+     *    expected parameters in that call. The
+     *    expected call count will be adjusted if it
+     *    is set too low to reach this call.
+     *    @param integer $timing    Number of calls in the future at
+     *                              which to test. Next call is 0.
+     *    @param string $method     Method call to test.
+     *    @param array $args        Expected parameters for the call
+     *                              including wildcards.
+     *    @param string $message    Overridden message.
+     *    @access public
+     */
+    function expectAt($timing, $method, $args, $message = '%s') {
+        $this->_dieOnNoMethod($method, 'set expected arguments at time');
+        $this->_checkArgumentsIsArray($args, 'set expected arguments at time');
+        $args = $this->_replaceWildcards($args);
+        if (! isset($this->_expected_args_at[$timing])) {
+            $this->_expected_args_at[$timing] = array();
+        }
+        $method = strtolower($method);
+        $message .= Mock::getExpectationLine();
+        $this->_expected_args_at[$timing][$method] =
+                new ParametersExpectation($args, $message);
+    }
+
+    /**
+     *    @deprecated
+     */
+    function expectArgumentsAt($timing, $method, $args, $message = '%s') {
+        return $this->expectAt($timing, $method, $args, $message);
+    }
+
+    /**
+     *    Sets an expectation for the number of times
+     *    a method will be called. The tally method
+     *    is used to check this.
+     *    @param string $method        Method call to test.
+     *    @param integer $count        Number of times it should
+     *                                 have been called at tally.
+     *    @param string $message       Overridden message.
+     *    @access public
+     */
+    function expectCallCount($method, $count, $message = '%s') {
+        $this->_dieOnNoMethod($method, 'set expected call count');
+        $message .= Mock::getExpectationLine();
+        $this->_expected_counts[strtolower($method)] =
+                new CallCountExpectation($method, $count, $message);
+    }
+
+    /**
+     *    Sets the number of times a method may be called
+     *    before a test failure is triggered.
+     *    @param string $method        Method call to test.
+     *    @param integer $count        Most number of times it should
+     *                                 have been called.
+     *    @param string $message       Overridden message.
+     *    @access public
+     */
+    function expectMaximumCallCount($method, $count, $message = '%s') {
+        $this->_dieOnNoMethod($method, 'set maximum call count');
+        $message .= Mock::getExpectationLine();
+        $this->_max_counts[strtolower($method)] =
+                new MaximumCallCountExpectation($method, $count, $message);
+    }
+
+    /**
+     *    Sets the number of times to call a method to prevent
+     *    a failure on the tally.
+     *    @param string $method      Method call to test.
+     *    @param integer $count      Least number of times it should
+     *                               have been called.
+     *    @param string $message     Overridden message.
+     *    @access public
+     */
+    function expectMinimumCallCount($method, $count, $message = '%s') {
+        $this->_dieOnNoMethod($method, 'set minimum call count');
+        $message .= Mock::getExpectationLine();
+        $this->_expected_counts[strtolower($method)] =
+                new MinimumCallCountExpectation($method, $count, $message);
+    }
+
+    /**
+     *    Convenience method for barring a method
+     *    call.
+     *    @param string $method        Method call to ban.
+     *    @param string $message       Overridden message.
+     *    @access public
+     */
+    function expectNever($method, $message = '%s') {
+        $this->expectMaximumCallCount($method, 0, $message);
+    }
+
+    /**
+     *    Convenience method for a single method
+     *    call.
+     *    @param string $method     Method call to track.
+     *    @param array $args        Expected argument list or
+     *                              false for any arguments.
+     *    @param string $message    Overridden message.
+     *    @access public
+     */
+    function expectOnce($method, $args = false, $message = '%s') {
+        $this->expectCallCount($method, 1, $message);
+        if ($args !== false) {
+            $this->expect($method, $args, $message);
+        }
+    }
+
+    /**
+     *    Convenience method for requiring a method
+     *    call.
+     *    @param string $method       Method call to track.
+     *    @param array $args          Expected argument list or
+     *                                false for any arguments.
+     *    @param string $message      Overridden message.
+     *    @access public
+     */
+    function expectAtLeastOnce($method, $args = false, $message = '%s') {
+        $this->expectMinimumCallCount($method, 1, $message);
+        if ($args !== false) {
+            $this->expect($method, $args, $message);
+        }
+    }
+    
+    /**
+     *    Sets up a trigger to throw an exception upon the
+     *    method call.
+     *    @param string $method     Method name to throw on.
+     */
+    function throwOn($method, $exception = false, $args = false) {
+        $this->_dieOnNoMethod($method, "throw on");
+        $this->_actions->register($method, $args,
+                new SimpleThrower($exception ? $exception : new Exception()));
+    }
+    
+    /**
+     *    Sets up a trigger to throw an exception upon the
+     *    method call.
+     */
+    function throwAt($timing, $method, $exception = false, $args = false) {
+        $this->_dieOnNoMethod($method, "throw at");
+        $this->_actions->registerAt($timing, $method, $args,
+                new SimpleThrower($exception ? $exception : new Exception()));
+    }
+    
+    /**
+     *    Sets up a trigger to throw an error upon the
+     *    method call.
+     */
+    function errorOn($method, $error = 'A mock error', $args = false, $severity = E_USER_ERROR) {
+        $this->_dieOnNoMethod($method, "error on");
+        $this->_actions->register($method, $args, new SimpleErrorThrower($error, $severity));
+    }
+    
+    /**
+     *    Sets up a trigger to throw an error upon the
+     *    method call.
+     */
+    function errorAt($timing, $method, $error = 'A mock error', $args = false, $severity = E_USER_ERROR) {
+        $this->_dieOnNoMethod($method, "error at");
+        $this->_actions->registerAt($timing, $method, $args, new SimpleErrorThrower($error, $severity));
+    }
+
+    /**
+     *    @deprecated
+     */
+    function tally() {
+    }
+
+    /**
+     *    Receives event from unit test that the current
+     *    test method has finished. Totals up the call
+     *    counts and triggers a test assertion if a test
+     *    is present for expected call counts.
+     *    @param string $test_method      Current method name.
+     *    @param SimpleTestCase $test     Test to send message to.
+     *    @access public
+     */
+    function atTestEnd($test_method, &$test) {
+        foreach ($this->_expected_counts as $method => $expectation) {
+            $test->assert($expectation, $this->getCallCount($method));
+        }
+        foreach ($this->_max_counts as $method => $expectation) {
+            if ($expectation->test($this->getCallCount($method))) {
+                $test->assert($expectation, $this->getCallCount($method));
+            }
+        }
+    }
+
+    /**
+     *    Returns the expected value for the method name
+     *    and checks expectations. Will generate any
+     *    test assertions as a result of expectations
+     *    if there is a test present.
+     *    @param string $method       Name of method to simulate.
+     *    @param array $args          Arguments as an array.
+     *    @return mixed               Stored return.
+     *    @access private
+     */
+    function &_invoke($method, $args) {
+        $method = strtolower($method);
+        $step = $this->getCallCount($method);
+        $this->_addCall($method, $args);
+        $this->_checkExpectations($method, $args, $step);
+        $result = &$this->_emulateCall($method, $args, $step);
+        return $result;
+    }
+    
+    /**
+     *    Finds the return value matching the incoming
+     *    arguments. If there is no matching value found
+     *    then an error is triggered.
+     *    @param string $method      Method name.
+     *    @param array $args         Calling arguments.
+     *    @param integer $step       Current position in the
+     *                               call history.
+     *    @return mixed              Stored return or other action.
+     *    @access protected
+     */
+    function &_emulateCall($method, $args, $step) {
+        return $this->_actions->respond($step, $method, $args);
+    }
+
+    /**
+     *    Tests the arguments against expectations.
+     *    @param string $method        Method to check.
+     *    @param array $args           Argument list to match.
+     *    @param integer $timing       The position of this call
+     *                                 in the call history.
+     *    @access private
+     */
+    function _checkExpectations($method, $args, $timing) {
+        $test = &$this->_getCurrentTestCase();
+        if (isset($this->_max_counts[$method])) {
+            if (! $this->_max_counts[$method]->test($timing + 1)) {
+                $test->assert($this->_max_counts[$method], $timing + 1);
+            }
+        }
+        if (isset($this->_expected_args_at[$timing][$method])) {
+            $test->assert(
+                    $this->_expected_args_at[$timing][$method],
+                    $args,
+                    "Mock method [$method] at [$timing] -> %s");
+        } elseif (isset($this->_expected_args[$method])) {
+            $test->assert(
+                    $this->_expected_args[$method],
+                    $args,
+                    "Mock method [$method] -> %s");
+        }
+    }
+}
+
+/**
+ *    Static methods only service class for code generation of
+ *    mock objects.
+ *    @package SimpleTest
+ *    @subpackage MockObjects
+ */
+class Mock {
+
+    /**
+     *    Factory for mock object classes.
+     *    @access public
+     */
+    function Mock() {
+        trigger_error('Mock factory methods are static.');
+    }
+
+    /**
+     *    Clones a class' interface and creates a mock version
+     *    that can have return values and expectations set.
+     *    @param string $class         Class to clone.
+     *    @param string $mock_class    New class name. Default is
+     *                                 the old name with "Mock"
+     *                                 prepended.
+     *    @param array $methods        Additional methods to add beyond
+     *                                 those in the cloned class. Use this
+     *                                 to emulate the dynamic addition of
+     *                                 methods in the cloned class or when
+     *                                 the class hasn't been written yet.
+     *    @static
+     *    @access public
+     */
+    function generate($class, $mock_class = false, $methods = false) {
+        $generator = new MockGenerator($class, $mock_class);
+        return $generator->generateSubclass($methods);
+    }
+
+    /**
+     *    Generates a version of a class with selected
+     *    methods mocked only. Inherits the old class
+     *    and chains the mock methods of an aggregated
+     *    mock object.
+     *    @param string $class            Class to clone.
+     *    @param string $mock_class       New class name.
+     *    @param array $methods           Methods to be overridden
+     *                                    with mock versions.
+     *    @static
+     *    @access public
+     */
+    function generatePartial($class, $mock_class, $methods) {
+        $generator = new MockGenerator($class, $mock_class);
+        return $generator->generatePartial($methods);
+    }
+
+    /**
+     *    Uses a stack trace to find the line of an assertion.
+     *    @access public
+     *    @static
+     */
+    function getExpectationLine() {
+        $trace = new SimpleStackTrace(array('expect'));
+        return $trace->traceMethod();
+    }
+}
+
+/**
+ *    @package  SimpleTest
+ *    @subpackage   MockObjects
+ *    @deprecated
+ */
+class Stub extends Mock {
+}
+
+/**
+ *    Service class for code generation of mock objects.
+ *    @package SimpleTest
+ *    @subpackage MockObjects
+ */
+class MockGenerator {
+    var $_class;
+    var $_mock_class;
+    var $_mock_base;
+    var $_reflection;
+
+    /**
+     *    Builds initial reflection object.
+     *    @param string $class        Class to be mocked.
+     *    @param string $mock_class   New class with identical interface,
+     *                                but no behaviour.
+     */
+    function MockGenerator($class, $mock_class) {
+        $this->_class = $class;
+        $this->_mock_class = $mock_class;
+        if (! $this->_mock_class) {
+            $this->_mock_class = 'Mock' . $this->_class;
+        }
+        $this->_mock_base = SimpleTest::getMockBaseClass();
+        $this->_reflection = new SimpleReflection($this->_class);
+    }
+
+    /**
+     *    Clones a class' interface and creates a mock version
+     *    that can have return values and expectations set.
+     *    @param array $methods        Additional methods to add beyond
+     *                                 those in th cloned class. Use this
+     *                                 to emulate the dynamic addition of
+     *                                 methods in the cloned class or when
+     *                                 the class hasn't been written yet.
+     *    @access public
+     */
+    function generate($methods) {
+        if (! $this->_reflection->classOrInterfaceExists()) {
+            return false;
+        }
+        $mock_reflection = new SimpleReflection($this->_mock_class);
+        if ($mock_reflection->classExistsSansAutoload()) {
+            return false;
+        }
+        $code = $this->_createClassCode($methods ? $methods : array());
+        return eval("$code return \$code;");
+    }
+    
+    /**
+     *    Subclasses a class and overrides every method with a mock one
+     *    that can have return values and expectations set. Chains
+     *    to an aggregated SimpleMock.
+     *    @param array $methods        Additional methods to add beyond
+     *                                 those in the cloned class. Use this
+     *                                 to emulate the dynamic addition of
+     *                                 methods in the cloned class or when
+     *                                 the class hasn't been written yet.
+     *    @access public
+     */
+    function generateSubclass($methods) {
+        if (! $this->_reflection->classOrInterfaceExists()) {
+            return false;
+        }
+        $mock_reflection = new SimpleReflection($this->_mock_class);
+        if ($mock_reflection->classExistsSansAutoload()) {
+            return false;
+        }
+        if ($this->_reflection->isInterface() || $this->_reflection->hasFinal()) {
+            $code = $this->_createClassCode($methods ? $methods : array());
+            return eval("$code return \$code;");
+        } else {
+            $code = $this->_createSubclassCode($methods ? $methods : array());
+            return eval("$code return \$code;");
+        }
+    }
+
+    /**
+     *    Generates a version of a class with selected
+     *    methods mocked only. Inherits the old class
+     *    and chains the mock methods of an aggregated
+     *    mock object.
+     *    @param array $methods           Methods to be overridden
+     *                                    with mock versions.
+     *    @access public
+     */
+    function generatePartial($methods) {
+        if (! $this->_reflection->classExists($this->_class)) {
+            return false;
+        }
+        $mock_reflection = new SimpleReflection($this->_mock_class);
+        if ($mock_reflection->classExistsSansAutoload()) {
+            trigger_error('Partial mock class [' . $this->_mock_class . '] already exists');
+            return false;
+        }
+        $code = $this->_extendClassCode($methods);
+        return eval("$code return \$code;");
+    }
+
+    /**
+     *    The new mock class code as a string.
+     *    @param array $methods          Additional methods.
+     *    @return string                 Code for new mock class.
+     *    @access private
+     */
+    function _createClassCode($methods) {
+        $implements = '';
+        $interfaces = $this->_reflection->getInterfaces();
+        if (function_exists('spl_classes')) {
+            $interfaces = array_diff($interfaces, array('Traversable'));
+        }
+        if (count($interfaces) > 0) {
+            $implements = 'implements ' . implode(', ', $interfaces);
+        }
+        $code = "class " . $this->_mock_class . " extends " . $this->_mock_base . " $implements {\n";
+        $code .= "    function " . $this->_mock_class . "() {\n";
+        $code .= "        \$this->" . $this->_mock_base . "();\n";
+        $code .= "    }\n";
+        if (in_array('__construct', $this->_reflection->getMethods())) {
+            $code .= "    " . $this->_reflection->getSignature('__construct') . " {\n";
+            $code .= "        \$this->" . $this->_mock_base . "();\n";
+            $code .= "    }\n";
+        }
+        $code .= $this->_createHandlerCode($methods);
+        $code .= "}\n";
+        return $code;
+    }
+
+    /**
+     *    The new mock class code as a string. The mock will
+     *    be a subclass of the original mocked class.
+     *    @param array $methods          Additional methods.
+     *    @return string                 Code for new mock class.
+     *    @access private
+     */
+    function _createSubclassCode($methods) {
+        $code  = "class " . $this->_mock_class . " extends " . $this->_class . " {\n";
+        $code .= "    var \$_mock;\n";
+        $code .= $this->_addMethodList(array_merge($methods, $this->_reflection->getMethods()));
+        $code .= "\n";
+        $code .= "    function " . $this->_mock_class . "() {\n";
+        $code .= "        \$this->_mock = &new " . $this->_mock_base . "();\n";
+        $code .= "        \$this->_mock->disableExpectationNameChecks();\n";
+        $code .= "    }\n";
+        $code .= $this->_chainMockReturns();
+        $code .= $this->_chainMockExpectations();
+        $code .= $this->_chainThrowMethods();
+        $code .= $this->_overrideMethods($this->_reflection->getMethods());
+        $code .= $this->_createNewMethodCode($methods);
+        $code .= "}\n";
+        return $code;
+    }
+
+    /**
+     *    The extension class code as a string. The class
+     *    composites a mock object and chains mocked methods
+     *    to it.
+     *    @param array  $methods       Mocked methods.
+     *    @return string               Code for a new class.
+     *    @access private
+     */
+    function _extendClassCode($methods) {
+        $code  = "class " . $this->_mock_class . " extends " . $this->_class . " {\n";
+        $code .= "    var \$_mock;\n";
+        $code .= $this->_addMethodList($methods);
+        $code .= "\n";
+        $code .= "    function " . $this->_mock_class . "() {\n";
+        $code .= "        \$this->_mock = &new " . $this->_mock_base . "();\n";
+        $code .= "        \$this->_mock->disableExpectationNameChecks();\n";
+        $code .= "    }\n";
+        $code .= $this->_chainMockReturns();
+        $code .= $this->_chainMockExpectations();
+        $code .= $this->_chainThrowMethods();
+        $code .= $this->_overrideMethods($methods);
+        $code .= "}\n";
+        return $code;
+    }
+
+    /**
+     *    Creates code within a class to generate replaced
+     *    methods. All methods call the _invoke() handler
+     *    with the method name and the arguments in an
+     *    array.
+     *    @param array $methods    Additional methods.
+     *    @access private
+     */
+    function _createHandlerCode($methods) {
+        $code = '';
+        $methods = array_merge($methods, $this->_reflection->getMethods());
+        foreach ($methods as $method) {
+            if ($this->_isConstructor($method)) {
+                continue;
+            }
+            $mock_reflection = new SimpleReflection($this->_mock_base);
+            if (in_array($method, $mock_reflection->getMethods())) {
+                continue;
+            }
+            $code .= "    " . $this->_reflection->getSignature($method) . " {\n";
+            $code .= "        \$args = func_get_args();\n";
+            $code .= "        \$result = &\$this->_invoke(\"$method\", \$args);\n";
+            $code .= "        return \$result;\n";
+            $code .= "    }\n";
+        }
+        return $code;
+    }
+
+    /**
+     *    Creates code within a class to generate a new
+     *    methods. All methods call the _invoke() handler
+     *    on the internal mock with the method name and
+     *    the arguments in an array.
+     *    @param array $methods    Additional methods.
+     *    @access private
+     */
+    function _createNewMethodCode($methods) {
+        $code = '';
+        foreach ($methods as $method) {
+            if ($this->_isConstructor($method)) {
+                continue;
+            }
+            $mock_reflection = new SimpleReflection($this->_mock_base);
+            if (in_array($method, $mock_reflection->getMethods())) {
+                continue;
+            }
+            $code .= "    " . $this->_reflection->getSignature($method) . " {\n";
+            $code .= "        \$args = func_get_args();\n";
+            $code .= "        \$result = &\$this->_mock->_invoke(\"$method\", \$args);\n";
+            $code .= "        return \$result;\n";
+            $code .= "    }\n";
+        }
+        return $code;
+    }
+
+    /**
+     *    Tests to see if a special PHP method is about to
+     *    be stubbed by mistake.
+     *    @param string $method    Method name.
+     *    @return boolean          True if special.
+     *    @access private
+     */
+    function _isConstructor($method) {
+        return in_array(
+                strtolower($method),
+                array('__construct', '__destruct'));
+    }
+
+    /**
+     *    Creates a list of mocked methods for error checking.
+     *    @param array $methods       Mocked methods.
+     *    @return string              Code for a method list.
+     *    @access private
+     */
+    function _addMethodList($methods) {
+        return "    var \$_mocked_methods = array('" .
+                implode("', '", array_map('strtolower', $methods)) .
+                "');\n";
+    }
+
+    /**
+     *    Creates code to abandon the expectation if not mocked.
+     *    @param string $alias       Parameter name of method name.
+     *    @return string             Code for bail out.
+     *    @access private
+     */
+    function _bailOutIfNotMocked($alias) {
+        $code  = "        if (! in_array(strtolower($alias), \$this->_mocked_methods)) {\n";
+        $code .= "            trigger_error(\"Method [$alias] is not mocked\");\n";
+        $code .= "            \$null = null;\n";
+        $code .= "            return \$null;\n";
+        $code .= "        }\n";
+        return $code;
+    }
+
+    /**
+     *    Creates source code for chaining to the composited
+     *    mock object.
+     *    @return string           Code for mock set up.
+     *    @access private
+     */
+    function _chainMockReturns() {
+        $code  = "    function setReturnValue(\$method, \$value, \$args = false) {\n";
+        $code .= $this->_bailOutIfNotMocked("\$method");
+        $code .= "        \$this->_mock->setReturnValue(\$method, \$value, \$args);\n";
+        $code .= "    }\n";
+        $code .= "    function setReturnValueAt(\$timing, \$method, \$value, \$args = false) {\n";
+        $code .= $this->_bailOutIfNotMocked("\$method");
+        $code .= "        \$this->_mock->setReturnValueAt(\$timing, \$method, \$value, \$args);\n";
+        $code .= "    }\n";
+        $code .= "    function setReturnReference(\$method, &\$ref, \$args = false) {\n";
+        $code .= $this->_bailOutIfNotMocked("\$method");
+        $code .= "        \$this->_mock->setReturnReference(\$method, \$ref, \$args);\n";
+        $code .= "    }\n";
+        $code .= "    function setReturnReferenceAt(\$timing, \$method, &\$ref, \$args = false) {\n";
+        $code .= $this->_bailOutIfNotMocked("\$method");
+        $code .= "        \$this->_mock->setReturnReferenceAt(\$timing, \$method, \$ref, \$args);\n";
+        $code .= "    }\n";
+        return $code;
+    }
+
+    /**
+     *    Creates source code for chaining to an aggregated
+     *    mock object.
+     *    @return string                 Code for expectations.
+     *    @access private
+     */
+    function _chainMockExpectations() {
+        $code  = "    function expect(\$method, \$args = false, \$msg = '%s') {\n";
+        $code .= $this->_bailOutIfNotMocked("\$method");
+        $code .= "        \$this->_mock->expect(\$method, \$args, \$msg);\n";
+        $code .= "    }\n";
+        $code .= "    function expectArguments(\$method, \$args = false, \$msg = '%s') {\n";
+        $code .= $this->_bailOutIfNotMocked("\$method");
+        $code .= "        \$this->_mock->expectArguments(\$method, \$args, \$msg);\n";
+        $code .= "    }\n";
+        $code .= "    function expectAt(\$timing, \$method, \$args = false, \$msg = '%s') {\n";
+        $code .= $this->_bailOutIfNotMocked("\$method");
+        $code .= "        \$this->_mock->expectArgumentsAt(\$timing, \$method, \$args, \$msg);\n";
+        $code .= "    }\n";
+        $code .= "    function expectArgumentsAt(\$timing, \$method, \$args = false, \$msg = '%s') {\n";
+        $code .= $this->_bailOutIfNotMocked("\$method");
+        $code .= "        \$this->_mock->expectArgumentsAt(\$timing, \$method, \$args, \$msg);\n";
+        $code .= "    }\n";
+        $code .= "    function expectCallCount(\$method, \$count) {\n";
+        $code .= $this->_bailOutIfNotMocked("\$method");
+        $code .= "        \$this->_mock->expectCallCount(\$method, \$count, \$msg = '%s');\n";
+        $code .= "    }\n";
+        $code .= "    function expectMaximumCallCount(\$method, \$count, \$msg = '%s') {\n";
+        $code .= $this->_bailOutIfNotMocked("\$method");
+        $code .= "        \$this->_mock->expectMaximumCallCount(\$method, \$count, \$msg = '%s');\n";
+        $code .= "    }\n";
+        $code .= "    function expectMinimumCallCount(\$method, \$count, \$msg = '%s') {\n";
+        $code .= $this->_bailOutIfNotMocked("\$method");
+        $code .= "        \$this->_mock->expectMinimumCallCount(\$method, \$count, \$msg = '%s');\n";
+        $code .= "    }\n";
+        $code .= "    function expectNever(\$method) {\n";
+        $code .= $this->_bailOutIfNotMocked("\$method");
+        $code .= "        \$this->_mock->expectNever(\$method);\n";
+        $code .= "    }\n";
+        $code .= "    function expectOnce(\$method, \$args = false, \$msg = '%s') {\n";
+        $code .= $this->_bailOutIfNotMocked("\$method");
+        $code .= "        \$this->_mock->expectOnce(\$method, \$args, \$msg);\n";
+        $code .= "    }\n";
+        $code .= "    function expectAtLeastOnce(\$method, \$args = false, \$msg = '%s') {\n";
+        $code .= $this->_bailOutIfNotMocked("\$method");
+        $code .= "        \$this->_mock->expectAtLeastOnce(\$method, \$args, \$msg);\n";
+        $code .= "    }\n";
+        $code .= "    function tally() {\n";
+        $code .= "    }\n";
+        return $code;
+    }
+    
+    /**
+     *    Adds code for chaining the throw methods.
+     *    @return string           Code for chains.
+     *    @access private
+     */
+    function _chainThrowMethods() {
+        $code  = "    function throwOn(\$method, \$exception = false, \$args = false) {\n";
+        $code .= $this->_bailOutIfNotMocked("\$method");
+        $code .= "        \$this->_mock->throwOn(\$method, \$exception, \$args);\n";
+        $code .= "    }\n";
+        $code .= "    function throwAt(\$timing, \$method, \$exception = false, \$args = false) {\n";
+        $code .= $this->_bailOutIfNotMocked("\$method");
+        $code .= "        \$this->_mock->throwAt(\$timing, \$method, \$exception, \$args);\n";
+        $code .= "    }\n";
+        $code .= "    function errorOn(\$method, \$error = 'A mock error', \$args = false, \$severity = E_USER_ERROR) {\n";
+        $code .= $this->_bailOutIfNotMocked("\$method");
+        $code .= "        \$this->_mock->errorOn(\$method, \$error, \$args, \$severity);\n";
+        $code .= "    }\n";
+        $code .= "    function errorAt(\$timing, \$method, \$error = 'A mock error', \$args = false, \$severity = E_USER_ERROR) {\n";
+        $code .= $this->_bailOutIfNotMocked("\$method");
+        $code .= "        \$this->_mock->errorAt(\$timing, \$method, \$error, \$args, \$severity);\n";
+        $code .= "    }\n";
+        return $code;
+    }
+
+    /**
+     *    Creates source code to override a list of methods
+     *    with mock versions.
+     *    @param array $methods    Methods to be overridden
+     *                             with mock versions.
+     *    @return string           Code for overridden chains.
+     *    @access private
+     */
+    function _overrideMethods($methods) {
+        $code = "";
+        foreach ($methods as $method) {
+            if ($this->_isConstructor($method)) {
+                continue;
+            }
+            $code .= "    " . $this->_reflection->getSignature($method) . " {\n";
+            $code .= "        \$args = func_get_args();\n";
+            $code .= "        \$result = &\$this->_mock->_invoke(\"$method\", \$args);\n";
+            $code .= "        return \$result;\n";
+            $code .= "    }\n";
+        }
+        return $code;
+    }
+}
+?>