pradosoft / prado

tests/test_tools/simpletest/reflection_php5.php

Indentation +251 added lines, -251 removed lines

@@ -1,274 +1,274 @@
 <?php
-    /**
-     *	base include file for SimpleTest
-     *	@package	SimpleTest
-     *	@subpackage	UnitTester
-     *	@version	$Id: reflection_php5.php 1398 2006-09-08 19:31:03Z xue $
-     */
+	/**
+	 *	base include file for SimpleTest
+	 *	@package	SimpleTest
+	 *	@subpackage	UnitTester
+	 *	@version	$Id: reflection_php5.php 1398 2006-09-08 19:31:03Z xue $
+	 */
 
-    /**
-     *    Version specific reflection API.
+	/**
+	 *    Version specific reflection API.
 	 *    @package SimpleTest
 	 *    @subpackage UnitTester
-     */
-    class SimpleReflection {
-        protected $_interface;
+	 */
+	class SimpleReflection {
+		protected $_interface;
 
-        /**
-         *    Stashes the class/interface.
-         *    @param string $interface    Class or interface
-         *                                to inspect.
-         */
-        function SimpleReflection($interface) {
-            $this->_interface = $interface;
-        }
+		/**
+		 *    Stashes the class/interface.
+		 *    @param string $interface    Class or interface
+		 *                                to inspect.
+		 */
+		function SimpleReflection($interface) {
+			$this->_interface = $interface;
+		}
 
-        /**
-         *    Checks that a class has been declared. Versions
-         *    before PHP5.0.2 need a check that it's not really
-         *    an interface.
-         *    @return boolean            True if defined.
-         *    @access public
-         */
-        function classExists() {
-            if (! class_exists($this->_interface)) {
-                return false;
-            }
-            $reflection = new ReflectionClass($this->_interface);
-            return ! $reflection->isInterface();
-        }
+		/**
+		 *    Checks that a class has been declared. Versions
+		 *    before PHP5.0.2 need a check that it's not really
+		 *    an interface.
+		 *    @return boolean            True if defined.
+		 *    @access public
+		 */
+		function classExists() {
+			if (! class_exists($this->_interface)) {
+				return false;
+			}
+			$reflection = new ReflectionClass($this->_interface);
+			return ! $reflection->isInterface();
+		}
 
-        /**
-         *    Needed to kill the autoload feature in PHP5
-         *    for classes created dynamically.
-         *    @return boolean        True if defined.
-         *    @access public
-         */
-        function classExistsSansAutoload() {
-            return class_exists($this->_interface, false);
-        }
+		/**
+		 *    Needed to kill the autoload feature in PHP5
+		 *    for classes created dynamically.
+		 *    @return boolean        True if defined.
+		 *    @access public
+		 */
+		function classExistsSansAutoload() {
+			return class_exists($this->_interface, false);
+		}
 
-        /**
-         *    Checks that a class or interface has been
-         *    declared.
-         *    @return boolean            True if defined.
-         *    @access public
-         */
-        function classOrInterfaceExists() {
-            return $this->_classOrInterfaceExistsWithAutoload($this->_interface, true);
-        }
+		/**
+		 *    Checks that a class or interface has been
+		 *    declared.
+		 *    @return boolean            True if defined.
+		 *    @access public
+		 */
+		function classOrInterfaceExists() {
+			return $this->_classOrInterfaceExistsWithAutoload($this->_interface, true);
+		}
 
-        /**
-         *    Needed to kill the autoload feature in PHP5
-         *    for classes created dynamically.
-         *    @return boolean        True if defined.
-         *    @access public
-         */
-        function classOrInterfaceExistsSansAutoload() {
-            return $this->_classOrInterfaceExistsWithAutoload($this->_interface, false);
-        }
+		/**
+		 *    Needed to kill the autoload feature in PHP5
+		 *    for classes created dynamically.
+		 *    @return boolean        True if defined.
+		 *    @access public
+		 */
+		function classOrInterfaceExistsSansAutoload() {
+			return $this->_classOrInterfaceExistsWithAutoload($this->_interface, false);
+		}
 
-        /**
-         *    Needed to select the autoload feature in PHP5
-         *    for classes created dynamically.
-         *    @param string $interface       Class or interface name.
-         *    @param boolean $autoload       True totriggerautoload.
-         *    @return boolean                True if interface defined.
-         *    @access private
-         */
-        function _classOrInterfaceExistsWithAutoload($interface, $autoload) {
-            if (function_exists('interface_exists')) {
-                if (interface_exists($this->_interface, $autoload)) {
-                    return true;
-                }
-            }
-            return class_exists($this->_interface, $autoload);
-        }
+		/**
+		 *    Needed to select the autoload feature in PHP5
+		 *    for classes created dynamically.
+		 *    @param string $interface       Class or interface name.
+		 *    @param boolean $autoload       True totriggerautoload.
+		 *    @return boolean                True if interface defined.
+		 *    @access private
+		 */
+		function _classOrInterfaceExistsWithAutoload($interface, $autoload) {
+			if (function_exists('interface_exists')) {
+				if (interface_exists($this->_interface, $autoload)) {
+					return true;
+				}
+			}
+			return class_exists($this->_interface, $autoload);
+		}
 
-        /**
-         *    Gets the list of methods on a class or
-         *    interface. Needs to recursively look at all of
-         *    the interfaces included.
-         *    @returns array              List of method names.
-         *    @access public
-         */
-        function getMethods() {
-            return array_unique(get_class_methods($this->_interface));
-        }
+		/**
+		 *    Gets the list of methods on a class or
+		 *    interface. Needs to recursively look at all of
+		 *    the interfaces included.
+		 *    @returns array              List of method names.
+		 *    @access public
+		 */
+		function getMethods() {
+			return array_unique(get_class_methods($this->_interface));
+		}
 
-        /**
-         *    Gets the list of interfaces from a class. If the
-         *    class name is actually an interface then just that
-         *    interface is returned.
-         *    @returns array          List of interfaces.
-         *    @access public
-         */
-        function getInterfaces() {
-            $reflection = new ReflectionClass($this->_interface);
-            if ($reflection->isInterface()) {
-            	return array($this->_interface);
-            }
-            return $this->_onlyParents($reflection->getInterfaces());
-        }
+		/**
+		 *    Gets the list of interfaces from a class. If the
+		 *    class name is actually an interface then just that
+		 *    interface is returned.
+		 *    @returns array          List of interfaces.
+		 *    @access public
+		 */
+		function getInterfaces() {
+			$reflection = new ReflectionClass($this->_interface);
+			if ($reflection->isInterface()) {
+				return array($this->_interface);
+			}
+			return $this->_onlyParents($reflection->getInterfaces());
+		}
 
-        /**
-         *    Gets the list of methods for the implemented
-         *    interfaces only.
-         *    @returns array      List of enforced method signatures.
-         *    @access public
-         */
-        function getInterfaceMethods() {
-            $methods = array();
-            foreach ($this->getInterfaces() as $interface) {
-                $methods = array_merge($methods, get_class_methods($interface));
-            }
-            return array_unique($methods);
-        }
+		/**
+		 *    Gets the list of methods for the implemented
+		 *    interfaces only.
+		 *    @returns array      List of enforced method signatures.
+		 *    @access public
+		 */
+		function getInterfaceMethods() {
+			$methods = array();
+			foreach ($this->getInterfaces() as $interface) {
+				$methods = array_merge($methods, get_class_methods($interface));
+			}
+			return array_unique($methods);
+		}
 
-        /**
-         *    Checks to see if the method signature has to be tightly
-         *    specified.
-         *    @param string $method        Method name.
-         *    @returns boolean             True if enforced.
-         *    @access private
-         */
-        function _isInterfaceMethod($method) {
-            return in_array($method, $this->getInterfaceMethods());
-        }
+		/**
+		 *    Checks to see if the method signature has to be tightly
+		 *    specified.
+		 *    @param string $method        Method name.
+		 *    @returns boolean             True if enforced.
+		 *    @access private
+		 */
+		function _isInterfaceMethod($method) {
+			return in_array($method, $this->getInterfaceMethods());
+		}
 
-        /**
-         *    Finds the parent class name.
-         *    @returns string      Parent class name.
-         *    @access public
-         */
-        function getParent() {
-            $reflection = new ReflectionClass($this->_interface);
-            $parent = $reflection->getParentClass();
-            if ($parent) {
-                return $parent->getName();
-            }
-            return false;
-        }
+		/**
+		 *    Finds the parent class name.
+		 *    @returns string      Parent class name.
+		 *    @access public
+		 */
+		function getParent() {
+			$reflection = new ReflectionClass($this->_interface);
+			$parent = $reflection->getParentClass();
+			if ($parent) {
+				return $parent->getName();
+			}
+			return false;
+		}
 
-        /**
-         *    Determines if the class is abstract.
-         *    @returns boolean      True if abstract.
-         *    @access public
-         */
-        function isAbstract() {
-            $reflection = new ReflectionClass($this->_interface);
-            return $reflection->isAbstract();
-        }
+		/**
+		 *    Determines if the class is abstract.
+		 *    @returns boolean      True if abstract.
+		 *    @access public
+		 */
+		function isAbstract() {
+			$reflection = new ReflectionClass($this->_interface);
+			return $reflection->isAbstract();
+		}
 
-        /**
-         *    Wittles a list of interfaces down to only the top
-         *    level parents.
-         *    @param array $interfaces     Reflection API interfaces
-         *                                 to reduce.
-         *    @returns array               List of parent interface names.
-         *    @access private
-         */
-        function _onlyParents($interfaces) {
-            $parents = array();
-            foreach ($interfaces as $interface) {
-                foreach($interfaces as $possible_parent) {
-                    if ($interface->getName() == $possible_parent->getName()) {
-                        continue;
-                    }
-                    if ($interface->isSubClassOf($possible_parent)) {
-                        break;
-                    }
-                }
-                $parents[] = $interface->getName();
-            }
-            return $parents;
-        }
+		/**
+		 *    Wittles a list of interfaces down to only the top
+		 *    level parents.
+		 *    @param array $interfaces     Reflection API interfaces
+		 *                                 to reduce.
+		 *    @returns array               List of parent interface names.
+		 *    @access private
+		 */
+		function _onlyParents($interfaces) {
+			$parents = array();
+			foreach ($interfaces as $interface) {
+				foreach($interfaces as $possible_parent) {
+					if ($interface->getName() == $possible_parent->getName()) {
+						continue;
+					}
+					if ($interface->isSubClassOf($possible_parent)) {
+						break;
+					}
+				}
+				$parents[] = $interface->getName();
+			}
+			return $parents;
+		}
 
-        /**
-         *    Gets the source code matching the declaration
-         *    of a method.
-         *    @param string $name    Method name.
-         *    @return string         Method signature up to last
-         *                           bracket.
-         *    @access public
-         */
-        function getSignature($name) {
-        	if ($name == '__get') {
-        		return 'function __get($key)';
-        	}
-        	if ($name == '__set') {
-        		return 'function __set($key, $value)';
-        	}
-        	if (! is_callable(array($this->_interface, $name))) {
-        		return "function $name()";
-        	}
-        	if ($this->_isInterfaceMethod($name)) {
-        	    return $this->_getFullSignature($name);
-        	}
-        	return "function $name()";
-        }
+		/**
+		 *    Gets the source code matching the declaration
+		 *    of a method.
+		 *    @param string $name    Method name.
+		 *    @return string         Method signature up to last
+		 *                           bracket.
+		 *    @access public
+		 */
+		function getSignature($name) {
+			if ($name == '__get') {
+				return 'function __get($key)';
+			}
+			if ($name == '__set') {
+				return 'function __set($key, $value)';
+			}
+			if (! is_callable(array($this->_interface, $name))) {
+				return "function $name()";
+			}
+			if ($this->_isInterfaceMethod($name)) {
+				return $this->_getFullSignature($name);
+			}
+			return "function $name()";
+		}
 
-        /**
-         *    For a signature specified in an interface, full
-         *    details must be replicated to be a valid implementation.
-         *    @param string $name    Method name.
-         *    @return string         Method signature up to last
-         *                           bracket.
-         *    @access private
-         */
-        function _getFullSignature($name) {
-	        $interface = new ReflectionClass($this->_interface);
-	        $method = $interface->getMethod($name);
-	        $reference = $method->returnsReference() ? '&' : '';
-        	return "function $reference$name(" .
-            		implode(', ', $this->_getParameterSignatures($method)) .
-            		")";
-        }
+		/**
+		 *    For a signature specified in an interface, full
+		 *    details must be replicated to be a valid implementation.
+		 *    @param string $name    Method name.
+		 *    @return string         Method signature up to last
+		 *                           bracket.
+		 *    @access private
+		 */
+		function _getFullSignature($name) {
+			$interface = new ReflectionClass($this->_interface);
+			$method = $interface->getMethod($name);
+			$reference = $method->returnsReference() ? '&' : '';
+			return "function $reference$name(" .
+					implode(', ', $this->_getParameterSignatures($method)) .
+					")";
+		}
 
-        /**
-         *    Gets the source code for each parameter.
-         *    @param ReflectionMethod $method   Method object from
-         *										reflection API
-         *    @return array                     List of strings, each
-         *                                      a snippet of code.
-         *    @access private
-         */
-        function _getParameterSignatures($method) {
-        	$signatures = array();
-            foreach ($method->getParameters() as $parameter) {
-                $type = $parameter->getClass();
-            	$signatures[] =
+		/**
+		 *    Gets the source code for each parameter.
+		 *    @param ReflectionMethod $method   Method object from
+		 *										reflection API
+		 *    @return array                     List of strings, each
+		 *                                      a snippet of code.
+		 *    @access private
+		 */
+		function _getParameterSignatures($method) {
+			$signatures = array();
+			foreach ($method->getParameters() as $parameter) {
+				$type = $parameter->getClass();
+				$signatures[] =
 					(! is_null($type) ? $type->getName() . ' ' : '') .
-            			($parameter->isPassedByReference() ? '&' : '') .
-            			'$' . $this->_suppressSpurious($parameter->getName()) .
-            			($this->_isOptional($parameter) ? ' = null' : '');
-            }
-            return $signatures;
-        }
+						($parameter->isPassedByReference() ? '&' : '') .
+						'$' . $this->_suppressSpurious($parameter->getName()) .
+						($this->_isOptional($parameter) ? ' = null' : '');
+			}
+			return $signatures;
+		}
 
-        /**
-         *    The SPL library has problems with the
-         *    Reflection library. In particular, you can
-         *    get extra characters in parameter names :(.
-         *    @param string $name    Parameter name.
-         *    @return string         Cleaner name.
-         *    @access private
-         */
-        function _suppressSpurious($name) {
-            return str_replace(array('[', ']', ' '), '', $name);
-        }
+		/**
+		 *    The SPL library has problems with the
+		 *    Reflection library. In particular, you can
+		 *    get extra characters in parameter names :(.
+		 *    @param string $name    Parameter name.
+		 *    @return string         Cleaner name.
+		 *    @access private
+		 */
+		function _suppressSpurious($name) {
+			return str_replace(array('[', ']', ' '), '', $name);
+		}
 
-        /**
-         *    Test of a reflection parameter being optional
-         *    that works with early versions of PHP5.
-         *    @param reflectionParameter $parameter    Is this optional.
-         *    @return boolean                          True if optional.
-         *    @access private
-         */
-        function _isOptional($parameter) {
-            if (method_exists($parameter, 'isOptional')) {
-                return $parameter->isOptional();
-            }
-            return false;
-        }
-    }
\ No newline at end of file
+		/**
+		 *    Test of a reflection parameter being optional
+		 *    that works with early versions of PHP5.
+		 *    @param reflectionParameter $parameter    Is this optional.
+		 *    @return boolean                          True if optional.
+		 *    @access private
+		 */
+		function _isOptional($parameter) {
+			if (method_exists($parameter, 'isOptional')) {
+				return $parameter->isOptional();
+			}
+			return false;
+		}
+	}
\ No newline at end of file

tests/test_tools/simpletest/unit_tester.php

Indentation +343 added lines, -343 removed lines

@@ -1,372 +1,372 @@
 <?php
-    /**
-     *	base include file for SimpleTest
-     *	@package	SimpleTest
-     *	@subpackage	UnitTester
-     *	@version	$Id: unit_tester.php 1398 2006-09-08 19:31:03Z xue $
-     */
+	/**
+	 *	base include file for SimpleTest
+	 *	@package	SimpleTest
+	 *	@subpackage	UnitTester
+	 *	@version	$Id: unit_tester.php 1398 2006-09-08 19:31:03Z xue $
+	 */
 
-    /**#@+
+	/**#@+
      *	include other SimpleTest class files
      */
-    require_once(dirname(__FILE__) . '/test_case.php');
-    require_once(dirname(__FILE__) . '/dumper.php');
-    /**#@-*/
+	require_once(dirname(__FILE__) . '/test_case.php');
+	require_once(dirname(__FILE__) . '/dumper.php');
+	/**#@-*/
 
-    /**
-     *    Standard unit test class for day to day testing
-     *    of PHP code XP style. Adds some useful standard
-     *    assertions.
+	/**
+	 *    Standard unit test class for day to day testing
+	 *    of PHP code XP style. Adds some useful standard
+	 *    assertions.
 	 *	  @package	SimpleTest
 	 *	  @subpackage	UnitTester
-     */
-    class UnitTestCase extends SimpleTestCase {
+	 */
+	class UnitTestCase extends SimpleTestCase {
 
-        /**
-         *    Creates an empty test case. Should be subclassed
-         *    with test methods for a functional test case.
-         *    @param string $label     Name of test case. Will use
-         *                             the class name if none specified.
-         *    @access public
-         */
-        function UnitTestCase($label = false) {
-            if (! $label) {
-                $label = get_class($this);
-            }
-            $this->SimpleTestCase($label);
-        }
+		/**
+		 *    Creates an empty test case. Should be subclassed
+		 *    with test methods for a functional test case.
+		 *    @param string $label     Name of test case. Will use
+		 *                             the class name if none specified.
+		 *    @access public
+		 */
+		function UnitTestCase($label = false) {
+			if (! $label) {
+				$label = get_class($this);
+			}
+			$this->SimpleTestCase($label);
+		}
 
-        /**
-         *    Will be true if the value is null.
-         *    @param null $value       Supposedly null value.
-         *    @param string $message   Message to display.
-         *    @return boolean                        True on pass
-         *    @access public
-         */
-        function assertNull($value, $message = "%s") {
-            $dumper = new SimpleDumper();
-            $message = sprintf(
-                    $message,
-                    "[" . $dumper->describeValue($value) . "] should be null");
-            return $this->assertTrue(! isset($value), $message);
-        }
+		/**
+		 *    Will be true if the value is null.
+		 *    @param null $value       Supposedly null value.
+		 *    @param string $message   Message to display.
+		 *    @return boolean                        True on pass
+		 *    @access public
+		 */
+		function assertNull($value, $message = "%s") {
+			$dumper = new SimpleDumper();
+			$message = sprintf(
+					$message,
+					"[" . $dumper->describeValue($value) . "] should be null");
+			return $this->assertTrue(! isset($value), $message);
+		}
 
-        /**
-         *    Will be true if the value is set.
-         *    @param mixed $value           Supposedly set value.
-         *    @param string $message        Message to display.
-         *    @return boolean               True on pass.
-         *    @access public
-         */
-        function assertNotNull($value, $message = "%s") {
-            $dumper = new SimpleDumper();
-            $message = sprintf(
-                    $message,
-                    "[" . $dumper->describeValue($value) . "] should not be null");
-            return $this->assertTrue(isset($value), $message);
-        }
+		/**
+		 *    Will be true if the value is set.
+		 *    @param mixed $value           Supposedly set value.
+		 *    @param string $message        Message to display.
+		 *    @return boolean               True on pass.
+		 *    @access public
+		 */
+		function assertNotNull($value, $message = "%s") {
+			$dumper = new SimpleDumper();
+			$message = sprintf(
+					$message,
+					"[" . $dumper->describeValue($value) . "] should not be null");
+			return $this->assertTrue(isset($value), $message);
+		}
 
-        /**
-         *    Type and class test. Will pass if class
-         *    matches the type name or is a subclass or
-         *    if not an object, but the type is correct.
-         *    @param mixed $object         Object to test.
-         *    @param string $type          Type name as string.
-         *    @param string $message       Message to display.
-         *    @return boolean              True on pass.
-         *    @access public
-         */
-        function assertIsA($object, $type, $message = "%s") {
-            return $this->assert(
-                    new IsAExpectation($type),
-                    $object,
-                    $message);
-        }
+		/**
+		 *    Type and class test. Will pass if class
+		 *    matches the type name or is a subclass or
+		 *    if not an object, but the type is correct.
+		 *    @param mixed $object         Object to test.
+		 *    @param string $type          Type name as string.
+		 *    @param string $message       Message to display.
+		 *    @return boolean              True on pass.
+		 *    @access public
+		 */
+		function assertIsA($object, $type, $message = "%s") {
+			return $this->assert(
+					new IsAExpectation($type),
+					$object,
+					$message);
+		}
 
-        /**
-         *    Type and class mismatch test. Will pass if class
-         *    name or underling type does not match the one
-         *    specified.
-         *    @param mixed $object         Object to test.
-         *    @param string $type          Type name as string.
-         *    @param string $message       Message to display.
-         *    @return boolean              True on pass.
-         *    @access public
-         */
-        function assertNotA($object, $type, $message = "%s") {
-            return $this->assert(
-                    new NotAExpectation($type),
-                    $object,
-                    $message);
-        }
+		/**
+		 *    Type and class mismatch test. Will pass if class
+		 *    name or underling type does not match the one
+		 *    specified.
+		 *    @param mixed $object         Object to test.
+		 *    @param string $type          Type name as string.
+		 *    @param string $message       Message to display.
+		 *    @return boolean              True on pass.
+		 *    @access public
+		 */
+		function assertNotA($object, $type, $message = "%s") {
+			return $this->assert(
+					new NotAExpectation($type),
+					$object,
+					$message);
+		}
 
-        /**
-         *    Will trigger a pass if the two parameters have
-         *    the same value only. Otherwise a fail.
-         *    @param mixed $first          Value to compare.
-         *    @param mixed $second         Value to compare.
-         *    @param string $message       Message to display.
-         *    @return boolean              True on pass
-         *    @access public
-         */
-        function assertEqual($first, $second, $message = "%s") {
-            return $this->assert(
-                    new EqualExpectation($first),
-                    $second,
-                    $message);
-        }
+		/**
+		 *    Will trigger a pass if the two parameters have
+		 *    the same value only. Otherwise a fail.
+		 *    @param mixed $first          Value to compare.
+		 *    @param mixed $second         Value to compare.
+		 *    @param string $message       Message to display.
+		 *    @return boolean              True on pass
+		 *    @access public
+		 */
+		function assertEqual($first, $second, $message = "%s") {
+			return $this->assert(
+					new EqualExpectation($first),
+					$second,
+					$message);
+		}
 
-        /**
-         *    Will trigger a pass if the two parameters have
-         *    a different value. Otherwise a fail.
-         *    @param mixed $first           Value to compare.
-         *    @param mixed $second          Value to compare.
-         *    @param string $message        Message to display.
-         *    @return boolean               True on pass
-         *    @access public
-         */
-        function assertNotEqual($first, $second, $message = "%s") {
-            return $this->assert(
-                    new NotEqualExpectation($first),
-                    $second,
-                    $message);
-        }
+		/**
+		 *    Will trigger a pass if the two parameters have
+		 *    a different value. Otherwise a fail.
+		 *    @param mixed $first           Value to compare.
+		 *    @param mixed $second          Value to compare.
+		 *    @param string $message        Message to display.
+		 *    @return boolean               True on pass
+		 *    @access public
+		 */
+		function assertNotEqual($first, $second, $message = "%s") {
+			return $this->assert(
+					new NotEqualExpectation($first),
+					$second,
+					$message);
+		}
 
-        /**
-         *    Will trigger a pass if the if the first parameter
-         *    is near enough to the second by the margin.
-         *    @param mixed $first          Value to compare.
-         *    @param mixed $second         Value to compare.
-         *    @param mixed $margin         Fuzziness of match.
-         *    @param string $message       Message to display.
-         *    @return boolean              True on pass
-         *    @access public
-         */
-        function assertWithinMargin($first, $second, $margin, $message = "%s") {
-            return $this->assert(
-                    new WithinMarginExpectation($first, $margin),
-                    $second,
-                    $message);
-        }
+		/**
+		 *    Will trigger a pass if the if the first parameter
+		 *    is near enough to the second by the margin.
+		 *    @param mixed $first          Value to compare.
+		 *    @param mixed $second         Value to compare.
+		 *    @param mixed $margin         Fuzziness of match.
+		 *    @param string $message       Message to display.
+		 *    @return boolean              True on pass
+		 *    @access public
+		 */
+		function assertWithinMargin($first, $second, $margin, $message = "%s") {
+			return $this->assert(
+					new WithinMarginExpectation($first, $margin),
+					$second,
+					$message);
+		}
 
-        /**
-         *    Will trigger a pass if the two parameters differ
-         *    by more than the margin.
-         *    @param mixed $first          Value to compare.
-         *    @param mixed $second         Value to compare.
-         *    @param mixed $margin         Fuzziness of match.
-         *    @param string $message       Message to display.
-         *    @return boolean              True on pass
-         *    @access public
-         */
-        function assertOutsideMargin($first, $second, $margin, $message = "%s") {
-            return $this->assert(
-                    new OutsideMarginExpectation($first, $margin),
-                    $second,
-                    $message);
-        }
+		/**
+		 *    Will trigger a pass if the two parameters differ
+		 *    by more than the margin.
+		 *    @param mixed $first          Value to compare.
+		 *    @param mixed $second         Value to compare.
+		 *    @param mixed $margin         Fuzziness of match.
+		 *    @param string $message       Message to display.
+		 *    @return boolean              True on pass
+		 *    @access public
+		 */
+		function assertOutsideMargin($first, $second, $margin, $message = "%s") {
+			return $this->assert(
+					new OutsideMarginExpectation($first, $margin),
+					$second,
+					$message);
+		}
 
-        /**
-         *    Will trigger a pass if the two parameters have
-         *    the same value and same type. Otherwise a fail.
-         *    @param mixed $first           Value to compare.
-         *    @param mixed $second          Value to compare.
-         *    @param string $message        Message to display.
-         *    @return boolean               True on pass
-         *    @access public
-         */
-        function assertIdentical($first, $second, $message = "%s") {
-            return $this->assert(
-                    new IdenticalExpectation($first),
-                    $second,
-                    $message);
-        }
+		/**
+		 *    Will trigger a pass if the two parameters have
+		 *    the same value and same type. Otherwise a fail.
+		 *    @param mixed $first           Value to compare.
+		 *    @param mixed $second          Value to compare.
+		 *    @param string $message        Message to display.
+		 *    @return boolean               True on pass
+		 *    @access public
+		 */
+		function assertIdentical($first, $second, $message = "%s") {
+			return $this->assert(
+					new IdenticalExpectation($first),
+					$second,
+					$message);
+		}
 
-        /**
-         *    Will trigger a pass if the two parameters have
-         *    the different value or different type.
-         *    @param mixed $first           Value to compare.
-         *    @param mixed $second          Value to compare.
-         *    @param string $message        Message to display.
-         *    @return boolean               True on pass
-         *    @access public
-         */
-        function assertNotIdentical($first, $second, $message = "%s") {
-            return $this->assert(
-                    new NotIdenticalExpectation($first),
-                    $second,
-                    $message);
-        }
+		/**
+		 *    Will trigger a pass if the two parameters have
+		 *    the different value or different type.
+		 *    @param mixed $first           Value to compare.
+		 *    @param mixed $second          Value to compare.
+		 *    @param string $message        Message to display.
+		 *    @return boolean               True on pass
+		 *    @access public
+		 */
+		function assertNotIdentical($first, $second, $message = "%s") {
+			return $this->assert(
+					new NotIdenticalExpectation($first),
+					$second,
+					$message);
+		}
 
-        /**
-         *    Will trigger a pass if both parameters refer
-         *    to the same object. Fail otherwise.
-         *    @param mixed $first           Object reference to check.
-         *    @param mixed $second          Hopefully the same object.
-         *    @param string $message        Message to display.
-         *    @return boolean               True on pass
-         *    @access public
-         */
-        function assertReference($first, $second, $message = "%s") {
-            $dumper = new SimpleDumper();
-            $message = sprintf(
-                    $message,
-                    "[" . $dumper->describeValue($first) .
-                            "] and [" . $dumper->describeValue($second) .
-                            "] should reference the same object");
-            return $this->assertTrue(
-                    SimpleTestCompatibility::isReference($first, $second),
-                    $message);
-        }
+		/**
+		 *    Will trigger a pass if both parameters refer
+		 *    to the same object. Fail otherwise.
+		 *    @param mixed $first           Object reference to check.
+		 *    @param mixed $second          Hopefully the same object.
+		 *    @param string $message        Message to display.
+		 *    @return boolean               True on pass
+		 *    @access public
+		 */
+		function assertReference($first, $second, $message = "%s") {
+			$dumper = new SimpleDumper();
+			$message = sprintf(
+					$message,
+					"[" . $dumper->describeValue($first) .
+							"] and [" . $dumper->describeValue($second) .
+							"] should reference the same object");
+			return $this->assertTrue(
+					SimpleTestCompatibility::isReference($first, $second),
+					$message);
+		}
 
-        /**
-         *    Will trigger a pass if both parameters refer
-         *    to different objects. Fail otherwise. The objects
-         *    have to be identical though.
-         *    @param mixed $first           Object reference to check.
-         *    @param mixed $second          Hopefully not the same object.
-         *    @param string $message        Message to display.
-         *    @return boolean               True on pass
-         *    @access public
-         */
-        function assertClone($first, $second, $message = "%s") {
-            $dumper = new SimpleDumper();
-            $message = sprintf(
-                    $message,
-                    "[" . $dumper->describeValue($first) .
-                            "] and [" . $dumper->describeValue($second) .
-                            "] should not be the same object");
-            $identical = new IdenticalExpectation($first);
-            return $this->assertTrue(
-                    $identical->test($second) &&
-                            ! SimpleTestCompatibility::isReference($first, $second),
-                    $message);
-        }
+		/**
+		 *    Will trigger a pass if both parameters refer
+		 *    to different objects. Fail otherwise. The objects
+		 *    have to be identical though.
+		 *    @param mixed $first           Object reference to check.
+		 *    @param mixed $second          Hopefully not the same object.
+		 *    @param string $message        Message to display.
+		 *    @return boolean               True on pass
+		 *    @access public
+		 */
+		function assertClone($first, $second, $message = "%s") {
+			$dumper = new SimpleDumper();
+			$message = sprintf(
+					$message,
+					"[" . $dumper->describeValue($first) .
+							"] and [" . $dumper->describeValue($second) .
+							"] should not be the same object");
+			$identical = new IdenticalExpectation($first);
+			return $this->assertTrue(
+					$identical->test($second) &&
+							! SimpleTestCompatibility::isReference($first, $second),
+					$message);
+		}
 
-        /**
-         *    @deprecated
-         */
-        function assertCopy($first, $second, $message = "%s") {
-            $dumper = new SimpleDumper();
-            $message = sprintf(
-                    $message,
-                    "[" . $dumper->describeValue($first) .
-                            "] and [" . $dumper->describeValue($second) .
-                            "] should not be the same object");
-            return $this->assertFalse(
-                    SimpleTestCompatibility::isReference($first, $second),
-                    $message);
-        }
+		/**
+		 *    @deprecated
+		 */
+		function assertCopy($first, $second, $message = "%s") {
+			$dumper = new SimpleDumper();
+			$message = sprintf(
+					$message,
+					"[" . $dumper->describeValue($first) .
+							"] and [" . $dumper->describeValue($second) .
+							"] should not be the same object");
+			return $this->assertFalse(
+					SimpleTestCompatibility::isReference($first, $second),
+					$message);
+		}
 
-        /**
-         *    Will trigger a pass if the Perl regex pattern
-         *    is found in the subject. Fail otherwise.
-         *    @param string $pattern    Perl regex to look for including
-         *                              the regex delimiters.
-         *    @param string $subject    String to search in.
-         *    @param string $message    Message to display.
-         *    @return boolean           True on pass
-         *    @access public
-         */
-        function assertPattern($pattern, $subject, $message = "%s") {
-            return $this->assert(
-                    new PatternExpectation($pattern),
-                    $subject,
-                    $message);
-        }
+		/**
+		 *    Will trigger a pass if the Perl regex pattern
+		 *    is found in the subject. Fail otherwise.
+		 *    @param string $pattern    Perl regex to look for including
+		 *                              the regex delimiters.
+		 *    @param string $subject    String to search in.
+		 *    @param string $message    Message to display.
+		 *    @return boolean           True on pass
+		 *    @access public
+		 */
+		function assertPattern($pattern, $subject, $message = "%s") {
+			return $this->assert(
+					new PatternExpectation($pattern),
+					$subject,
+					$message);
+		}
 
-        /**
-         *	  @deprecated
-         */
-        function assertWantedPattern($pattern, $subject, $message = "%s") {
-        	return $this->assertPattern($pattern, $subject, $message);
-        }
+		/**
+		 *	  @deprecated
+		 */
+		function assertWantedPattern($pattern, $subject, $message = "%s") {
+			return $this->assertPattern($pattern, $subject, $message);
+		}
 
-        /**
-         *    Will trigger a pass if the perl regex pattern
-         *    is not present in subject. Fail if found.
-         *    @param string $pattern    Perl regex to look for including
-         *                              the regex delimiters.
-         *    @param string $subject    String to search in.
-         *    @param string $message    Message to display.
-         *    @return boolean           True on pass
-         *    @access public
-         */
-        function assertNoPattern($pattern, $subject, $message = "%s") {
-            return $this->assert(
-                    new NoPatternExpectation($pattern),
-                    $subject,
-                    $message);
-        }
+		/**
+		 *    Will trigger a pass if the perl regex pattern
+		 *    is not present in subject. Fail if found.
+		 *    @param string $pattern    Perl regex to look for including
+		 *                              the regex delimiters.
+		 *    @param string $subject    String to search in.
+		 *    @param string $message    Message to display.
+		 *    @return boolean           True on pass
+		 *    @access public
+		 */
+		function assertNoPattern($pattern, $subject, $message = "%s") {
+			return $this->assert(
+					new NoPatternExpectation($pattern),
+					$subject,
+					$message);
+		}
 
-        /**
-         *	  @deprecated
-         */
-        function assertNoUnwantedPattern($pattern, $subject, $message = "%s") {
-        	return $this->assertNoPattern($pattern, $subject, $message);
-        }
+		/**
+		 *	  @deprecated
+		 */
+		function assertNoUnwantedPattern($pattern, $subject, $message = "%s") {
+			return $this->assertNoPattern($pattern, $subject, $message);
+		}
 
-        /**
-         *    Confirms that no errors have occoured so
-         *    far in the test method.
-         *    @param string $message    Message to display.
-         *    @return boolean           True on pass
-         *    @access public
-         */
-        function assertNoErrors($message = "%s") {
-            $queue = &SimpleErrorQueue::instance();
-            return $this->assertTrue(
-                    $queue->isEmpty(),
-                    sprintf($message, "Should be no errors"));
-        }
+		/**
+		 *    Confirms that no errors have occoured so
+		 *    far in the test method.
+		 *    @param string $message    Message to display.
+		 *    @return boolean           True on pass
+		 *    @access public
+		 */
+		function assertNoErrors($message = "%s") {
+			$queue = &SimpleErrorQueue::instance();
+			return $this->assertTrue(
+					$queue->isEmpty(),
+					sprintf($message, "Should be no errors"));
+		}
 
-        /**
-         *    Confirms that an error has occoured and
-         *    optionally that the error text matches exactly.
-         *    @param string $expected   Expected error text or
-         *                              false for no check.
-         *    @param string $message    Message to display.
-         *    @return boolean           True on pass
-         *    @access public
-         */
-        function assertError($expected = false, $message = "%s") {
-            $queue = &SimpleErrorQueue::instance();
-            if ($queue->isEmpty()) {
-                $this->fail(sprintf($message, "Expected error not found"));
-                return;
-            }
-            list($severity, $content, $file, $line, $globals) = $queue->extract();
-            $severity = SimpleErrorQueue::getSeverityAsString($severity);
-            if (! $expected) {
-                return $this->pass(
-                        "Captured a PHP error of [$content] severity [$severity] in [$file] line [$line] -> %s");
-            }
-            $expected = $this->_coerceToExpectation($expected);
-            return $this->assert(
-                    $expected,
-                    $content,
-                    "Expected PHP error [$content] severity [$severity] in [$file] line [$line] -> %s");
-        }
+		/**
+		 *    Confirms that an error has occoured and
+		 *    optionally that the error text matches exactly.
+		 *    @param string $expected   Expected error text or
+		 *                              false for no check.
+		 *    @param string $message    Message to display.
+		 *    @return boolean           True on pass
+		 *    @access public
+		 */
+		function assertError($expected = false, $message = "%s") {
+			$queue = &SimpleErrorQueue::instance();
+			if ($queue->isEmpty()) {
+				$this->fail(sprintf($message, "Expected error not found"));
+				return;
+			}
+			list($severity, $content, $file, $line, $globals) = $queue->extract();
+			$severity = SimpleErrorQueue::getSeverityAsString($severity);
+			if (! $expected) {
+				return $this->pass(
+						"Captured a PHP error of [$content] severity [$severity] in [$file] line [$line] -> %s");
+			}
+			$expected = $this->_coerceToExpectation($expected);
+			return $this->assert(
+					$expected,
+					$content,
+					"Expected PHP error [$content] severity [$severity] in [$file] line [$line] -> %s");
+		}
 
-        /**
-         *    Creates an equality 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 (SimpleTestCompatibility::isA($expected, 'SimpleExpectation')) {
-                return $expected;
-            }
-            return new EqualExpectation($expected);
-        }
+		/**
+		 *    Creates an equality 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 (SimpleTestCompatibility::isA($expected, 'SimpleExpectation')) {
+				return $expected;
+			}
+			return new EqualExpectation($expected);
+		}
 
-        /**
-         *    @deprecated
-         */
-        function assertErrorPattern($pattern, $message = "%s") {
-            return $this->assertError(new PatternExpectation($pattern), $message);
-        }
-    }
+		/**
+		 *    @deprecated
+		 */
+		function assertErrorPattern($pattern, $message = "%s") {
+			return $this->assertError(new PatternExpectation($pattern), $message);
+		}
+	}

tests/test_tools/simpletest/mock_objects.php

Indentation +1257 added lines, -1257 removed lines

@@ -1,1272 +1,1272 @@
 <?php
-    /**
-     *	base include file for SimpleTest
-     *	@package	SimpleTest
-     *	@subpackage	MockObjects
-     *	@version	$Id: mock_objects.php 1532 2006-12-01 12:28:55Z xue $
-     */
-
-    /**#@+
+	/**
+	 *	base include file for SimpleTest
+	 *	@package	SimpleTest
+	 *	@subpackage	MockObjects
+	 *	@version	$Id: mock_objects.php 1532 2006-12-01 12:28:55Z xue $
+	 */
+
+	/**#@+
      * 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', '*');
-    }
-
-    /**
-     *    A wildcard expectation always matches.
+	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', '*');
+	}
+
+	/**
+	 *    A wildcard expectation always matches.
 	 *    @package SimpleTest
 	 *    @subpackage MockObjects
-     */
-    class AnythingExpectation extends SimpleExpectation {
-
-        /**
-         *    Tests the expectation. Always true.
-         *    @param mixed $compare  Ignored.
-         *    @return boolean        True.
-         *    @access public
-         */
-        function test($compare) {
-            return true;
-        }
-
-        /**
-         *    Returns a human readable test message.
-         *    @param mixed $compare      Comparison value.
-         *    @return string             Description of success
-         *                               or failure.
-         *    @access public
-         */
-        function testMessage($compare) {
-            $dumper = $this->_getDumper();
-            return 'Anything always matches [' . $dumper->describeValue($compare) . ']';
-        }
-    }
-
-    /**
-     *    Parameter comparison assertion.
+	 */
+	class AnythingExpectation extends SimpleExpectation {
+
+		/**
+		 *    Tests the expectation. Always true.
+		 *    @param mixed $compare  Ignored.
+		 *    @return boolean        True.
+		 *    @access public
+		 */
+		function test($compare) {
+			return true;
+		}
+
+		/**
+		 *    Returns a human readable test message.
+		 *    @param mixed $compare      Comparison value.
+		 *    @return string             Description of success
+		 *                               or failure.
+		 *    @access public
+		 */
+		function testMessage($compare) {
+			$dumper = $this->_getDumper();
+			return 'Anything always matches [' . $dumper->describeValue($compare) . ']';
+		}
+	}
+
+	/**
+	 *    Parameter comparison assertion.
 	 *    @package SimpleTest
 	 *    @subpackage MockObjects
-     */
-    class ParametersExpectation extends SimpleExpectation {
-        protected $_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 mixed $wildcard    Any parameter matching this
-         *                              will always match.
-         *    @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]) . "]";
-                }
-            }
-            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.
-     */
-    class CallCountExpectation extends SimpleExpectation {
-        protected $_method;
-        protected $_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.
-     */
-    class MinimumCallCountExpectation extends SimpleExpectation {
-        protected $_method;
-        protected $_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.
-     */
-    class MaximumCallCountExpectation extends SimpleExpectation {
-        protected $_method;
-        protected $_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 values and references by searching the
-     *    parameter lists until a match is found.
+	 */
+	class ParametersExpectation extends SimpleExpectation {
+		protected $_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 mixed $wildcard    Any parameter matching this
+		 *                              will always match.
+		 *    @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]) . "]";
+				}
+			}
+			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.
+	 */
+	class CallCountExpectation extends SimpleExpectation {
+		protected $_method;
+		protected $_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.
+	 */
+	class MinimumCallCountExpectation extends SimpleExpectation {
+		protected $_method;
+		protected $_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.
+	 */
+	class MaximumCallCountExpectation extends SimpleExpectation {
+		protected $_method;
+		protected $_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 values and references by searching the
+	 *    parameter lists until a match is found.
 	 *    @package SimpleTest
 	 *    @subpackage MockObjects
-     */
-    class CallMap {
-        protected $_map;
-
-        /**
-         *    Creates an empty call map.
-         *    @access public
-         */
-        function CallMap() {
-            $this->_map = array();
-        }
-
-        /**
-         *    Stashes a value against a method call.
-         *    @param array $parameters    Arguments including wildcards.
-         *    @param mixed $value         Value copied into the map.
-         *    @access public
-         */
-        function addValue($parameters, $value) {
-            $this->addReference($parameters, $value);
-        }
-
-        /**
-         *    Stashes a reference against a method call.
-         *    @param array $parameters    Array of arguments (including wildcards).
-         *    @param mixed $reference     Array reference placed in the map.
-         *    @access public
-         */
-        function addReference($parameters, $reference) {
-            $place = count($this->_map);
-            $this->_map[$place] = array();
-            $this->_map[$place]["params"] = new ParametersExpectation($parameters);
-            $this->_map[$place]["content"] = $reference;
-        }
-
-        /**
-         *    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 &findFirstMatch($parameters) {
-            $slot = $this->_findFirstSlot($parameters);
-            if (!isset($slot)) {
-                $null = null;
-                return $null;
-            }
-            return $slot["content"];
-        }
-
-        /**
-         *    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);
-        }
-
-        /**
-         *    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;
-        }
-    }
-
-    /**
-     *    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.
+	 */
+	class CallMap {
+		protected $_map;
+
+		/**
+		 *    Creates an empty call map.
+		 *    @access public
+		 */
+		function CallMap() {
+			$this->_map = array();
+		}
+
+		/**
+		 *    Stashes a value against a method call.
+		 *    @param array $parameters    Arguments including wildcards.
+		 *    @param mixed $value         Value copied into the map.
+		 *    @access public
+		 */
+		function addValue($parameters, $value) {
+			$this->addReference($parameters, $value);
+		}
+
+		/**
+		 *    Stashes a reference against a method call.
+		 *    @param array $parameters    Array of arguments (including wildcards).
+		 *    @param mixed $reference     Array reference placed in the map.
+		 *    @access public
+		 */
+		function addReference($parameters, $reference) {
+			$place = count($this->_map);
+			$this->_map[$place] = array();
+			$this->_map[$place]["params"] = new ParametersExpectation($parameters);
+			$this->_map[$place]["content"] = $reference;
+		}
+
+		/**
+		 *    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 &findFirstMatch($parameters) {
+			$slot = $this->_findFirstSlot($parameters);
+			if (!isset($slot)) {
+				$null = null;
+				return $null;
+			}
+			return $slot["content"];
+		}
+
+		/**
+		 *    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);
+		}
+
+		/**
+		 *    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;
+		}
+	}
+
+	/**
+	 *    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.
 	 *    @package SimpleTest
 	 *    @subpackage MockObjects
-     */
-    class SimpleMock {
-        protected $_wildcard = MOCK_ANYTHING;
-        protected $_is_strict = true;
-        protected $_returns;
-        protected $_return_sequence;
-        protected $_call_counts;
-        protected $_expected_counts;
-        protected $_max_counts;
-        protected $_expected_args;
-        protected $_expected_args_at;
-
-        /**
-         *    Creates an empty return list and expectation list.
-         *    All call counts are set to zero.
-         *    @param SimpleTestCase $test    Test case to test expectations in.
-         *    @param mixed $wildcard         Parameter matching wildcard.
-         *    @param boolean $is_strict      Enables method name checks on
-         *                                   expectations.
-         */
-        function SimpleMock() {
-            $this->_returns = array();
-            $this->_return_sequence = array();
-            $this->_call_counts = array();
-            $test = $this->_getCurrentTestCase();
-            $test->tell($this);
-            $this->_expected_counts = array();
-            $this->_max_counts = array();
-            $this->_expected_args = array();
-            $this->_expected_args_at = array();
-        }
-
-        /**
-         *    Disables a name check when setting expectations.
-         *    This hack is needed for the partial mocks.
-         *    @access public
-         */
-        function disableExpectationNameChecks() {
-            $this->_is_strict = false;
-        }
-
-        /**
-         *    Changes the default wildcard object.
-         *    @param mixed $wildcard         Parameter matching wildcard.
-         *    @access public
-         */
-        function setWildcard($wildcard) {
-            $this->_wildcard = $wildcard;
-        }
-
-        /**
-         *    Finds currently running test.
-         *    @return SimpeTestCase    Current test case.
-         *    @access protected
-         */
-        function &_getCurrentTestCase() {
-            return SimpleTest::getCurrent();
-        }
-
-        /**
-         *    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                      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");
-            $args = $this->_replaceWildcards($args);
-            $method = strtolower($method);
-            if (! isset($this->_returns[$method])) {
-                $this->_returns[$method] = new CallMap();
-            }
-            $this->_returns[$method]->addValue($args, $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");
-            $args = $this->_replaceWildcards($args);
-            $method = strtolower($method);
-            if (! isset($this->_return_sequence[$method])) {
-                $this->_return_sequence[$method] = array();
-            }
-            if (! isset($this->_return_sequence[$method][$timing])) {
-                $this->_return_sequence[$method][$timing] = new CallMap();
-            }
-            $this->_return_sequence[$method][$timing]->addValue($args, $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");
-            $args = $this->_replaceWildcards($args);
-            $method = strtolower($method);
-            if (! isset($this->_returns[$method])) {
-                $this->_returns[$method] = new CallMap();
-            }
-            $this->_returns[$method]->addReference($args, $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");
-            $args = $this->_replaceWildcards($args);
-            $method = strtolower($method);
-            if (! isset($this->_return_sequence[$method])) {
-                $this->_return_sequence[$method] = array();
-            }
-            if (! isset($this->_return_sequence[$method][$timing])) {
-                $this->_return_sequence[$method][$timing] = new CallMap();
-            }
-            $this->_return_sequence[$method][$timing]->addReference($args, $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');
-            $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->expectArguments($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->expectArguments($method, $args, $message);
-            }
-        }
-
-        /**
-         *    @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 $method    Current method name.
-         *    @access public
-         */
-        function atTestEnd($method) {
-            foreach ($this->_expected_counts as $method => $expectation) {
-                $this->_assertTrue(
-                        $expectation->test($this->getCallCount($method)),
-                        $expectation->overlayMessage($this->getCallCount($method)));
-            }
-            foreach ($this->_max_counts as $method => $expectation) {
-                if ($expectation->test($this->getCallCount($method))) {
-                    $this->_assertTrue(
-                            true,
-                            $expectation->overlayMessage($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->_getReturn($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.
-         *    @access protected
-         */
-        function &_getReturn($method, $args, $step) {
-            if (isset($this->_return_sequence[$method][$step])) {
-                if ($this->_return_sequence[$method][$step]->isMatch($args)) {
-                    $result = $this->_return_sequence[$method][$step]->findFirstMatch($args);
-                    return $result;
-                }
-            }
-            if (isset($this->_returns[$method])) {
-                $result = $this->_returns[$method]->findFirstMatch($args);
-                return $result;
-            }
-            $null = null;
-            return $null;
-        }
-
-        /**
-         *    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) {
-            if (isset($this->_max_counts[$method])) {
-                if (! $this->_max_counts[$method]->test($timing + 1)) {
-                    $this->_assertTrue(
-                            false,
-                            $this->_max_counts[$method]->overlayMessage($timing + 1));
-                }
-            }
-            if (isset($this->_expected_args_at[$timing][$method])) {
-                $this->_assertTrue(
-                        $this->_expected_args_at[$timing][$method]->test($args),
-                        "Mock method [$method] at [$timing] -> " .
-                                $this->_expected_args_at[$timing][$method]->overlayMessage($args));
-            } elseif (isset($this->_expected_args[$method])) {
-                $this->_assertTrue(
-                        $this->_expected_args[$method]->test($args),
-                        "Mock method [$method] -> " . $this->_expected_args[$method]->overlayMessage($args));
-            }
-        }
-
-        /**
-         *    Triggers an assertion on the held test case.
-         *    Should be overridden when using another test
-         *    framework other than the SimpleTest one if the
-         *    assertion method has a different name.
-         *    @param boolean $assertion     True will pass.
-         *    @param string $message        Message that will go with
-         *                                  the test event.
-         *    @access protected
-         */
-        function _assertTrue($assertion, $message) {
-            $test = $this->_getCurrentTestCase();
-            $test->assertTrue($assertion, $message);
-        }
-    }
-
-    /**
-     *    Static methods only service class for code generation of
-     *    mock objects.
+	 */
+	class SimpleMock {
+		protected $_wildcard = MOCK_ANYTHING;
+		protected $_is_strict = true;
+		protected $_returns;
+		protected $_return_sequence;
+		protected $_call_counts;
+		protected $_expected_counts;
+		protected $_max_counts;
+		protected $_expected_args;
+		protected $_expected_args_at;
+
+		/**
+		 *    Creates an empty return list and expectation list.
+		 *    All call counts are set to zero.
+		 *    @param SimpleTestCase $test    Test case to test expectations in.
+		 *    @param mixed $wildcard         Parameter matching wildcard.
+		 *    @param boolean $is_strict      Enables method name checks on
+		 *                                   expectations.
+		 */
+		function SimpleMock() {
+			$this->_returns = array();
+			$this->_return_sequence = array();
+			$this->_call_counts = array();
+			$test = $this->_getCurrentTestCase();
+			$test->tell($this);
+			$this->_expected_counts = array();
+			$this->_max_counts = array();
+			$this->_expected_args = array();
+			$this->_expected_args_at = array();
+		}
+
+		/**
+		 *    Disables a name check when setting expectations.
+		 *    This hack is needed for the partial mocks.
+		 *    @access public
+		 */
+		function disableExpectationNameChecks() {
+			$this->_is_strict = false;
+		}
+
+		/**
+		 *    Changes the default wildcard object.
+		 *    @param mixed $wildcard         Parameter matching wildcard.
+		 *    @access public
+		 */
+		function setWildcard($wildcard) {
+			$this->_wildcard = $wildcard;
+		}
+
+		/**
+		 *    Finds currently running test.
+		 *    @return SimpeTestCase    Current test case.
+		 *    @access protected
+		 */
+		function &_getCurrentTestCase() {
+			return SimpleTest::getCurrent();
+		}
+
+		/**
+		 *    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                      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");
+			$args = $this->_replaceWildcards($args);
+			$method = strtolower($method);
+			if (! isset($this->_returns[$method])) {
+				$this->_returns[$method] = new CallMap();
+			}
+			$this->_returns[$method]->addValue($args, $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");
+			$args = $this->_replaceWildcards($args);
+			$method = strtolower($method);
+			if (! isset($this->_return_sequence[$method])) {
+				$this->_return_sequence[$method] = array();
+			}
+			if (! isset($this->_return_sequence[$method][$timing])) {
+				$this->_return_sequence[$method][$timing] = new CallMap();
+			}
+			$this->_return_sequence[$method][$timing]->addValue($args, $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");
+			$args = $this->_replaceWildcards($args);
+			$method = strtolower($method);
+			if (! isset($this->_returns[$method])) {
+				$this->_returns[$method] = new CallMap();
+			}
+			$this->_returns[$method]->addReference($args, $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");
+			$args = $this->_replaceWildcards($args);
+			$method = strtolower($method);
+			if (! isset($this->_return_sequence[$method])) {
+				$this->_return_sequence[$method] = array();
+			}
+			if (! isset($this->_return_sequence[$method][$timing])) {
+				$this->_return_sequence[$method][$timing] = new CallMap();
+			}
+			$this->_return_sequence[$method][$timing]->addReference($args, $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');
+			$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->expectArguments($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->expectArguments($method, $args, $message);
+			}
+		}
+
+		/**
+		 *    @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 $method    Current method name.
+		 *    @access public
+		 */
+		function atTestEnd($method) {
+			foreach ($this->_expected_counts as $method => $expectation) {
+				$this->_assertTrue(
+						$expectation->test($this->getCallCount($method)),
+						$expectation->overlayMessage($this->getCallCount($method)));
+			}
+			foreach ($this->_max_counts as $method => $expectation) {
+				if ($expectation->test($this->getCallCount($method))) {
+					$this->_assertTrue(
+							true,
+							$expectation->overlayMessage($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->_getReturn($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.
+		 *    @access protected
+		 */
+		function &_getReturn($method, $args, $step) {
+			if (isset($this->_return_sequence[$method][$step])) {
+				if ($this->_return_sequence[$method][$step]->isMatch($args)) {
+					$result = $this->_return_sequence[$method][$step]->findFirstMatch($args);
+					return $result;
+				}
+			}
+			if (isset($this->_returns[$method])) {
+				$result = $this->_returns[$method]->findFirstMatch($args);
+				return $result;
+			}
+			$null = null;
+			return $null;
+		}
+
+		/**
+		 *    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) {
+			if (isset($this->_max_counts[$method])) {
+				if (! $this->_max_counts[$method]->test($timing + 1)) {
+					$this->_assertTrue(
+							false,
+							$this->_max_counts[$method]->overlayMessage($timing + 1));
+				}
+			}
+			if (isset($this->_expected_args_at[$timing][$method])) {
+				$this->_assertTrue(
+						$this->_expected_args_at[$timing][$method]->test($args),
+						"Mock method [$method] at [$timing] -> " .
+								$this->_expected_args_at[$timing][$method]->overlayMessage($args));
+			} elseif (isset($this->_expected_args[$method])) {
+				$this->_assertTrue(
+						$this->_expected_args[$method]->test($args),
+						"Mock method [$method] -> " . $this->_expected_args[$method]->overlayMessage($args));
+			}
+		}
+
+		/**
+		 *    Triggers an assertion on the held test case.
+		 *    Should be overridden when using another test
+		 *    framework other than the SimpleTest one if the
+		 *    assertion method has a different name.
+		 *    @param boolean $assertion     True will pass.
+		 *    @param string $message        Message that will go with
+		 *                                  the test event.
+		 *    @access protected
+		 */
+		function _assertTrue($assertion, $message) {
+			$test = $this->_getCurrentTestCase();
+			$test->assertTrue($assertion, $message);
+		}
+	}
+
+	/**
+	 *    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 class only.');
-        }
-
-        /**
-         *    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 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.
-         *    @static
-         *    @access public
-         */
-        static function generate($class, $mock_class = false, $methods = false) {
-            $generator = new MockGenerator($class, $mock_class);
-            return $generator->generate($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
-         */
-        static 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.
-         *    @param array $stack      Stack frames top most first. Only
-         *                             needed if not using the PHP
-         *                             backtrace function.
-         *    @return string           Location of first expect*
-         *                             method embedded in format string.
-         *    @access public
-         *    @static
-         */
-        static function getExpectationLine($stack = false) {
-            if ($stack === false) {
-                $stack = SimpleTestCompatibility::getStackTrace();
-            }
-            return SimpleDumper::getFormattedAssertionLine($stack);
-        }
-    }
-
-    /**
-     *    @deprecated
-     */
-    class Stub extends Mock {
-    }
-
-    /**
-     *    Service class for code generation of mock objects.
+	 */
+	class Mock {
+
+		/**
+		 *    Factory for mock object classes.
+		 *    @access public
+		 */
+		function Mock() {
+			trigger_error('Mock factory methods are class only.');
+		}
+
+		/**
+		 *    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 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.
+		 *    @static
+		 *    @access public
+		 */
+		static function generate($class, $mock_class = false, $methods = false) {
+			$generator = new MockGenerator($class, $mock_class);
+			return $generator->generate($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
+		 */
+		static 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.
+		 *    @param array $stack      Stack frames top most first. Only
+		 *                             needed if not using the PHP
+		 *                             backtrace function.
+		 *    @return string           Location of first expect*
+		 *                             method embedded in format string.
+		 *    @access public
+		 *    @static
+		 */
+		static function getExpectationLine($stack = false) {
+			if ($stack === false) {
+				$stack = SimpleTestCompatibility::getStackTrace();
+			}
+			return SimpleDumper::getFormattedAssertionLine($stack);
+		}
+	}
+
+	/**
+	 *    @deprecated
+	 */
+	class Stub extends Mock {
+	}
+
+	/**
+	 *    Service class for code generation of mock objects.
 	 *    @package SimpleTest
 	 *    @subpackage MockObjects
-     */
-    class MockGenerator {
-        protected $_class;
-        protected $_mock_class;
-        protected $_mock_base;
-        protected $_reflection;
-
-        function MockGenerator($class, $mock_class) {
-            $this->_class = $class;
-            $this->_mock_class = $mock_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;
-            }
-            if (! $this->_mock_class) {
-                $this->_mock_class = 'Mock' . $this->_class;
-            }
-            $mock_reflection = new SimpleReflection($this->_mock_class);
-            if ($mock_reflection->classExistsSansAutoload()) {
-                return false;
-            }
-            return eval(
-                    $this->_createClassCode($methods ? $methods : array()) .
-                    " return true;");
-        }
-
-        /**
-         *    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 [$mock_class] already exists");
-                return false;
-            }
-            return eval($this->_extendClassCode($methods));
-        }
-
-        /**
-         *    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";
-            $code .= $this->_createHandlerCode($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->_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;
-        }
-
-        /**
-         *    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', '__clone'));
-        }
-
-        /**
-         *    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("', '", $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($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) {\n";
-            $code .= $this->_bailOutIfNotMocked("\$method");
-            $code .= "        \$this->_mock->expect(\$method, \$args);\n";
-            $code .= "    }\n";
-            $code .= "    function expectArguments(\$method, \$args = false) {\n";
-            $code .= $this->_bailOutIfNotMocked("\$method");
-            $code .= "        \$this->_mock->expectArguments(\$method, \$args);\n";
-            $code .= "    }\n";
-            $code .= "    function expectAt(\$timing, \$method, \$args = false) {\n";
-            $code .= $this->_bailOutIfNotMocked("\$method");
-            $code .= "        \$this->_mock->expectArgumentsAt(\$timing, \$method, \$args);\n";
-            $code .= "    }\n";
-            $code .= "    function expectArgumentsAt(\$timing, \$method, \$args = false) {\n";
-            $code .= $this->_bailOutIfNotMocked("\$method");
-            $code .= "        \$this->_mock->expectArgumentsAt(\$timing, \$method, \$args);\n";
-            $code .= "    }\n";
-            $code .= "    function expectCallCount(\$method, \$count) {\n";
-            $code .= $this->_bailOutIfNotMocked("\$method");
-            $code .= "        \$this->_mock->expectCallCount(\$method, \$count);\n";
-            $code .= "    }\n";
-            $code .= "    function expectMaximumCallCount(\$method, \$count) {\n";
-            $code .= $this->_bailOutIfNotMocked("\$method");
-            $code .= "        \$this->_mock->expectMaximumCallCount(\$method, \$count);\n";
-            $code .= "    }\n";
-            $code .= "    function expectMinimumCallCount(\$method, \$count) {\n";
-            $code .= $this->_bailOutIfNotMocked("\$method");
-            $code .= "        \$this->_mock->expectMinimumCallCount(\$method, \$count);\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) {\n";
-            $code .= $this->_bailOutIfNotMocked("\$method");
-            $code .= "        \$this->_mock->expectOnce(\$method, \$args);\n";
-            $code .= "    }\n";
-            $code .= "    function expectAtLeastOnce(\$method, \$args = false) {\n";
-            $code .= $this->_bailOutIfNotMocked("\$method");
-            $code .= "        \$this->_mock->expectAtLeastOnce(\$method, \$args);\n";
-            $code .= "    }\n";
-            $code .= "    function tally() {\n";
-            $code .= "        \$this->_mock->tally();\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) {
-                $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;
-        }
-    }
\ No newline at end of file
+	 */
+	class MockGenerator {
+		protected $_class;
+		protected $_mock_class;
+		protected $_mock_base;
+		protected $_reflection;
+
+		function MockGenerator($class, $mock_class) {
+			$this->_class = $class;
+			$this->_mock_class = $mock_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;
+			}
+			if (! $this->_mock_class) {
+				$this->_mock_class = 'Mock' . $this->_class;
+			}
+			$mock_reflection = new SimpleReflection($this->_mock_class);
+			if ($mock_reflection->classExistsSansAutoload()) {
+				return false;
+			}
+			return eval(
+					$this->_createClassCode($methods ? $methods : array()) .
+					" return true;");
+		}
+
+		/**
+		 *    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 [$mock_class] already exists");
+				return false;
+			}
+			return eval($this->_extendClassCode($methods));
+		}
+
+		/**
+		 *    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";
+			$code .= $this->_createHandlerCode($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->_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;
+		}
+
+		/**
+		 *    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', '__clone'));
+		}
+
+		/**
+		 *    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("', '", $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($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) {\n";
+			$code .= $this->_bailOutIfNotMocked("\$method");
+			$code .= "        \$this->_mock->expect(\$method, \$args);\n";
+			$code .= "    }\n";
+			$code .= "    function expectArguments(\$method, \$args = false) {\n";
+			$code .= $this->_bailOutIfNotMocked("\$method");
+			$code .= "        \$this->_mock->expectArguments(\$method, \$args);\n";
+			$code .= "    }\n";
+			$code .= "    function expectAt(\$timing, \$method, \$args = false) {\n";
+			$code .= $this->_bailOutIfNotMocked("\$method");
+			$code .= "        \$this->_mock->expectArgumentsAt(\$timing, \$method, \$args);\n";
+			$code .= "    }\n";
+			$code .= "    function expectArgumentsAt(\$timing, \$method, \$args = false) {\n";
+			$code .= $this->_bailOutIfNotMocked("\$method");
+			$code .= "        \$this->_mock->expectArgumentsAt(\$timing, \$method, \$args);\n";
+			$code .= "    }\n";
+			$code .= "    function expectCallCount(\$method, \$count) {\n";
+			$code .= $this->_bailOutIfNotMocked("\$method");
+			$code .= "        \$this->_mock->expectCallCount(\$method, \$count);\n";
+			$code .= "    }\n";
+			$code .= "    function expectMaximumCallCount(\$method, \$count) {\n";
+			$code .= $this->_bailOutIfNotMocked("\$method");
+			$code .= "        \$this->_mock->expectMaximumCallCount(\$method, \$count);\n";
+			$code .= "    }\n";
+			$code .= "    function expectMinimumCallCount(\$method, \$count) {\n";
+			$code .= $this->_bailOutIfNotMocked("\$method");
+			$code .= "        \$this->_mock->expectMinimumCallCount(\$method, \$count);\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) {\n";
+			$code .= $this->_bailOutIfNotMocked("\$method");
+			$code .= "        \$this->_mock->expectOnce(\$method, \$args);\n";
+			$code .= "    }\n";
+			$code .= "    function expectAtLeastOnce(\$method, \$args = false) {\n";
+			$code .= $this->_bailOutIfNotMocked("\$method");
+			$code .= "        \$this->_mock->expectAtLeastOnce(\$method, \$args);\n";
+			$code .= "    }\n";
+			$code .= "    function tally() {\n";
+			$code .= "        \$this->_mock->tally();\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) {
+				$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;
+		}
+	}
\ No newline at end of file

tests/test_tools/simpletest/page.php

Indentation +965 added lines, -965 removed lines

@@ -1,974 +1,974 @@
 <?php
-    /**
-     *	Base include file for SimpleTest
-     *	@package	SimpleTest
-     *	@subpackage	WebTester
-     *	@version	$Id: page.php 1398 2006-09-08 19:31:03Z xue $
-     */
-
-    /**#@+
+	/**
+	 *	Base include file for SimpleTest
+	 *	@package	SimpleTest
+	 *	@subpackage	WebTester
+	 *	@version	$Id: page.php 1398 2006-09-08 19:31:03Z xue $
+	 */
+
+	/**#@+
      *	include other SimpleTest class files
      */
-    require_once(dirname(__FILE__) . '/http.php');
-    require_once(dirname(__FILE__) . '/parser.php');
-    require_once(dirname(__FILE__) . '/tag.php');
-    require_once(dirname(__FILE__) . '/form.php');
-    require_once(dirname(__FILE__) . '/selector.php');
-    /**#@-*/
-
-    /**
-     *    Creates tags and widgets given HTML tag
-     *    attributes.
+	require_once(dirname(__FILE__) . '/http.php');
+	require_once(dirname(__FILE__) . '/parser.php');
+	require_once(dirname(__FILE__) . '/tag.php');
+	require_once(dirname(__FILE__) . '/form.php');
+	require_once(dirname(__FILE__) . '/selector.php');
+	/**#@-*/
+
+	/**
+	 *    Creates tags and widgets given HTML tag
+	 *    attributes.
 	 *    @package SimpleTest
 	 *    @subpackage WebTester
-     */
-    class SimpleTagBuilder {
-
-        /**
-         *    Factory for the tag objects. Creates the
-         *    appropriate tag object for the incoming tag name
-         *    and attributes.
-         *    @param string $name        HTML tag name.
-         *    @param hash $attributes    Element attributes.
-         *    @return SimpleTag          Tag object.
-         *    @access public
-         */
-        function createTag($name, $attributes) {
-            static $map = array(
-                    'a' => 'SimpleAnchorTag',
-                    'title' => 'SimpleTitleTag',
-                    'button' => 'SimpleButtonTag',
-                    'textarea' => 'SimpleTextAreaTag',
-                    'option' => 'SimpleOptionTag',
-                    'label' => 'SimpleLabelTag',
-                    'form' => 'SimpleFormTag',
-                    'frame' => 'SimpleFrameTag');
-            $attributes = $this->_keysToLowerCase($attributes);
-            if (array_key_exists($name, $map)) {
-                $tag_class = $map[$name];
-                return new $tag_class($attributes);
-            } elseif ($name == 'select') {
-                return $this->_createSelectionTag($attributes);
-            } elseif ($name == 'input') {
-                return $this->_createInputTag($attributes);
-            }
-            return new SimpleTag($name, $attributes);
-        }
-
-        /**
-         *    Factory for selection fields.
-         *    @param hash $attributes    Element attributes.
-         *    @return SimpleTag          Tag object.
-         *    @access protected
-         */
-        function _createSelectionTag($attributes) {
-            if (isset($attributes['multiple'])) {
-                return new MultipleSelectionTag($attributes);
-            }
-            return new SimpleSelectionTag($attributes);
-        }
-
-        /**
-         *    Factory for input tags.
-         *    @param hash $attributes    Element attributes.
-         *    @return SimpleTag          Tag object.
-         *    @access protected
-         */
-        function _createInputTag($attributes) {
-            if (! isset($attributes['type'])) {
-                return new SimpleTextTag($attributes);
-            }
-            $type = strtolower(trim($attributes['type']));
-            $map = array(
-                    'submit' => 'SimpleSubmitTag',
-                    'image' => 'SimpleImageSubmitTag',
-                    'checkbox' => 'SimpleCheckboxTag',
-                    'radio' => 'SimpleRadioButtonTag',
-                    'text' => 'SimpleTextTag',
-                    'hidden' => 'SimpleTextTag',
-                    'password' => 'SimpleTextTag',
-                    'file' => 'SimpleUploadTag');
-            if (array_key_exists($type, $map)) {
-                $tag_class = $map[$type];
-                return new $tag_class($attributes);
-            }
-            return false;
-        }
-
-        /**
-         *    Make the keys lower case for case insensitive look-ups.
-         *    @param hash $map   Hash to convert.
-         *    @return hash       Unchanged values, but keys lower case.
-         *    @access private
-         */
-        function _keysToLowerCase($map) {
-            $lower = array();
-            foreach ($map as $key => $value) {
-                $lower[strtolower($key)] = $value;
-            }
-            return $lower;
-        }
-    }
-
-    /**
-     *    SAX event handler. Maintains a list of
-     *    open tags and dispatches them as they close.
+	 */
+	class SimpleTagBuilder {
+
+		/**
+		 *    Factory for the tag objects. Creates the
+		 *    appropriate tag object for the incoming tag name
+		 *    and attributes.
+		 *    @param string $name        HTML tag name.
+		 *    @param hash $attributes    Element attributes.
+		 *    @return SimpleTag          Tag object.
+		 *    @access public
+		 */
+		function createTag($name, $attributes) {
+			static $map = array(
+					'a' => 'SimpleAnchorTag',
+					'title' => 'SimpleTitleTag',
+					'button' => 'SimpleButtonTag',
+					'textarea' => 'SimpleTextAreaTag',
+					'option' => 'SimpleOptionTag',
+					'label' => 'SimpleLabelTag',
+					'form' => 'SimpleFormTag',
+					'frame' => 'SimpleFrameTag');
+			$attributes = $this->_keysToLowerCase($attributes);
+			if (array_key_exists($name, $map)) {
+				$tag_class = $map[$name];
+				return new $tag_class($attributes);
+			} elseif ($name == 'select') {
+				return $this->_createSelectionTag($attributes);
+			} elseif ($name == 'input') {
+				return $this->_createInputTag($attributes);
+			}
+			return new SimpleTag($name, $attributes);
+		}
+
+		/**
+		 *    Factory for selection fields.
+		 *    @param hash $attributes    Element attributes.
+		 *    @return SimpleTag          Tag object.
+		 *    @access protected
+		 */
+		function _createSelectionTag($attributes) {
+			if (isset($attributes['multiple'])) {
+				return new MultipleSelectionTag($attributes);
+			}
+			return new SimpleSelectionTag($attributes);
+		}
+
+		/**
+		 *    Factory for input tags.
+		 *    @param hash $attributes    Element attributes.
+		 *    @return SimpleTag          Tag object.
+		 *    @access protected
+		 */
+		function _createInputTag($attributes) {
+			if (! isset($attributes['type'])) {
+				return new SimpleTextTag($attributes);
+			}
+			$type = strtolower(trim($attributes['type']));
+			$map = array(
+					'submit' => 'SimpleSubmitTag',
+					'image' => 'SimpleImageSubmitTag',
+					'checkbox' => 'SimpleCheckboxTag',
+					'radio' => 'SimpleRadioButtonTag',
+					'text' => 'SimpleTextTag',
+					'hidden' => 'SimpleTextTag',
+					'password' => 'SimpleTextTag',
+					'file' => 'SimpleUploadTag');
+			if (array_key_exists($type, $map)) {
+				$tag_class = $map[$type];
+				return new $tag_class($attributes);
+			}
+			return false;
+		}
+
+		/**
+		 *    Make the keys lower case for case insensitive look-ups.
+		 *    @param hash $map   Hash to convert.
+		 *    @return hash       Unchanged values, but keys lower case.
+		 *    @access private
+		 */
+		function _keysToLowerCase($map) {
+			$lower = array();
+			foreach ($map as $key => $value) {
+				$lower[strtolower($key)] = $value;
+			}
+			return $lower;
+		}
+	}
+
+	/**
+	 *    SAX event handler. Maintains a list of
+	 *    open tags and dispatches them as they close.
 	 *    @package SimpleTest
 	 *    @subpackage WebTester
-     */
-    class SimplePageBuilder extends SimpleSaxListener {
-        protected $_tags;
-        protected $_page;
-        protected $_private_content_tag;
-
-        /**
-         *    Sets the builder up empty.
-         *    @access public
-         */
-        function SimplePageBuilder() {
-            $this->SimpleSaxListener();
-        }
-
-        /**
-         *    Frees up any references so as to allow the PHP garbage
-         *    collection from unset() to work.
-         *    @access public
-         */
-        function free() {
-            unset($this->_tags);
-            unset($this->_page);
-            unset($this->_private_content_tags);
-        }
-
-        /**
-         *    Reads the raw content and send events
-         *    into the page to be built.
-         *    @param $response SimpleHttpResponse  Fetched response.
-         *    @return SimplePage                   Newly parsed page.
-         *    @access public
-         */
-        function &parse($response) {
-            $this->_tags = array();
-            $this->_page = $this->_createPage($response);
-            $parser = $this->_createParser($this);
-            $parser->parse($response->getContent());
-            $this->_page->acceptPageEnd();
-            return $this->_page;
-        }
-
-        /**
-         *    Creates an empty page.
-         *    @return SimplePage        New unparsed page.
-         *    @access protected
-         */
-        function &_createPage($response) {
-            $page = new SimplePage($response);
-            return $page;
-        }
-
-        /**
-         *    Creates the parser used with the builder.
-         *    @param $listener SimpleSaxListener   Target of parser.
-         *    @return SimpleSaxParser              Parser to generate
-         *                                         events for the builder.
-         *    @access protected
-         */
-        function &_createParser($listener) {
-            $parser = new SimpleHtmlSaxParser($listener);
-            return $parser;
-        }
-
-        /**
-         *    Start of element event. Opens a new tag.
-         *    @param string $name         Element name.
-         *    @param hash $attributes     Attributes without content
-         *                                are marked as true.
-         *    @return boolean             False on parse error.
-         *    @access public
-         */
-        function startElement($name, $attributes) {
-            $factory = new SimpleTagBuilder();
-            $tag = $factory->createTag($name, $attributes);
-            if (! $tag) {
-                return true;
-            }
-            if ($tag->getTagName() == 'label') {
-                $this->_page->acceptLabelStart($tag);
-                $this->_openTag($tag);
-                return true;
-            }
-            if ($tag->getTagName() == 'form') {
-                $this->_page->acceptFormStart($tag);
-                return true;
-            }
-            if ($tag->getTagName() == 'frameset') {
-                $this->_page->acceptFramesetStart($tag);
-                return true;
-            }
-            if ($tag->getTagName() == 'frame') {
-                $this->_page->acceptFrame($tag);
-                return true;
-            }
-            if ($tag->isPrivateContent() && ! isset($this->_private_content_tag)) {
-                $this->_private_content_tag = $tag;
-            }
-            if ($tag->expectEndTag()) {
-                $this->_openTag($tag);
-                return true;
-            }
-            $this->_page->acceptTag($tag);
-            return true;
-        }
-
-        /**
-         *    End of element event.
-         *    @param string $name        Element name.
-         *    @return boolean            False on parse error.
-         *    @access public
-         */
-        function endElement($name) {
-            if ($name == 'label') {
-                $this->_page->acceptLabelEnd();
-                return true;
-            }
-            if ($name == 'form') {
-                $this->_page->acceptFormEnd();
-                return true;
-            }
-            if ($name == 'frameset') {
-                $this->_page->acceptFramesetEnd();
-                return true;
-            }
-            if ($this->_hasNamedTagOnOpenTagStack($name)) {
-                $tag = array_pop($this->_tags[$name]);
-                if ($tag->isPrivateContent() && $this->_private_content_tag->getTagName() == $name) {
-                    unset($this->_private_content_tag);
-                }
-                $this->_addContentTagToOpenTags($tag);
-                $this->_page->acceptTag($tag);
-                return true;
-            }
-            return true;
-        }
-
-        /**
-         *    Test to see if there are any open tags awaiting
-         *    closure that match the tag name.
-         *    @param string $name        Element name.
-         *    @return boolean            True if any are still open.
-         *    @access private
-         */
-        function _hasNamedTagOnOpenTagStack($name) {
-            return isset($this->_tags[$name]) && (count($this->_tags[$name]) > 0);
-        }
-
-        /**
-         *    Unparsed, but relevant data. The data is added
-         *    to every open tag.
-         *    @param string $text        May include unparsed tags.
-         *    @return boolean            False on parse error.
-         *    @access public
-         */
-        function addContent($text) {
-            if (isset($this->_private_content_tag)) {
-                $this->_private_content_tag->addContent($text);
-            } else {
-                $this->_addContentToAllOpenTags($text);
-            }
-            return true;
-        }
-
-        /**
-         *    Any content fills all currently open tags unless it
-         *    is part of an option tag.
-         *    @param string $text        May include unparsed tags.
-         *    @access private
-         */
-        function _addContentToAllOpenTags($text) {
-            foreach (array_keys($this->_tags) as $name) {
-                for ($i = 0, $count = count($this->_tags[$name]); $i < $count; $i++) {
-                    $this->_tags[$name][$i]->addContent($text);
-                }
-            }
-        }
-
-        /**
-         *    Parsed data in tag form. The parsed tag is added
-         *    to every open tag. Used for adding options to select
-         *    fields only.
-         *    @param SimpleTag $tag        Option tags only.
-         *    @access private
-         */
-        function _addContentTagToOpenTags($tag) {
-            if ($tag->getTagName() != 'option') {
-                return;
-            }
-            foreach (array_keys($this->_tags) as $name) {
-                for ($i = 0, $count = count($this->_tags[$name]); $i < $count; $i++) {
-                    $this->_tags[$name][$i]->addTag($tag);
-                }
-            }
-        }
-
-        /**
-         *    Opens a tag for receiving content. Multiple tags
-         *    will be receiving input at the same time.
-         *    @param SimpleTag $tag        New content tag.
-         *    @access private
-         */
-        function _openTag($tag) {
-            $name = $tag->getTagName();
-            if (! in_array($name, array_keys($this->_tags))) {
-                $this->_tags[$name] = array();
-            }
-            $this->_tags[$name][] = $tag;
-        }
-    }
-
-    /**
-     *    A wrapper for a web page.
+	 */
+	class SimplePageBuilder extends SimpleSaxListener {
+		protected $_tags;
+		protected $_page;
+		protected $_private_content_tag;
+
+		/**
+		 *    Sets the builder up empty.
+		 *    @access public
+		 */
+		function SimplePageBuilder() {
+			$this->SimpleSaxListener();
+		}
+
+		/**
+		 *    Frees up any references so as to allow the PHP garbage
+		 *    collection from unset() to work.
+		 *    @access public
+		 */
+		function free() {
+			unset($this->_tags);
+			unset($this->_page);
+			unset($this->_private_content_tags);
+		}
+
+		/**
+		 *    Reads the raw content and send events
+		 *    into the page to be built.
+		 *    @param $response SimpleHttpResponse  Fetched response.
+		 *    @return SimplePage                   Newly parsed page.
+		 *    @access public
+		 */
+		function &parse($response) {
+			$this->_tags = array();
+			$this->_page = $this->_createPage($response);
+			$parser = $this->_createParser($this);
+			$parser->parse($response->getContent());
+			$this->_page->acceptPageEnd();
+			return $this->_page;
+		}
+
+		/**
+		 *    Creates an empty page.
+		 *    @return SimplePage        New unparsed page.
+		 *    @access protected
+		 */
+		function &_createPage($response) {
+			$page = new SimplePage($response);
+			return $page;
+		}
+
+		/**
+		 *    Creates the parser used with the builder.
+		 *    @param $listener SimpleSaxListener   Target of parser.
+		 *    @return SimpleSaxParser              Parser to generate
+		 *                                         events for the builder.
+		 *    @access protected
+		 */
+		function &_createParser($listener) {
+			$parser = new SimpleHtmlSaxParser($listener);
+			return $parser;
+		}
+
+		/**
+		 *    Start of element event. Opens a new tag.
+		 *    @param string $name         Element name.
+		 *    @param hash $attributes     Attributes without content
+		 *                                are marked as true.
+		 *    @return boolean             False on parse error.
+		 *    @access public
+		 */
+		function startElement($name, $attributes) {
+			$factory = new SimpleTagBuilder();
+			$tag = $factory->createTag($name, $attributes);
+			if (! $tag) {
+				return true;
+			}
+			if ($tag->getTagName() == 'label') {
+				$this->_page->acceptLabelStart($tag);
+				$this->_openTag($tag);
+				return true;
+			}
+			if ($tag->getTagName() == 'form') {
+				$this->_page->acceptFormStart($tag);
+				return true;
+			}
+			if ($tag->getTagName() == 'frameset') {
+				$this->_page->acceptFramesetStart($tag);
+				return true;
+			}
+			if ($tag->getTagName() == 'frame') {
+				$this->_page->acceptFrame($tag);
+				return true;
+			}
+			if ($tag->isPrivateContent() && ! isset($this->_private_content_tag)) {
+				$this->_private_content_tag = $tag;
+			}
+			if ($tag->expectEndTag()) {
+				$this->_openTag($tag);
+				return true;
+			}
+			$this->_page->acceptTag($tag);
+			return true;
+		}
+
+		/**
+		 *    End of element event.
+		 *    @param string $name        Element name.
+		 *    @return boolean            False on parse error.
+		 *    @access public
+		 */
+		function endElement($name) {
+			if ($name == 'label') {
+				$this->_page->acceptLabelEnd();
+				return true;
+			}
+			if ($name == 'form') {
+				$this->_page->acceptFormEnd();
+				return true;
+			}
+			if ($name == 'frameset') {
+				$this->_page->acceptFramesetEnd();
+				return true;
+			}
+			if ($this->_hasNamedTagOnOpenTagStack($name)) {
+				$tag = array_pop($this->_tags[$name]);
+				if ($tag->isPrivateContent() && $this->_private_content_tag->getTagName() == $name) {
+					unset($this->_private_content_tag);
+				}
+				$this->_addContentTagToOpenTags($tag);
+				$this->_page->acceptTag($tag);
+				return true;
+			}
+			return true;
+		}
+
+		/**
+		 *    Test to see if there are any open tags awaiting
+		 *    closure that match the tag name.
+		 *    @param string $name        Element name.
+		 *    @return boolean            True if any are still open.
+		 *    @access private
+		 */
+		function _hasNamedTagOnOpenTagStack($name) {
+			return isset($this->_tags[$name]) && (count($this->_tags[$name]) > 0);
+		}
+
+		/**
+		 *    Unparsed, but relevant data. The data is added
+		 *    to every open tag.
+		 *    @param string $text        May include unparsed tags.
+		 *    @return boolean            False on parse error.
+		 *    @access public
+		 */
+		function addContent($text) {
+			if (isset($this->_private_content_tag)) {
+				$this->_private_content_tag->addContent($text);
+			} else {
+				$this->_addContentToAllOpenTags($text);
+			}
+			return true;
+		}
+
+		/**
+		 *    Any content fills all currently open tags unless it
+		 *    is part of an option tag.
+		 *    @param string $text        May include unparsed tags.
+		 *    @access private
+		 */
+		function _addContentToAllOpenTags($text) {
+			foreach (array_keys($this->_tags) as $name) {
+				for ($i = 0, $count = count($this->_tags[$name]); $i < $count; $i++) {
+					$this->_tags[$name][$i]->addContent($text);
+				}
+			}
+		}
+
+		/**
+		 *    Parsed data in tag form. The parsed tag is added
+		 *    to every open tag. Used for adding options to select
+		 *    fields only.
+		 *    @param SimpleTag $tag        Option tags only.
+		 *    @access private
+		 */
+		function _addContentTagToOpenTags($tag) {
+			if ($tag->getTagName() != 'option') {
+				return;
+			}
+			foreach (array_keys($this->_tags) as $name) {
+				for ($i = 0, $count = count($this->_tags[$name]); $i < $count; $i++) {
+					$this->_tags[$name][$i]->addTag($tag);
+				}
+			}
+		}
+
+		/**
+		 *    Opens a tag for receiving content. Multiple tags
+		 *    will be receiving input at the same time.
+		 *    @param SimpleTag $tag        New content tag.
+		 *    @access private
+		 */
+		function _openTag($tag) {
+			$name = $tag->getTagName();
+			if (! in_array($name, array_keys($this->_tags))) {
+				$this->_tags[$name] = array();
+			}
+			$this->_tags[$name][] = $tag;
+		}
+	}
+
+	/**
+	 *    A wrapper for a web page.
 	 *    @package SimpleTest
 	 *    @subpackage WebTester
-     */
-    class SimplePage {
-        protected $_links;
-        protected $_title;
-        protected $_last_widget;
-        protected $_label;
-        protected $_left_over_labels;
-        protected $_open_forms;
-        protected $_complete_forms;
-        protected $_frameset;
-        protected $_frames;
-        protected $_frameset_nesting_level;
-        protected $_transport_error;
-        protected $_raw;
-        protected $_text;
-        protected $_sent;
-        protected $_headers;
-        protected $_method;
-        protected $_url;
-        protected $_request_data;
-
-        /**
-         *    Parses a page ready to access it's contents.
-         *    @param SimpleHttpResponse $response     Result of HTTP fetch.
-         *    @access public
-         */
-        function SimplePage($response = false) {
-            $this->_links = array();
-            $this->_title = false;
-            $this->_left_over_labels = array();
-            $this->_open_forms = array();
-            $this->_complete_forms = array();
-            $this->_frameset = false;
-            $this->_frames = array();
-            $this->_frameset_nesting_level = 0;
-            $this->_text = false;
-            if ($response) {
-                $this->_extractResponse($response);
-            } else {
-                $this->_noResponse();
-            }
-        }
-
-        /**
-         *    Extracts all of the response information.
-         *    @param SimpleHttpResponse $response    Response being parsed.
-         *    @access private
-         */
-        function _extractResponse($response) {
-            $this->_transport_error = $response->getError();
-            $this->_raw = $response->getContent();
-            $this->_sent = $response->getSent();
-            $this->_headers = $response->getHeaders();
-            $this->_method = $response->getMethod();
-            $this->_url = $response->getUrl();
-            $this->_request_data = $response->getRequestData();
-        }
-
-        /**
-         *    Sets up a missing response.
-         *    @access private
-         */
-        function _noResponse() {
-            $this->_transport_error = 'No page fetched yet';
-            $this->_raw = false;
-            $this->_sent = false;
-            $this->_headers = false;
-            $this->_method = 'GET';
-            $this->_url = false;
-            $this->_request_data = false;
-        }
-
-        /**
-         *    Original request as bytes sent down the wire.
-         *    @return mixed              Sent content.
-         *    @access public
-         */
-        function getRequest() {
-            return $this->_sent;
-        }
-
-        /**
-         *    Accessor for raw text of page.
-         *    @return string        Raw unparsed content.
-         *    @access public
-         */
-        function getRaw() {
-            return $this->_raw;
-        }
-
-        /**
-         *    Accessor for plain text of page as a text browser
-         *    would see it.
-         *    @return string        Plain text of page.
-         *    @access public
-         */
-        function getText() {
-            if (! $this->_text) {
-                $this->_text = SimpleHtmlSaxParser::normalise($this->_raw);
-            }
-            return $this->_text;
-        }
-
-        /**
-         *    Accessor for raw headers of page.
-         *    @return string       Header block as text.
-         *    @access public
-         */
-        function getHeaders() {
-            if ($this->_headers) {
-                return $this->_headers->getRaw();
-            }
-            return false;
-        }
-
-        /**
-         *    Original request method.
-         *    @return string        GET, POST or HEAD.
-         *    @access public
-         */
-        function getMethod() {
-            return $this->_method;
-        }
-
-        /**
-         *    Original resource name.
-         *    @return SimpleUrl        Current url.
-         *    @access public
-         */
-        function getUrl() {
-            return $this->_url;
-        }
-
-        /**
-         *    Original request data.
-         *    @return mixed              Sent content.
-         *    @access public
-         */
-        function getRequestData() {
-            return $this->_request_data;
-        }
-
-        /**
-         *    Accessor for last error.
-         *    @return string        Error from last response.
-         *    @access public
-         */
-        function getTransportError() {
-            return $this->_transport_error;
-        }
-
-        /**
-         *    Accessor for current MIME type.
-         *    @return string    MIME type as string; e.g. 'text/html'
-         *    @access public
-         */
-        function getMimeType() {
-            if ($this->_headers) {
-                return $this->_headers->getMimeType();
-            }
-            return false;
-        }
-
-        /**
-         *    Accessor for HTTP response code.
-         *    @return integer    HTTP response code received.
-         *    @access public
-         */
-        function getResponseCode() {
-            if ($this->_headers) {
-                return $this->_headers->getResponseCode();
-            }
-            return false;
-        }
-
-        /**
-         *    Accessor for last Authentication type. Only valid
-         *    straight after a challenge (401).
-         *    @return string    Description of challenge type.
-         *    @access public
-         */
-        function getAuthentication() {
-            if ($this->_headers) {
-                return $this->_headers->getAuthentication();
-            }
-            return false;
-        }
-
-        /**
-         *    Accessor for last Authentication realm. Only valid
-         *    straight after a challenge (401).
-         *    @return string    Name of security realm.
-         *    @access public
-         */
-        function getRealm() {
-            if ($this->_headers) {
-                return $this->_headers->getRealm();
-            }
-            return false;
-        }
-
-        /**
-         *    Accessor for current frame focus. Will be
-         *    false as no frames.
-         *    @return array    Always empty.
-         *    @access public
-         */
-        function getFrameFocus() {
-            return array();
-        }
-
-        /**
-         *    Sets the focus by index. The integer index starts from 1.
-         *    @param integer $choice    Chosen frame.
-         *    @return boolean           Always false.
-         *    @access public
-         */
-        function setFrameFocusByIndex($choice) {
-            return false;
-        }
-
-        /**
-         *    Sets the focus by name. Always fails for a leaf page.
-         *    @param string $name    Chosen frame.
-         *    @return boolean        False as no frames.
-         *    @access public
-         */
-        function setFrameFocus($name) {
-            return false;
-        }
-
-        /**
-         *    Clears the frame focus. Does nothing for a leaf page.
-         *    @access public
-         */
-        function clearFrameFocus() {
-        }
-
-        /**
-         *    Adds a tag to the page.
-         *    @param SimpleTag $tag        Tag to accept.
-         *    @access public
-         */
-        function acceptTag($tag) {
-            if ($tag->getTagName() == "a") {
-                $this->_addLink($tag);
-            } elseif ($tag->getTagName() == "title") {
-                $this->_setTitle($tag);
-            } elseif ($this->_isFormElement($tag->getTagName())) {
-                for ($i = 0; $i < count($this->_open_forms); $i++) {
-                    $this->_open_forms[$i]->addWidget($tag);
-                }
-                $this->_last_widget = $tag;
-            }
-        }
-
-        /**
-         *    Opens a label for a described widget.
-         *    @param SimpleFormTag $tag      Tag to accept.
-         *    @access public
-         */
-        function acceptLabelStart($tag) {
-            $this->_label = $tag;
-            unset($this->_last_widget);
-        }
-
-        /**
-         *    Closes the most recently opened label.
-         *    @access public
-         */
-        function acceptLabelEnd() {
-            if (isset($this->_label)) {
-                if (isset($this->_last_widget)) {
-                    $this->_last_widget->setLabel($this->_label->getText());
-                    unset($this->_last_widget);
-                } else {
-                    $this->_left_over_labels[] = SimpleTestCompatibility::copy($this->_label);
-                }
-                unset($this->_label);
-            }
-        }
-
-        /**
-         *    Tests to see if a tag is a possible form
-         *    element.
-         *    @param string $name     HTML element name.
-         *    @return boolean         True if form element.
-         *    @access private
-         */
-        function _isFormElement($name) {
-            return in_array($name, array('input', 'button', 'textarea', 'select'));
-        }
-
-        /**
-         *    Opens a form. New widgets go here.
-         *    @param SimpleFormTag $tag      Tag to accept.
-         *    @access public
-         */
-        function acceptFormStart($tag) {
-            $this->_open_forms[] = new SimpleForm($tag, $this->getUrl());
-        }
-
-        /**
-         *    Closes the most recently opened form.
-         *    @access public
-         */
-        function acceptFormEnd() {
-            if (count($this->_open_forms)) {
-                $this->_complete_forms[] = array_pop($this->_open_forms);
-            }
-        }
-
-        /**
-         *    Opens a frameset. A frameset may contain nested
-         *    frameset tags.
-         *    @param SimpleFramesetTag $tag      Tag to accept.
-         *    @access public
-         */
-        function acceptFramesetStart($tag) {
-            if (! $this->_isLoadingFrames()) {
-                $this->_frameset = $tag;
-            }
-            $this->_frameset_nesting_level++;
-        }
-
-        /**
-         *    Closes the most recently opened frameset.
-         *    @access public
-         */
-        function acceptFramesetEnd() {
-            if ($this->_isLoadingFrames()) {
-                $this->_frameset_nesting_level--;
-            }
-        }
-
-        /**
-         *    Takes a single frame tag and stashes it in
-         *    the current frame set.
-         *    @param SimpleFrameTag $tag      Tag to accept.
-         *    @access public
-         */
-        function acceptFrame($tag) {
-            if ($this->_isLoadingFrames()) {
-                if ($tag->getAttribute('src')) {
-                    $this->_frames[] = $tag;
-                }
-            }
-        }
-
-        /**
-         *    Test to see if in the middle of reading
-         *    a frameset.
-         *    @return boolean        True if inframeset.
-         *    @access private
-         */
-        function _isLoadingFrames() {
-            if (! $this->_frameset) {
-                return false;
-            }
-            return ($this->_frameset_nesting_level > 0);
-        }
-
-        /**
-         *    Test to see if link is an absolute one.
-         *    @param string $url     Url to test.
-         *    @return boolean        True if absolute.
-         *    @access protected
-         */
-        function _linkIsAbsolute($url) {
-            $parsed = new SimpleUrl($url);
-            return (boolean)($parsed->getScheme() && $parsed->getHost());
-        }
-
-        /**
-         *    Adds a link to the page.
-         *    @param SimpleAnchorTag $tag      Link to accept.
-         *    @access protected
-         */
-        function _addLink($tag) {
-            $this->_links[] = $tag;
-        }
-
-        /**
-         *    Marker for end of complete page. Any work in
-         *    progress can now be closed.
-         *    @access public
-         */
-        function acceptPageEnd() {
-            while (count($this->_open_forms)) {
-                $this->_complete_forms[] = array_pop($this->_open_forms);
-            }
-            foreach ($this->_left_over_labels as $label) {
-                for ($i = 0, $count = count($this->_complete_forms); $i < $count; $i++) {
-                    $this->_complete_forms[$i]->attachLabelBySelector(
-                            new SimpleById($label->getFor()),
-                            $label->getText());
-                }
-            }
-        }
-
-        /**
-         *    Test for the presence of a frameset.
-         *    @return boolean        True if frameset.
-         *    @access public
-         */
-        function hasFrames() {
-            return (boolean)$this->_frameset;
-        }
-
-        /**
-         *    Accessor for frame name and source URL for every frame that
-         *    will need to be loaded. Immediate children only.
-         *    @return boolean/array     False if no frameset or
-         *                              otherwise a hash of frame URLs.
-         *                              The key is either a numerical
-         *                              base one index or the name attribute.
-         *    @access public
-         */
-        function getFrameset() {
-            if (! $this->_frameset) {
-                return false;
-            }
-            $urls = array();
-            for ($i = 0; $i < count($this->_frames); $i++) {
-                $name = $this->_frames[$i]->getAttribute('name');
-                $url = new SimpleUrl($this->_frames[$i]->getAttribute('src'));
-                $urls[$name ? $name : $i + 1] = $url->makeAbsolute($this->getUrl());
-            }
-            return $urls;
-        }
-
-        /**
-         *    Fetches a list of loaded frames.
-         *    @return array/string    Just the URL for a single page.
-         *    @access public
-         */
-        function getFrames() {
-            $url = $this->getUrl();
-            return $url->asString();
-        }
-
-        /**
-         *    Accessor for a list of all fixed links.
-         *    @return array   List of urls with scheme of
-         *                    http or https and hostname.
-         *    @access public
-         */
-        function getAbsoluteUrls() {
-            $all = array();
-            foreach ($this->_links as $link) {
-                if ($this->_linkIsAbsolute($link->getHref())) {
-                    $all[] = $link->getHref();
-                }
-            }
-            return $all;
-        }
-
-        /**
-         *    Accessor for a list of all relative links.
-         *    @return array      List of urls without hostname.
-         *    @access public
-         */
-        function getRelativeUrls() {
-            $all = array();
-            foreach ($this->_links as $link) {
-                if (! $this->_linkIsAbsolute($link->getHref())) {
-                    $all[] = $link->getHref();
-                }
-            }
-            return $all;
-        }
-
-        /**
-         *    Accessor for URLs by the link label. Label will match
-         *    regardess of whitespace issues and case.
-         *    @param string $label    Text of link.
-         *    @return array           List of links with that label.
-         *    @access public
-         */
-        function getUrlsByLabel($label) {
-            $matches = array();
-            foreach ($this->_links as $link) {
-                if ($link->getText() == $label) {
-                    $matches[] = $this->_getUrlFromLink($link);
-                }
-            }
-            return $matches;
-        }
-
-        /**
-         *    Accessor for a URL by the id attribute.
-         *    @param string $id       Id attribute of link.
-         *    @return SimpleUrl       URL with that id of false if none.
-         *    @access public
-         */
-        function getUrlById($id) {
-            foreach ($this->_links as $link) {
-                if ($link->getAttribute('id') === (string)$id) {
-                    return $this->_getUrlFromLink($link);
-                }
-            }
-            return false;
-        }
-
-        /**
-         *    Converts a link into a target URL.
-         *    @param SimpleAnchor $link    Parsed link.
-         *    @return SimpleUrl            URL with frame target if any.
-         *    @access private
-         */
-        function _getUrlFromLink($link) {
-            $url = $this->_makeAbsolute($link->getHref());
-            if ($link->getAttribute('target')) {
-                $url->setTarget($link->getAttribute('target'));
-            }
-            return $url;
-        }
-
-        /**
-         *    Expands expandomatic URLs into fully qualified
-         *    URLs.
-         *    @param SimpleUrl $url        Relative URL.
-         *    @return SimpleUrl            Absolute URL.
-         *    @access protected
-         */
-        function _makeAbsolute($url) {
-            if (! is_object($url)) {
-                $url = new SimpleUrl($url);
-            }
-            return $url->makeAbsolute($this->getUrl());
-        }
-
-        /**
-         *    Sets the title tag contents.
-         *    @param SimpleTitleTag $tag    Title of page.
-         *    @access protected
-         */
-        function _setTitle($tag) {
-            $this->_title = $tag;
-        }
-
-        /**
-         *    Accessor for parsed title.
-         *    @return string     Title or false if no title is present.
-         *    @access public
-         */
-        function getTitle() {
-            if ($this->_title) {
-                return $this->_title->getText();
-            }
-            return false;
-        }
-
-        /**
-         *    Finds a held form by button label. Will only
-         *    search correctly built forms.
-         *    @param SimpleSelector $selector       Button finder.
-         *    @return SimpleForm                    Form object containing
-         *                                          the button.
-         *    @access public
-         */
-        function &getFormBySubmit($selector) {
-            for ($i = 0; $i < count($this->_complete_forms); $i++) {
-                if ($this->_complete_forms[$i]->hasSubmit($selector)) {
-                    return $this->_complete_forms[$i];
-                }
-            }
-            $null = null;
-            return $null;
-        }
-
-        /**
-         *    Finds a held form by image using a selector.
-         *    Will only search correctly built forms.
-         *    @param SimpleSelector $selector  Image finder.
-         *    @return SimpleForm               Form object containing
-         *                                     the image.
-         *    @access public
-         */
-        function &getFormByImage($selector) {
-            for ($i = 0; $i < count($this->_complete_forms); $i++) {
-                if ($this->_complete_forms[$i]->hasImage($selector)) {
-                    return $this->_complete_forms[$i];
-                }
-            }
-            $null = null;
-            return $null;
-        }
-
-        /**
-         *    Finds a held form by the form ID. A way of
-         *    identifying a specific form when we have control
-         *    of the HTML code.
-         *    @param string $id     Form label.
-         *    @return SimpleForm    Form object containing the matching ID.
-         *    @access public
-         */
-        function &getFormById($id) {
-            for ($i = 0; $i < count($this->_complete_forms); $i++) {
-                if ($this->_complete_forms[$i]->getId() == $id) {
-                    return $this->_complete_forms[$i];
-                }
-            }
-            $null = null;
-            return $null;
-        }
-
-        /**
-         *    Sets a field on each form in which the field is
-         *    available.
-         *    @param SimpleSelector $selector    Field finder.
-         *    @param string $value               Value to set field to.
-         *    @return boolean                    True if value is valid.
-         *    @access public
-         */
-        function setField($selector, $value) {
-            $is_set = false;
-            for ($i = 0; $i < count($this->_complete_forms); $i++) {
-                if ($this->_complete_forms[$i]->setField($selector, $value)) {
-                    $is_set = true;
-                }
-            }
-            return $is_set;
-        }
-
-        /**
-         *    Accessor for a form element value within a page.
-         *    @param SimpleSelector $selector    Field finder.
-         *    @return string/boolean             A string if the field is
-         *                                       present, false if unchecked
-         *                                       and null if missing.
-         *    @access public
-         */
-        function getField($selector) {
-            for ($i = 0; $i < count($this->_complete_forms); $i++) {
-                $value = $this->_complete_forms[$i]->getValue($selector);
-                if (isset($value)) {
-                    return $value;
-                }
-            }
-            return null;
-        }
-    }
+	 */
+	class SimplePage {
+		protected $_links;
+		protected $_title;
+		protected $_last_widget;
+		protected $_label;
+		protected $_left_over_labels;
+		protected $_open_forms;
+		protected $_complete_forms;
+		protected $_frameset;
+		protected $_frames;
+		protected $_frameset_nesting_level;
+		protected $_transport_error;
+		protected $_raw;
+		protected $_text;
+		protected $_sent;
+		protected $_headers;
+		protected $_method;
+		protected $_url;
+		protected $_request_data;
+
+		/**
+		 *    Parses a page ready to access it's contents.
+		 *    @param SimpleHttpResponse $response     Result of HTTP fetch.
+		 *    @access public
+		 */
+		function SimplePage($response = false) {
+			$this->_links = array();
+			$this->_title = false;
+			$this->_left_over_labels = array();
+			$this->_open_forms = array();
+			$this->_complete_forms = array();
+			$this->_frameset = false;
+			$this->_frames = array();
+			$this->_frameset_nesting_level = 0;
+			$this->_text = false;
+			if ($response) {
+				$this->_extractResponse($response);
+			} else {
+				$this->_noResponse();
+			}
+		}
+
+		/**
+		 *    Extracts all of the response information.
+		 *    @param SimpleHttpResponse $response    Response being parsed.
+		 *    @access private
+		 */
+		function _extractResponse($response) {
+			$this->_transport_error = $response->getError();
+			$this->_raw = $response->getContent();
+			$this->_sent = $response->getSent();
+			$this->_headers = $response->getHeaders();
+			$this->_method = $response->getMethod();
+			$this->_url = $response->getUrl();
+			$this->_request_data = $response->getRequestData();
+		}
+
+		/**
+		 *    Sets up a missing response.
+		 *    @access private
+		 */
+		function _noResponse() {
+			$this->_transport_error = 'No page fetched yet';
+			$this->_raw = false;
+			$this->_sent = false;
+			$this->_headers = false;
+			$this->_method = 'GET';
+			$this->_url = false;
+			$this->_request_data = false;
+		}
+
+		/**
+		 *    Original request as bytes sent down the wire.
+		 *    @return mixed              Sent content.
+		 *    @access public
+		 */
+		function getRequest() {
+			return $this->_sent;
+		}
+
+		/**
+		 *    Accessor for raw text of page.
+		 *    @return string        Raw unparsed content.
+		 *    @access public
+		 */
+		function getRaw() {
+			return $this->_raw;
+		}
+
+		/**
+		 *    Accessor for plain text of page as a text browser
+		 *    would see it.
+		 *    @return string        Plain text of page.
+		 *    @access public
+		 */
+		function getText() {
+			if (! $this->_text) {
+				$this->_text = SimpleHtmlSaxParser::normalise($this->_raw);
+			}
+			return $this->_text;
+		}
+
+		/**
+		 *    Accessor for raw headers of page.
+		 *    @return string       Header block as text.
+		 *    @access public
+		 */
+		function getHeaders() {
+			if ($this->_headers) {
+				return $this->_headers->getRaw();
+			}
+			return false;
+		}
+
+		/**
+		 *    Original request method.
+		 *    @return string        GET, POST or HEAD.
+		 *    @access public
+		 */
+		function getMethod() {
+			return $this->_method;
+		}
+
+		/**
+		 *    Original resource name.
+		 *    @return SimpleUrl        Current url.
+		 *    @access public
+		 */
+		function getUrl() {
+			return $this->_url;
+		}
+
+		/**
+		 *    Original request data.
+		 *    @return mixed              Sent content.
+		 *    @access public
+		 */
+		function getRequestData() {
+			return $this->_request_data;
+		}
+
+		/**
+		 *    Accessor for last error.
+		 *    @return string        Error from last response.
+		 *    @access public
+		 */
+		function getTransportError() {
+			return $this->_transport_error;
+		}
+
+		/**
+		 *    Accessor for current MIME type.
+		 *    @return string    MIME type as string; e.g. 'text/html'
+		 *    @access public
+		 */
+		function getMimeType() {
+			if ($this->_headers) {
+				return $this->_headers->getMimeType();
+			}
+			return false;
+		}
+
+		/**
+		 *    Accessor for HTTP response code.
+		 *    @return integer    HTTP response code received.
+		 *    @access public
+		 */
+		function getResponseCode() {
+			if ($this->_headers) {
+				return $this->_headers->getResponseCode();
+			}
+			return false;
+		}
+
+		/**
+		 *    Accessor for last Authentication type. Only valid
+		 *    straight after a challenge (401).
+		 *    @return string    Description of challenge type.
+		 *    @access public
+		 */
+		function getAuthentication() {
+			if ($this->_headers) {
+				return $this->_headers->getAuthentication();
+			}
+			return false;
+		}
+
+		/**
+		 *    Accessor for last Authentication realm. Only valid
+		 *    straight after a challenge (401).
+		 *    @return string    Name of security realm.
+		 *    @access public
+		 */
+		function getRealm() {
+			if ($this->_headers) {
+				return $this->_headers->getRealm();
+			}
+			return false;
+		}
+
+		/**
+		 *    Accessor for current frame focus. Will be
+		 *    false as no frames.
+		 *    @return array    Always empty.
+		 *    @access public
+		 */
+		function getFrameFocus() {
+			return array();
+		}
+
+		/**
+		 *    Sets the focus by index. The integer index starts from 1.
+		 *    @param integer $choice    Chosen frame.
+		 *    @return boolean           Always false.
+		 *    @access public
+		 */
+		function setFrameFocusByIndex($choice) {
+			return false;
+		}
+
+		/**
+		 *    Sets the focus by name. Always fails for a leaf page.
+		 *    @param string $name    Chosen frame.
+		 *    @return boolean        False as no frames.
+		 *    @access public
+		 */
+		function setFrameFocus($name) {
+			return false;
+		}
+
+		/**
+		 *    Clears the frame focus. Does nothing for a leaf page.
+		 *    @access public
+		 */
+		function clearFrameFocus() {
+		}
+
+		/**
+		 *    Adds a tag to the page.
+		 *    @param SimpleTag $tag        Tag to accept.
+		 *    @access public
+		 */
+		function acceptTag($tag) {
+			if ($tag->getTagName() == "a") {
+				$this->_addLink($tag);
+			} elseif ($tag->getTagName() == "title") {
+				$this->_setTitle($tag);
+			} elseif ($this->_isFormElement($tag->getTagName())) {
+				for ($i = 0; $i < count($this->_open_forms); $i++) {
+					$this->_open_forms[$i]->addWidget($tag);
+				}
+				$this->_last_widget = $tag;
+			}
+		}
+
+		/**
+		 *    Opens a label for a described widget.
+		 *    @param SimpleFormTag $tag      Tag to accept.
+		 *    @access public
+		 */
+		function acceptLabelStart($tag) {
+			$this->_label = $tag;
+			unset($this->_last_widget);
+		}
+
+		/**
+		 *    Closes the most recently opened label.
+		 *    @access public
+		 */
+		function acceptLabelEnd() {
+			if (isset($this->_label)) {
+				if (isset($this->_last_widget)) {
+					$this->_last_widget->setLabel($this->_label->getText());
+					unset($this->_last_widget);
+				} else {
+					$this->_left_over_labels[] = SimpleTestCompatibility::copy($this->_label);
+				}
+				unset($this->_label);
+			}
+		}
+
+		/**
+		 *    Tests to see if a tag is a possible form
+		 *    element.
+		 *    @param string $name     HTML element name.
+		 *    @return boolean         True if form element.
+		 *    @access private
+		 */
+		function _isFormElement($name) {
+			return in_array($name, array('input', 'button', 'textarea', 'select'));
+		}
+
+		/**
+		 *    Opens a form. New widgets go here.
+		 *    @param SimpleFormTag $tag      Tag to accept.
+		 *    @access public
+		 */
+		function acceptFormStart($tag) {
+			$this->_open_forms[] = new SimpleForm($tag, $this->getUrl());
+		}
+
+		/**
+		 *    Closes the most recently opened form.
+		 *    @access public
+		 */
+		function acceptFormEnd() {
+			if (count($this->_open_forms)) {
+				$this->_complete_forms[] = array_pop($this->_open_forms);
+			}
+		}
+
+		/**
+		 *    Opens a frameset. A frameset may contain nested
+		 *    frameset tags.
+		 *    @param SimpleFramesetTag $tag      Tag to accept.
+		 *    @access public
+		 */
+		function acceptFramesetStart($tag) {
+			if (! $this->_isLoadingFrames()) {
+				$this->_frameset = $tag;
+			}
+			$this->_frameset_nesting_level++;
+		}
+
+		/**
+		 *    Closes the most recently opened frameset.
+		 *    @access public
+		 */
+		function acceptFramesetEnd() {
+			if ($this->_isLoadingFrames()) {
+				$this->_frameset_nesting_level--;
+			}
+		}
+
+		/**
+		 *    Takes a single frame tag and stashes it in
+		 *    the current frame set.
+		 *    @param SimpleFrameTag $tag      Tag to accept.
+		 *    @access public
+		 */
+		function acceptFrame($tag) {
+			if ($this->_isLoadingFrames()) {
+				if ($tag->getAttribute('src')) {
+					$this->_frames[] = $tag;
+				}
+			}
+		}
+
+		/**
+		 *    Test to see if in the middle of reading
+		 *    a frameset.
+		 *    @return boolean        True if inframeset.
+		 *    @access private
+		 */
+		function _isLoadingFrames() {
+			if (! $this->_frameset) {
+				return false;
+			}
+			return ($this->_frameset_nesting_level > 0);
+		}
+
+		/**
+		 *    Test to see if link is an absolute one.
+		 *    @param string $url     Url to test.
+		 *    @return boolean        True if absolute.
+		 *    @access protected
+		 */
+		function _linkIsAbsolute($url) {
+			$parsed = new SimpleUrl($url);
+			return (boolean)($parsed->getScheme() && $parsed->getHost());
+		}
+
+		/**
+		 *    Adds a link to the page.
+		 *    @param SimpleAnchorTag $tag      Link to accept.
+		 *    @access protected
+		 */
+		function _addLink($tag) {
+			$this->_links[] = $tag;
+		}
+
+		/**
+		 *    Marker for end of complete page. Any work in
+		 *    progress can now be closed.
+		 *    @access public
+		 */
+		function acceptPageEnd() {
+			while (count($this->_open_forms)) {
+				$this->_complete_forms[] = array_pop($this->_open_forms);
+			}
+			foreach ($this->_left_over_labels as $label) {
+				for ($i = 0, $count = count($this->_complete_forms); $i < $count; $i++) {
+					$this->_complete_forms[$i]->attachLabelBySelector(
+							new SimpleById($label->getFor()),
+							$label->getText());
+				}
+			}
+		}
+
+		/**
+		 *    Test for the presence of a frameset.
+		 *    @return boolean        True if frameset.
+		 *    @access public
+		 */
+		function hasFrames() {
+			return (boolean)$this->_frameset;
+		}
+
+		/**
+		 *    Accessor for frame name and source URL for every frame that
+		 *    will need to be loaded. Immediate children only.
+		 *    @return boolean/array     False if no frameset or
+		 *                              otherwise a hash of frame URLs.
+		 *                              The key is either a numerical
+		 *                              base one index or the name attribute.
+		 *    @access public
+		 */
+		function getFrameset() {
+			if (! $this->_frameset) {
+				return false;
+			}
+			$urls = array();
+			for ($i = 0; $i < count($this->_frames); $i++) {
+				$name = $this->_frames[$i]->getAttribute('name');
+				$url = new SimpleUrl($this->_frames[$i]->getAttribute('src'));
+				$urls[$name ? $name : $i + 1] = $url->makeAbsolute($this->getUrl());
+			}
+			return $urls;
+		}
+
+		/**
+		 *    Fetches a list of loaded frames.
+		 *    @return array/string    Just the URL for a single page.
+		 *    @access public
+		 */
+		function getFrames() {
+			$url = $this->getUrl();
+			return $url->asString();
+		}
+
+		/**
+		 *    Accessor for a list of all fixed links.
+		 *    @return array   List of urls with scheme of
+		 *                    http or https and hostname.
+		 *    @access public
+		 */
+		function getAbsoluteUrls() {
+			$all = array();
+			foreach ($this->_links as $link) {
+				if ($this->_linkIsAbsolute($link->getHref())) {
+					$all[] = $link->getHref();
+				}
+			}
+			return $all;
+		}
+
+		/**
+		 *    Accessor for a list of all relative links.
+		 *    @return array      List of urls without hostname.
+		 *    @access public
+		 */
+		function getRelativeUrls() {
+			$all = array();
+			foreach ($this->_links as $link) {
+				if (! $this->_linkIsAbsolute($link->getHref())) {
+					$all[] = $link->getHref();
+				}
+			}
+			return $all;
+		}
+
+		/**
+		 *    Accessor for URLs by the link label. Label will match
+		 *    regardess of whitespace issues and case.
+		 *    @param string $label    Text of link.
+		 *    @return array           List of links with that label.
+		 *    @access public
+		 */
+		function getUrlsByLabel($label) {
+			$matches = array();
+			foreach ($this->_links as $link) {
+				if ($link->getText() == $label) {
+					$matches[] = $this->_getUrlFromLink($link);
+				}
+			}
+			return $matches;
+		}
+
+		/**
+		 *    Accessor for a URL by the id attribute.
+		 *    @param string $id       Id attribute of link.
+		 *    @return SimpleUrl       URL with that id of false if none.
+		 *    @access public
+		 */
+		function getUrlById($id) {
+			foreach ($this->_links as $link) {
+				if ($link->getAttribute('id') === (string)$id) {
+					return $this->_getUrlFromLink($link);
+				}
+			}
+			return false;
+		}
+
+		/**
+		 *    Converts a link into a target URL.
+		 *    @param SimpleAnchor $link    Parsed link.
+		 *    @return SimpleUrl            URL with frame target if any.
+		 *    @access private
+		 */
+		function _getUrlFromLink($link) {
+			$url = $this->_makeAbsolute($link->getHref());
+			if ($link->getAttribute('target')) {
+				$url->setTarget($link->getAttribute('target'));
+			}
+			return $url;
+		}
+
+		/**
+		 *    Expands expandomatic URLs into fully qualified
+		 *    URLs.
+		 *    @param SimpleUrl $url        Relative URL.
+		 *    @return SimpleUrl            Absolute URL.
+		 *    @access protected
+		 */
+		function _makeAbsolute($url) {
+			if (! is_object($url)) {
+				$url = new SimpleUrl($url);
+			}
+			return $url->makeAbsolute($this->getUrl());
+		}
+
+		/**
+		 *    Sets the title tag contents.
+		 *    @param SimpleTitleTag $tag    Title of page.
+		 *    @access protected
+		 */
+		function _setTitle($tag) {
+			$this->_title = $tag;
+		}
+
+		/**
+		 *    Accessor for parsed title.
+		 *    @return string     Title or false if no title is present.
+		 *    @access public
+		 */
+		function getTitle() {
+			if ($this->_title) {
+				return $this->_title->getText();
+			}
+			return false;
+		}
+
+		/**
+		 *    Finds a held form by button label. Will only
+		 *    search correctly built forms.
+		 *    @param SimpleSelector $selector       Button finder.
+		 *    @return SimpleForm                    Form object containing
+		 *                                          the button.
+		 *    @access public
+		 */
+		function &getFormBySubmit($selector) {
+			for ($i = 0; $i < count($this->_complete_forms); $i++) {
+				if ($this->_complete_forms[$i]->hasSubmit($selector)) {
+					return $this->_complete_forms[$i];
+				}
+			}
+			$null = null;
+			return $null;
+		}
+
+		/**
+		 *    Finds a held form by image using a selector.
+		 *    Will only search correctly built forms.
+		 *    @param SimpleSelector $selector  Image finder.
+		 *    @return SimpleForm               Form object containing
+		 *                                     the image.
+		 *    @access public
+		 */
+		function &getFormByImage($selector) {
+			for ($i = 0; $i < count($this->_complete_forms); $i++) {
+				if ($this->_complete_forms[$i]->hasImage($selector)) {
+					return $this->_complete_forms[$i];
+				}
+			}
+			$null = null;
+			return $null;
+		}
+
+		/**
+		 *    Finds a held form by the form ID. A way of
+		 *    identifying a specific form when we have control
+		 *    of the HTML code.
+		 *    @param string $id     Form label.
+		 *    @return SimpleForm    Form object containing the matching ID.
+		 *    @access public
+		 */
+		function &getFormById($id) {
+			for ($i = 0; $i < count($this->_complete_forms); $i++) {
+				if ($this->_complete_forms[$i]->getId() == $id) {
+					return $this->_complete_forms[$i];
+				}
+			}
+			$null = null;
+			return $null;
+		}
+
+		/**
+		 *    Sets a field on each form in which the field is
+		 *    available.
+		 *    @param SimpleSelector $selector    Field finder.
+		 *    @param string $value               Value to set field to.
+		 *    @return boolean                    True if value is valid.
+		 *    @access public
+		 */
+		function setField($selector, $value) {
+			$is_set = false;
+			for ($i = 0; $i < count($this->_complete_forms); $i++) {
+				if ($this->_complete_forms[$i]->setField($selector, $value)) {
+					$is_set = true;
+				}
+			}
+			return $is_set;
+		}
+
+		/**
+		 *    Accessor for a form element value within a page.
+		 *    @param SimpleSelector $selector    Field finder.
+		 *    @return string/boolean             A string if the field is
+		 *                                       present, false if unchecked
+		 *                                       and null if missing.
+		 *    @access public
+		 */
+		function getField($selector) {
+			for ($i = 0; $i < count($this->_complete_forms); $i++) {
+				$value = $this->_complete_forms[$i]->getValue($selector);
+				if (isset($value)) {
+					return $value;
+				}
+			}
+			return null;
+		}
+	}

tests/test_tools/simpletest/detached.php

Indentation +79 added lines, -79 removed lines

@@ -1,95 +1,95 @@
 <?php
-    /**
-     *	base include file for SimpleTest
-     *	@package	SimpleTest
-     *	@subpackage	UnitTester
-     *	@version	$Id: detached.php 1398 2006-09-08 19:31:03Z xue $
-     */
+	/**
+	 *	base include file for SimpleTest
+	 *	@package	SimpleTest
+	 *	@subpackage	UnitTester
+	 *	@version	$Id: detached.php 1398 2006-09-08 19:31:03Z xue $
+	 */
 
-    /**#@+
+	/**#@+
      *	include other SimpleTest class files
      */
-    require_once(dirname(__FILE__) . '/xml.php');
-    require_once(dirname(__FILE__) . '/shell_tester.php');
-    /**#@-*/
+	require_once(dirname(__FILE__) . '/xml.php');
+	require_once(dirname(__FILE__) . '/shell_tester.php');
+	/**#@-*/
 
-    /**
-     *    Runs an XML formated test in a separate process.
+	/**
+	 *    Runs an XML formated test in a separate process.
 	 *	  @package SimpleTest
 	 *	  @subpackage UnitTester
-     */
-    class DetachedTestCase {
-        protected $_command;
-        protected $_dry_command;
-        protected $_size;
+	 */
+	class DetachedTestCase {
+		protected $_command;
+		protected $_dry_command;
+		protected $_size;
 
-        /**
-         *    Sets the location of the remote test.
-         *    @param string $command       Test script.
-         *    @param string $dry_command   Script for dry run.
-         *    @access public
-         */
-        function DetachedTestCase($command, $dry_command = false) {
-            $this->_command = $command;
-            $this->_dry_command = $dry_command ? $dry_command : $command;
-            $this->_size = false;
-        }
+		/**
+		 *    Sets the location of the remote test.
+		 *    @param string $command       Test script.
+		 *    @param string $dry_command   Script for dry run.
+		 *    @access public
+		 */
+		function DetachedTestCase($command, $dry_command = false) {
+			$this->_command = $command;
+			$this->_dry_command = $dry_command ? $dry_command : $command;
+			$this->_size = false;
+		}
 
-        /**
-         *    Accessor for the test name for subclasses.
-         *    @return string       Name of the test.
-         *    @access public
-         */
-        function getLabel() {
-            return $this->_command;
-        }
+		/**
+		 *    Accessor for the test name for subclasses.
+		 *    @return string       Name of the test.
+		 *    @access public
+		 */
+		function getLabel() {
+			return $this->_command;
+		}
 
-        /**
-         *    Runs the top level test for this class. Currently
-         *    reads the data as a single chunk. I'll fix this
-         *    once I have added iteration to the browser.
-         *    @param SimpleReporter $reporter    Target of test results.
-         *    @returns boolean                   True if no failures.
-         *    @access public
-         */
-        function run($reporter) {
+		/**
+		 *    Runs the top level test for this class. Currently
+		 *    reads the data as a single chunk. I'll fix this
+		 *    once I have added iteration to the browser.
+		 *    @param SimpleReporter $reporter    Target of test results.
+		 *    @returns boolean                   True if no failures.
+		 *    @access public
+		 */
+		function run($reporter) {
 			$shell = new SimpleShell();
 			$shell->execute($this->_command);
-            $parser = $this->_createParser($reporter);
-            if (! $parser->parse($shell->getOutput())) {
-                trigger_error('Cannot parse incoming XML from [' . $this->_command . ']');
-                return false;
-            }
-            return true;
-        }
+			$parser = $this->_createParser($reporter);
+			if (! $parser->parse($shell->getOutput())) {
+				trigger_error('Cannot parse incoming XML from [' . $this->_command . ']');
+				return false;
+			}
+			return true;
+		}
 
-        /**
-         *    Accessor for the number of subtests.
-         *    @return integer       Number of test cases.
-         *    @access public
-         */
-        function getSize() {
-            if ($this->_size === false) {
+		/**
+		 *    Accessor for the number of subtests.
+		 *    @return integer       Number of test cases.
+		 *    @access public
+		 */
+		function getSize() {
+			if ($this->_size === false) {
 				$shell = new SimpleShell();
 				$shell->execute($this->_dry_command);
-                $reporter = new SimpleReporter();
-                $parser = $this->_createParser($reporter);
-                if (! $parser->parse($shell->getOutput())) {
-                    trigger_error('Cannot parse incoming XML from [' . $this->_dry_command . ']');
-                    return false;
-                }
-                $this->_size = $reporter->getTestCaseCount();
-            }
-            return $this->_size;
-        }
+				$reporter = new SimpleReporter();
+				$parser = $this->_createParser($reporter);
+				if (! $parser->parse($shell->getOutput())) {
+					trigger_error('Cannot parse incoming XML from [' . $this->_dry_command . ']');
+					return false;
+				}
+				$this->_size = $reporter->getTestCaseCount();
+			}
+			return $this->_size;
+		}
 
-        /**
-         *    Creates the XML parser.
-         *    @param SimpleReporter $reporter    Target of test results.
-         *    @return SimpleTestXmlListener      XML reader.
-         *    @access protected
-         */
-        function &_createParser($reporter) {
-            return new SimpleTestXmlParser($reporter);
-        }
-    }
\ No newline at end of file
+		/**
+		 *    Creates the XML parser.
+		 *    @param SimpleReporter $reporter    Target of test results.
+		 *    @return SimpleTestXmlListener      XML reader.
+		 *    @access protected
+		 */
+		function &_createParser($reporter) {
+			return new SimpleTestXmlParser($reporter);
+		}
+	}
\ No newline at end of file

tests/test_tools/simpletest/scorer.php

Indentation +767 added lines, -767 removed lines

@@ -1,776 +1,776 @@
 <?php
-    /**
-     *	base include file for SimpleTest
-     *	@package	SimpleTest
-     *	@subpackage	UnitTester
-     *	@version	$Id: scorer.php 1532 2006-12-01 12:28:55Z xue $
-     */
-
-    /**#@+*/
-    require_once(dirname(__FILE__) . '/invoker.php');
-    /**#@-*/
-
-    /**
-     *    Can recieve test events and display them. Display
-     *    is achieved by making display methods available
-     *    and visiting the incoming event.
+	/**
+	 *	base include file for SimpleTest
+	 *	@package	SimpleTest
+	 *	@subpackage	UnitTester
+	 *	@version	$Id: scorer.php 1532 2006-12-01 12:28:55Z xue $
+	 */
+
+	/**#@+*/
+	require_once(dirname(__FILE__) . '/invoker.php');
+	/**#@-*/
+
+	/**
+	 *    Can recieve test events and display them. Display
+	 *    is achieved by making display methods available
+	 *    and visiting the incoming event.
 	 *	  @package SimpleTest
 	 *	  @subpackage UnitTester
-     *    @abstract
-     */
-    class SimpleScorer {
-        protected $_passes;
-        protected $_fails;
-        protected $_exceptions;
-        protected $_is_dry_run;
-
-        /**
-         *    Starts the test run with no results.
-         *    @access public
-         */
-        function SimpleScorer() {
-            $this->_passes = 0;
-            $this->_fails = 0;
-            $this->_exceptions = 0;
-            $this->_is_dry_run = false;
-        }
-
-        /**
-         *    Signals that the next evaluation will be a dry
-         *    run. That is, the structure events will be
-         *    recorded, but no tests will be run.
-         *    @param boolean $is_dry        Dry run if true.
-         *    @access public
-         */
-        function makeDry($is_dry = true) {
-            $this->_is_dry_run = $is_dry;
-        }
-
-        /**
-         *    The reporter has a veto on what should be run.
-         *    @param string $test_case_name  name of test case.
-         *    @param string $method          Name of test method.
-         *    @access public
-         */
-        function shouldInvoke($test_case_name, $method) {
-            return ! $this->_is_dry_run;
-        }
-
-        /**
-         *    Can wrap the invoker in preperation for running
-         *    a test.
-         *    @param SimpleInvoker $invoker   Individual test runner.
-         *    @return SimpleInvoker           Wrapped test runner.
-         *    @access public
-         */
-        function &createInvoker($invoker) {
-            return $invoker;
-        }
-
-        /**
-         *    Accessor for current status. Will be false
-         *    if there have been any failures or exceptions.
-         *    Used for command line tools.
-         *    @return boolean        True if no failures.
-         *    @access public
-         */
-        function getStatus() {
-            if ($this->_exceptions + $this->_fails > 0) {
-                return false;
-            }
-            return true;
-        }
-
-        /**
-         *    Paints the start of a group test.
-         *    @param string $test_name     Name of test or other label.
-         *    @param integer $size         Number of test cases starting.
-         *    @access public
-         */
-        function paintGroupStart($test_name, $size) {
-        }
-
-        /**
-         *    Paints the end of a group test.
-         *    @param string $test_name     Name of test or other label.
-         *    @access public
-         */
-        function paintGroupEnd($test_name) {
-        }
-
-        /**
-         *    Paints the start of a test case.
-         *    @param string $test_name     Name of test or other label.
-         *    @access public
-         */
-        function paintCaseStart($test_name) {
-        }
-
-        /**
-         *    Paints the end of a test case.
-         *    @param string $test_name     Name of test or other label.
-         *    @access public
-         */
-        function paintCaseEnd($test_name) {
-        }
-
-        /**
-         *    Paints the start of a test method.
-         *    @param string $test_name     Name of test or other label.
-         *    @access public
-         */
-        function paintMethodStart($test_name) {
-        }
-
-        /**
-         *    Paints the end of a test method.
-         *    @param string $test_name     Name of test or other label.
-         *    @access public
-         */
-        function paintMethodEnd($test_name) {
-        }
-
-        /**
-         *    Increments the pass count.
-         *    @param string $message        Message is ignored.
-         *    @access public
-         */
-        function paintPass($message) {
-            $this->_passes++;
-        }
-
-        /**
-         *    Increments the fail count.
-         *    @param string $message        Message is ignored.
-         *    @access public
-         */
-        function paintFail($message) {
-            $this->_fails++;
-        }
-
-        /**
-         *    Deals with PHP 4 throwing an error or PHP 5
-         *    throwing an exception.
-         *    @param string $message    Text of error formatted by
-         *                              the test case.
-         *    @access public
-         */
-        function paintError($message) {
-            $this->_exceptions++;
-        }
-
-        /**
-         *    Accessor for the number of passes so far.
-         *    @return integer       Number of passes.
-         *    @access public
-         */
-        function getPassCount() {
-            return $this->_passes;
-        }
-
-        /**
-         *    Accessor for the number of fails so far.
-         *    @return integer       Number of fails.
-         *    @access public
-         */
-        function getFailCount() {
-            return $this->_fails;
-        }
-
-        /**
-         *    Accessor for the number of untrapped errors
-         *    so far.
-         *    @return integer       Number of exceptions.
-         *    @access public
-         */
-        function getExceptionCount() {
-            return $this->_exceptions;
-        }
-
-        /**
-         *    Paints a simple supplementary message.
-         *    @param string $message        Text to display.
-         *    @access public
-         */
-        function paintMessage($message) {
-        }
-
-        /**
-         *    Paints a formatted ASCII message such as a
-         *    variable dump.
-         *    @param string $message        Text to display.
-         *    @access public
-         */
-        function paintFormattedMessage($message) {
-        }
-
-        /**
-         *    By default just ignores user generated events.
-         *    @param string $type        Event type as text.
-         *    @param mixed $payload      Message or object.
-         *    @access public
-         */
-        function paintSignal($type, $payload) {
-        }
-    }
-
-    /**
-     *    Recipient of generated test messages that can display
-     *    page footers and headers. Also keeps track of the
-     *    test nesting. This is the main base class on which
-     *    to build the finished test (page based) displays.
+	 *    @abstract
+	 */
+	class SimpleScorer {
+		protected $_passes;
+		protected $_fails;
+		protected $_exceptions;
+		protected $_is_dry_run;
+
+		/**
+		 *    Starts the test run with no results.
+		 *    @access public
+		 */
+		function SimpleScorer() {
+			$this->_passes = 0;
+			$this->_fails = 0;
+			$this->_exceptions = 0;
+			$this->_is_dry_run = false;
+		}
+
+		/**
+		 *    Signals that the next evaluation will be a dry
+		 *    run. That is, the structure events will be
+		 *    recorded, but no tests will be run.
+		 *    @param boolean $is_dry        Dry run if true.
+		 *    @access public
+		 */
+		function makeDry($is_dry = true) {
+			$this->_is_dry_run = $is_dry;
+		}
+
+		/**
+		 *    The reporter has a veto on what should be run.
+		 *    @param string $test_case_name  name of test case.
+		 *    @param string $method          Name of test method.
+		 *    @access public
+		 */
+		function shouldInvoke($test_case_name, $method) {
+			return ! $this->_is_dry_run;
+		}
+
+		/**
+		 *    Can wrap the invoker in preperation for running
+		 *    a test.
+		 *    @param SimpleInvoker $invoker   Individual test runner.
+		 *    @return SimpleInvoker           Wrapped test runner.
+		 *    @access public
+		 */
+		function &createInvoker($invoker) {
+			return $invoker;
+		}
+
+		/**
+		 *    Accessor for current status. Will be false
+		 *    if there have been any failures or exceptions.
+		 *    Used for command line tools.
+		 *    @return boolean        True if no failures.
+		 *    @access public
+		 */
+		function getStatus() {
+			if ($this->_exceptions + $this->_fails > 0) {
+				return false;
+			}
+			return true;
+		}
+
+		/**
+		 *    Paints the start of a group test.
+		 *    @param string $test_name     Name of test or other label.
+		 *    @param integer $size         Number of test cases starting.
+		 *    @access public
+		 */
+		function paintGroupStart($test_name, $size) {
+		}
+
+		/**
+		 *    Paints the end of a group test.
+		 *    @param string $test_name     Name of test or other label.
+		 *    @access public
+		 */
+		function paintGroupEnd($test_name) {
+		}
+
+		/**
+		 *    Paints the start of a test case.
+		 *    @param string $test_name     Name of test or other label.
+		 *    @access public
+		 */
+		function paintCaseStart($test_name) {
+		}
+
+		/**
+		 *    Paints the end of a test case.
+		 *    @param string $test_name     Name of test or other label.
+		 *    @access public
+		 */
+		function paintCaseEnd($test_name) {
+		}
+
+		/**
+		 *    Paints the start of a test method.
+		 *    @param string $test_name     Name of test or other label.
+		 *    @access public
+		 */
+		function paintMethodStart($test_name) {
+		}
+
+		/**
+		 *    Paints the end of a test method.
+		 *    @param string $test_name     Name of test or other label.
+		 *    @access public
+		 */
+		function paintMethodEnd($test_name) {
+		}
+
+		/**
+		 *    Increments the pass count.
+		 *    @param string $message        Message is ignored.
+		 *    @access public
+		 */
+		function paintPass($message) {
+			$this->_passes++;
+		}
+
+		/**
+		 *    Increments the fail count.
+		 *    @param string $message        Message is ignored.
+		 *    @access public
+		 */
+		function paintFail($message) {
+			$this->_fails++;
+		}
+
+		/**
+		 *    Deals with PHP 4 throwing an error or PHP 5
+		 *    throwing an exception.
+		 *    @param string $message    Text of error formatted by
+		 *                              the test case.
+		 *    @access public
+		 */
+		function paintError($message) {
+			$this->_exceptions++;
+		}
+
+		/**
+		 *    Accessor for the number of passes so far.
+		 *    @return integer       Number of passes.
+		 *    @access public
+		 */
+		function getPassCount() {
+			return $this->_passes;
+		}
+
+		/**
+		 *    Accessor for the number of fails so far.
+		 *    @return integer       Number of fails.
+		 *    @access public
+		 */
+		function getFailCount() {
+			return $this->_fails;
+		}
+
+		/**
+		 *    Accessor for the number of untrapped errors
+		 *    so far.
+		 *    @return integer       Number of exceptions.
+		 *    @access public
+		 */
+		function getExceptionCount() {
+			return $this->_exceptions;
+		}
+
+		/**
+		 *    Paints a simple supplementary message.
+		 *    @param string $message        Text to display.
+		 *    @access public
+		 */
+		function paintMessage($message) {
+		}
+
+		/**
+		 *    Paints a formatted ASCII message such as a
+		 *    variable dump.
+		 *    @param string $message        Text to display.
+		 *    @access public
+		 */
+		function paintFormattedMessage($message) {
+		}
+
+		/**
+		 *    By default just ignores user generated events.
+		 *    @param string $type        Event type as text.
+		 *    @param mixed $payload      Message or object.
+		 *    @access public
+		 */
+		function paintSignal($type, $payload) {
+		}
+	}
+
+	/**
+	 *    Recipient of generated test messages that can display
+	 *    page footers and headers. Also keeps track of the
+	 *    test nesting. This is the main base class on which
+	 *    to build the finished test (page based) displays.
 	 *	  @package SimpleTest
 	 *	  @subpackage UnitTester
-     */
-    class SimpleReporter extends SimpleScorer {
-        protected $_test_stack;
-        protected $_size;
-        protected $_progress;
-
-        /**
-         *    Starts the display with no results in.
-         *    @access public
-         */
-        function SimpleReporter() {
-            $this->SimpleScorer();
-            $this->_test_stack = array();
-            $this->_size = null;
-            $this->_progress = 0;
-        }
-
-        /**
-         *    Paints the start of a group test. Will also paint
-         *    the page header and footer if this is the
-         *    first test. Will stash the size if the first
-         *    start.
-         *    @param string $test_name   Name of test that is starting.
-         *    @param integer $size       Number of test cases starting.
-         *    @access public
-         */
-        function paintGroupStart($test_name, $size) {
-            if (! isset($this->_size)) {
-                $this->_size = $size;
-            }
-            if (count($this->_test_stack) == 0) {
-                $this->paintHeader($test_name);
-            }
-            $this->_test_stack[] = $test_name;
-        }
-
-        /**
-         *    Paints the end of a group test. Will paint the page
-         *    footer if the stack of tests has unwound.
-         *    @param string $test_name   Name of test that is ending.
-         *    @param integer $progress   Number of test cases ending.
-         *    @access public
-         */
-        function paintGroupEnd($test_name) {
-            array_pop($this->_test_stack);
-            if (count($this->_test_stack) == 0) {
-                $this->paintFooter($test_name);
-            }
-        }
-
-        /**
-         *    Paints the start of a test case. Will also paint
-         *    the page header and footer if this is the
-         *    first test. Will stash the size if the first
-         *    start.
-         *    @param string $test_name   Name of test that is starting.
-         *    @access public
-         */
-        function paintCaseStart($test_name) {
-            if (! isset($this->_size)) {
-                $this->_size = 1;
-            }
-            if (count($this->_test_stack) == 0) {
-                $this->paintHeader($test_name);
-            }
-            $this->_test_stack[] = $test_name;
-        }
-
-        /**
-         *    Paints the end of a test case. Will paint the page
-         *    footer if the stack of tests has unwound.
-         *    @param string $test_name   Name of test that is ending.
-         *    @access public
-         */
-        function paintCaseEnd($test_name) {
-            $this->_progress++;
-            array_pop($this->_test_stack);
-            if (count($this->_test_stack) == 0) {
-                $this->paintFooter($test_name);
-            }
-        }
-
-        /**
-         *    Paints the start of a test method.
-         *    @param string $test_name   Name of test that is starting.
-         *    @access public
-         */
-        function paintMethodStart($test_name) {
-            $this->_test_stack[] = $test_name;
-        }
-
-        /**
-         *    Paints the end of a test method. Will paint the page
-         *    footer if the stack of tests has unwound.
-         *    @param string $test_name   Name of test that is ending.
-         *    @access public
-         */
-        function paintMethodEnd($test_name) {
-            array_pop($this->_test_stack);
-        }
-
-        /**
-         *    Paints the test document header.
-         *    @param string $test_name     First test top level
-         *                                 to start.
-         *    @access public
-         *    @abstract
-         */
-        function paintHeader($test_name) {
-        }
-
-        /**
-         *    Paints the test document footer.
-         *    @param string $test_name        The top level test.
-         *    @access public
-         *    @abstract
-         */
-        function paintFooter($test_name) {
-        }
-
-        /**
-         *    Accessor for internal test stack. For
-         *    subclasses that need to see the whole test
-         *    history for display purposes.
-         *    @return array     List of methods in nesting order.
-         *    @access public
-         */
-        function getTestList() {
-            return $this->_test_stack;
-        }
-
-        /**
-         *    Accessor for total test size in number
-         *    of test cases. Null until the first
-         *    test is started.
-         *    @return integer   Total number of cases at start.
-         *    @access public
-         */
-        function getTestCaseCount() {
-            return $this->_size;
-        }
-
-        /**
-         *    Accessor for the number of test cases
-         *    completed so far.
-         *    @return integer   Number of ended cases.
-         *    @access public
-         */
-        function getTestCaseProgress() {
-            return $this->_progress;
-        }
-
-        /**
-         *    Static check for running in the comand line.
-         *    @return boolean        True if CLI.
-         *    @access public
-         *    @static
-         */
-        static function inCli() {
-            return php_sapi_name() == 'cli';
-        }
-    }
-
-    /**
-     *    For modifying the behaviour of the visual reporters.
+	 */
+	class SimpleReporter extends SimpleScorer {
+		protected $_test_stack;
+		protected $_size;
+		protected $_progress;
+
+		/**
+		 *    Starts the display with no results in.
+		 *    @access public
+		 */
+		function SimpleReporter() {
+			$this->SimpleScorer();
+			$this->_test_stack = array();
+			$this->_size = null;
+			$this->_progress = 0;
+		}
+
+		/**
+		 *    Paints the start of a group test. Will also paint
+		 *    the page header and footer if this is the
+		 *    first test. Will stash the size if the first
+		 *    start.
+		 *    @param string $test_name   Name of test that is starting.
+		 *    @param integer $size       Number of test cases starting.
+		 *    @access public
+		 */
+		function paintGroupStart($test_name, $size) {
+			if (! isset($this->_size)) {
+				$this->_size = $size;
+			}
+			if (count($this->_test_stack) == 0) {
+				$this->paintHeader($test_name);
+			}
+			$this->_test_stack[] = $test_name;
+		}
+
+		/**
+		 *    Paints the end of a group test. Will paint the page
+		 *    footer if the stack of tests has unwound.
+		 *    @param string $test_name   Name of test that is ending.
+		 *    @param integer $progress   Number of test cases ending.
+		 *    @access public
+		 */
+		function paintGroupEnd($test_name) {
+			array_pop($this->_test_stack);
+			if (count($this->_test_stack) == 0) {
+				$this->paintFooter($test_name);
+			}
+		}
+
+		/**
+		 *    Paints the start of a test case. Will also paint
+		 *    the page header and footer if this is the
+		 *    first test. Will stash the size if the first
+		 *    start.
+		 *    @param string $test_name   Name of test that is starting.
+		 *    @access public
+		 */
+		function paintCaseStart($test_name) {
+			if (! isset($this->_size)) {
+				$this->_size = 1;
+			}
+			if (count($this->_test_stack) == 0) {
+				$this->paintHeader($test_name);
+			}
+			$this->_test_stack[] = $test_name;
+		}
+
+		/**
+		 *    Paints the end of a test case. Will paint the page
+		 *    footer if the stack of tests has unwound.
+		 *    @param string $test_name   Name of test that is ending.
+		 *    @access public
+		 */
+		function paintCaseEnd($test_name) {
+			$this->_progress++;
+			array_pop($this->_test_stack);
+			if (count($this->_test_stack) == 0) {
+				$this->paintFooter($test_name);
+			}
+		}
+
+		/**
+		 *    Paints the start of a test method.
+		 *    @param string $test_name   Name of test that is starting.
+		 *    @access public
+		 */
+		function paintMethodStart($test_name) {
+			$this->_test_stack[] = $test_name;
+		}
+
+		/**
+		 *    Paints the end of a test method. Will paint the page
+		 *    footer if the stack of tests has unwound.
+		 *    @param string $test_name   Name of test that is ending.
+		 *    @access public
+		 */
+		function paintMethodEnd($test_name) {
+			array_pop($this->_test_stack);
+		}
+
+		/**
+		 *    Paints the test document header.
+		 *    @param string $test_name     First test top level
+		 *                                 to start.
+		 *    @access public
+		 *    @abstract
+		 */
+		function paintHeader($test_name) {
+		}
+
+		/**
+		 *    Paints the test document footer.
+		 *    @param string $test_name        The top level test.
+		 *    @access public
+		 *    @abstract
+		 */
+		function paintFooter($test_name) {
+		}
+
+		/**
+		 *    Accessor for internal test stack. For
+		 *    subclasses that need to see the whole test
+		 *    history for display purposes.
+		 *    @return array     List of methods in nesting order.
+		 *    @access public
+		 */
+		function getTestList() {
+			return $this->_test_stack;
+		}
+
+		/**
+		 *    Accessor for total test size in number
+		 *    of test cases. Null until the first
+		 *    test is started.
+		 *    @return integer   Total number of cases at start.
+		 *    @access public
+		 */
+		function getTestCaseCount() {
+			return $this->_size;
+		}
+
+		/**
+		 *    Accessor for the number of test cases
+		 *    completed so far.
+		 *    @return integer   Number of ended cases.
+		 *    @access public
+		 */
+		function getTestCaseProgress() {
+			return $this->_progress;
+		}
+
+		/**
+		 *    Static check for running in the comand line.
+		 *    @return boolean        True if CLI.
+		 *    @access public
+		 *    @static
+		 */
+		static function inCli() {
+			return php_sapi_name() == 'cli';
+		}
+	}
+
+	/**
+	 *    For modifying the behaviour of the visual reporters.
 	 *	  @package SimpleTest
 	 *	  @subpackage UnitTester
-     */
-    class SimpleReporterDecorator {
-        protected $_reporter;
-
-        /**
-         *    Mediates between teh reporter and the test case.
-         *    @param SimpleScorer $reporter       Reporter to receive events.
-         */
-        function SimpleReporterDecorator($reporter) {
-            $this->_reporter = $reporter;
-        }
-
-        /**
-         *    Signals that the next evaluation will be a dry
-         *    run. That is, the structure events will be
-         *    recorded, but no tests will be run.
-         *    @param boolean $is_dry        Dry run if true.
-         *    @access public
-         */
-        function makeDry($is_dry = true) {
-            $this->_reporter->makeDry($is_dry);
-        }
-
-        /**
-         *    Accessor for current status. Will be false
-         *    if there have been any failures or exceptions.
-         *    Used for command line tools.
-         *    @return boolean        True if no failures.
-         *    @access public
-         */
-        function getStatus() {
-            return $this->_reporter->getStatus();
-        }
-
-        /**
-         *    The reporter has a veto on what should be run.
-         *    @param string $test_case_name  name of test case.
-         *    @param string $method          Name of test method.
-         *    @return boolean                True if test should be run.
-         *    @access public
-         */
-        function shouldInvoke($test_case_name, $method) {
-            return $this->_reporter->shouldInvoke($test_case_name, $method);
-        }
-
-        /**
-         *    Can wrap the invoker in preperation for running
-         *    a test.
-         *    @param SimpleInvoker $invoker   Individual test runner.
-         *    @return SimpleInvoker           Wrapped test runner.
-         *    @access public
-         */
-        function &createInvoker($invoker) {
-            return $this->_reporter->createInvoker($invoker);
-        }
-
-        /**
-         *    Paints the start of a group test.
-         *    @param string $test_name     Name of test or other label.
-         *    @param integer $size         Number of test cases starting.
-         *    @access public
-         */
-        function paintGroupStart($test_name, $size) {
-            $this->_reporter->paintGroupStart($test_name, $size);
-        }
-
-        /**
-         *    Paints the end of a group test.
-         *    @param string $test_name     Name of test or other label.
-         *    @access public
-         */
-        function paintGroupEnd($test_name) {
-            $this->_reporter->paintGroupEnd($test_name);
-        }
-
-        /**
-         *    Paints the start of a test case.
-         *    @param string $test_name     Name of test or other label.
-         *    @access public
-         */
-        function paintCaseStart($test_name) {
-            $this->_reporter->paintCaseStart($test_name);
-        }
-
-        /**
-         *    Paints the end of a test case.
-         *    @param string $test_name     Name of test or other label.
-         *    @access public
-         */
-        function paintCaseEnd($test_name) {
-            $this->_reporter->paintCaseEnd($test_name);
-        }
-
-        /**
-         *    Paints the start of a test method.
-         *    @param string $test_name     Name of test or other label.
-         *    @access public
-         */
-        function paintMethodStart($test_name) {
-            $this->_reporter->paintMethodStart($test_name);
-        }
-
-        /**
-         *    Paints the end of a test method.
-         *    @param string $test_name     Name of test or other label.
-         *    @access public
-         */
-        function paintMethodEnd($test_name) {
-            $this->_reporter->paintMethodEnd($test_name);
-        }
-
-        /**
-         *    Chains to the wrapped reporter.
-         *    @param string $message        Message is ignored.
-         *    @access public
-         */
-        function paintPass($message) {
-            $this->_reporter->paintPass($message);
-        }
-
-        /**
-         *    Chains to the wrapped reporter.
-         *    @param string $message        Message is ignored.
-         *    @access public
-         */
-        function paintFail($message) {
-            $this->_reporter->paintFail($message);
-        }
-
-        /**
-         *    Chains to the wrapped reporter.
-         *    @param string $message    Text of error formatted by
-         *                              the test case.
-         *    @access public
-         */
-        function paintError($message) {
-            $this->_reporter->paintError($message);
-        }
-
-        /**
-         *    Chains to the wrapped reporter.
-         *    @param string $message        Text to display.
-         *    @access public
-         */
-        function paintMessage($message) {
-            $this->_reporter->paintMessage($message);
-        }
-
-        /**
-         *    Chains to the wrapped reporter.
-         *    @param string $message        Text to display.
-         *    @access public
-         */
-        function paintFormattedMessage($message) {
-            $this->_reporter->paintFormattedMessage($message);
-        }
-
-        /**
-         *    Chains to the wrapped reporter.
-         *    @param string $type        Event type as text.
-         *    @param mixed $payload      Message or object.
-         *    @return boolean            Should return false if this
-         *                               type of signal should fail the
-         *                               test suite.
-         *    @access public
-         */
-        function paintSignal($type, $payload) {
-            $this->_reporter->paintSignal($type, $payload);
-        }
-    }
-
-    /**
-     *    For sending messages to multiple reporters at
-     *    the same time.
+	 */
+	class SimpleReporterDecorator {
+		protected $_reporter;
+
+		/**
+		 *    Mediates between teh reporter and the test case.
+		 *    @param SimpleScorer $reporter       Reporter to receive events.
+		 */
+		function SimpleReporterDecorator($reporter) {
+			$this->_reporter = $reporter;
+		}
+
+		/**
+		 *    Signals that the next evaluation will be a dry
+		 *    run. That is, the structure events will be
+		 *    recorded, but no tests will be run.
+		 *    @param boolean $is_dry        Dry run if true.
+		 *    @access public
+		 */
+		function makeDry($is_dry = true) {
+			$this->_reporter->makeDry($is_dry);
+		}
+
+		/**
+		 *    Accessor for current status. Will be false
+		 *    if there have been any failures or exceptions.
+		 *    Used for command line tools.
+		 *    @return boolean        True if no failures.
+		 *    @access public
+		 */
+		function getStatus() {
+			return $this->_reporter->getStatus();
+		}
+
+		/**
+		 *    The reporter has a veto on what should be run.
+		 *    @param string $test_case_name  name of test case.
+		 *    @param string $method          Name of test method.
+		 *    @return boolean                True if test should be run.
+		 *    @access public
+		 */
+		function shouldInvoke($test_case_name, $method) {
+			return $this->_reporter->shouldInvoke($test_case_name, $method);
+		}
+
+		/**
+		 *    Can wrap the invoker in preperation for running
+		 *    a test.
+		 *    @param SimpleInvoker $invoker   Individual test runner.
+		 *    @return SimpleInvoker           Wrapped test runner.
+		 *    @access public
+		 */
+		function &createInvoker($invoker) {
+			return $this->_reporter->createInvoker($invoker);
+		}
+
+		/**
+		 *    Paints the start of a group test.
+		 *    @param string $test_name     Name of test or other label.
+		 *    @param integer $size         Number of test cases starting.
+		 *    @access public
+		 */
+		function paintGroupStart($test_name, $size) {
+			$this->_reporter->paintGroupStart($test_name, $size);
+		}
+
+		/**
+		 *    Paints the end of a group test.
+		 *    @param string $test_name     Name of test or other label.
+		 *    @access public
+		 */
+		function paintGroupEnd($test_name) {
+			$this->_reporter->paintGroupEnd($test_name);
+		}
+
+		/**
+		 *    Paints the start of a test case.
+		 *    @param string $test_name     Name of test or other label.
+		 *    @access public
+		 */
+		function paintCaseStart($test_name) {
+			$this->_reporter->paintCaseStart($test_name);
+		}
+
+		/**
+		 *    Paints the end of a test case.
+		 *    @param string $test_name     Name of test or other label.
+		 *    @access public
+		 */
+		function paintCaseEnd($test_name) {
+			$this->_reporter->paintCaseEnd($test_name);
+		}
+
+		/**
+		 *    Paints the start of a test method.
+		 *    @param string $test_name     Name of test or other label.
+		 *    @access public
+		 */
+		function paintMethodStart($test_name) {
+			$this->_reporter->paintMethodStart($test_name);
+		}
+
+		/**
+		 *    Paints the end of a test method.
+		 *    @param string $test_name     Name of test or other label.
+		 *    @access public
+		 */
+		function paintMethodEnd($test_name) {
+			$this->_reporter->paintMethodEnd($test_name);
+		}
+
+		/**
+		 *    Chains to the wrapped reporter.
+		 *    @param string $message        Message is ignored.
+		 *    @access public
+		 */
+		function paintPass($message) {
+			$this->_reporter->paintPass($message);
+		}
+
+		/**
+		 *    Chains to the wrapped reporter.
+		 *    @param string $message        Message is ignored.
+		 *    @access public
+		 */
+		function paintFail($message) {
+			$this->_reporter->paintFail($message);
+		}
+
+		/**
+		 *    Chains to the wrapped reporter.
+		 *    @param string $message    Text of error formatted by
+		 *                              the test case.
+		 *    @access public
+		 */
+		function paintError($message) {
+			$this->_reporter->paintError($message);
+		}
+
+		/**
+		 *    Chains to the wrapped reporter.
+		 *    @param string $message        Text to display.
+		 *    @access public
+		 */
+		function paintMessage($message) {
+			$this->_reporter->paintMessage($message);
+		}
+
+		/**
+		 *    Chains to the wrapped reporter.
+		 *    @param string $message        Text to display.
+		 *    @access public
+		 */
+		function paintFormattedMessage($message) {
+			$this->_reporter->paintFormattedMessage($message);
+		}
+
+		/**
+		 *    Chains to the wrapped reporter.
+		 *    @param string $type        Event type as text.
+		 *    @param mixed $payload      Message or object.
+		 *    @return boolean            Should return false if this
+		 *                               type of signal should fail the
+		 *                               test suite.
+		 *    @access public
+		 */
+		function paintSignal($type, $payload) {
+			$this->_reporter->paintSignal($type, $payload);
+		}
+	}
+
+	/**
+	 *    For sending messages to multiple reporters at
+	 *    the same time.
 	 *	  @package SimpleTest
 	 *	  @subpackage UnitTester
-     */
-    class MultipleReporter {
-        protected $_reporters = array();
-
-        /**
-         *    Adds a reporter to the subscriber list.
-         *    @param SimpleScorer $reporter     Reporter to receive events.
-         *    @access public
-         */
-        function attachReporter($reporter) {
-            $this->_reporters[] = $reporter;
-        }
-
-        /**
-         *    Signals that the next evaluation will be a dry
-         *    run. That is, the structure events will be
-         *    recorded, but no tests will be run.
-         *    @param boolean $is_dry        Dry run if true.
-         *    @access public
-         */
-        function makeDry($is_dry = true) {
-            for ($i = 0; $i < count($this->_reporters); $i++) {
-                $this->_reporters[$i]->makeDry($is_dry);
-            }
-        }
-
-        /**
-         *    Accessor for current status. Will be false
-         *    if there have been any failures or exceptions.
-         *    If any reporter reports a failure, the whole
-         *    suite fails.
-         *    @return boolean        True if no failures.
-         *    @access public
-         */
-        function getStatus() {
-            for ($i = 0; $i < count($this->_reporters); $i++) {
-                if (! $this->_reporters[$i]->getStatus()) {
-                    return false;
-                }
-            }
-            return true;
-        }
-
-        /**
-         *    The reporter has a veto on what should be run.
-         *    It requires all reporters to want to run the method.
-         *    @param string $test_case_name  name of test case.
-         *    @param string $method          Name of test method.
-         *    @access public
-         */
-        function shouldInvoke($test_case_name, $method) {
-            for ($i = 0; $i < count($this->_reporters); $i++) {
-                if (! $this->_reporters[$i]->shouldInvoke($test_case_name, $method)) {
-                    return false;
-                }
-            }
-            return true;
-        }
-
-        /**
-         *    Every reporter gets a chance to wrap the invoker.
-         *    @param SimpleInvoker $invoker   Individual test runner.
-         *    @return SimpleInvoker           Wrapped test runner.
-         *    @access public
-         */
-        function &createInvoker($invoker) {
-            for ($i = 0; $i < count($this->_reporters); $i++) {
-                $invoker = $this->_reporters[$i]->createInvoker($invoker);
-            }
-            return $invoker;
-        }
-
-        /**
-         *    Paints the start of a group test.
-         *    @param string $test_name     Name of test or other label.
-         *    @param integer $size         Number of test cases starting.
-         *    @access public
-         */
-        function paintGroupStart($test_name, $size) {
-            for ($i = 0; $i < count($this->_reporters); $i++) {
-                $this->_reporters[$i]->paintGroupStart($test_name, $size);
-            }
-        }
-
-        /**
-         *    Paints the end of a group test.
-         *    @param string $test_name     Name of test or other label.
-         *    @access public
-         */
-        function paintGroupEnd($test_name) {
-            for ($i = 0; $i < count($this->_reporters); $i++) {
-                $this->_reporters[$i]->paintGroupEnd($test_name);
-            }
-        }
-
-        /**
-         *    Paints the start of a test case.
-         *    @param string $test_name     Name of test or other label.
-         *    @access public
-         */
-        function paintCaseStart($test_name) {
-            for ($i = 0; $i < count($this->_reporters); $i++) {
-                $this->_reporters[$i]->paintCaseStart($test_name);
-            }
-        }
-
-        /**
-         *    Paints the end of a test case.
-         *    @param string $test_name     Name of test or other label.
-         *    @access public
-         */
-        function paintCaseEnd($test_name) {
-            for ($i = 0; $i < count($this->_reporters); $i++) {
-                $this->_reporters[$i]->paintCaseEnd($test_name);
-            }
-        }
-
-        /**
-         *    Paints the start of a test method.
-         *    @param string $test_name     Name of test or other label.
-         *    @access public
-         */
-        function paintMethodStart($test_name) {
-            for ($i = 0; $i < count($this->_reporters); $i++) {
-                $this->_reporters[$i]->paintMethodStart($test_name);
-            }
-        }
-
-        /**
-         *    Paints the end of a test method.
-         *    @param string $test_name     Name of test or other label.
-         *    @access public
-         */
-        function paintMethodEnd($test_name) {
-            for ($i = 0; $i < count($this->_reporters); $i++) {
-                $this->_reporters[$i]->paintMethodEnd($test_name);
-            }
-        }
-
-        /**
-         *    Chains to the wrapped reporter.
-         *    @param string $message        Message is ignored.
-         *    @access public
-         */
-        function paintPass($message) {
-            for ($i = 0; $i < count($this->_reporters); $i++) {
-                $this->_reporters[$i]->paintPass($message);
-            }
-        }
-
-        /**
-         *    Chains to the wrapped reporter.
-         *    @param string $message        Message is ignored.
-         *    @access public
-         */
-        function paintFail($message) {
-            for ($i = 0; $i < count($this->_reporters); $i++) {
-                $this->_reporters[$i]->paintFail($message);
-            }
-        }
-
-        /**
-         *    Chains to the wrapped reporter.
-         *    @param string $message    Text of error formatted by
-         *                              the test case.
-         *    @access public
-         */
-        function paintError($message) {
-            for ($i = 0; $i < count($this->_reporters); $i++) {
-                $this->_reporters[$i]->paintError($message);
-            }
-        }
-
-        /**
-         *    Chains to the wrapped reporter.
-         *    @param string $message        Text to display.
-         *    @access public
-         */
-        function paintMessage($message) {
-            for ($i = 0; $i < count($this->_reporters); $i++) {
-                $this->_reporters[$i]->paintMessage($message);
-            }
-        }
-
-        /**
-         *    Chains to the wrapped reporter.
-         *    @param string $message        Text to display.
-         *    @access public
-         */
-        function paintFormattedMessage($message) {
-            for ($i = 0; $i < count($this->_reporters); $i++) {
-                $this->_reporters[$i]->paintFormattedMessage($message);
-            }
-        }
-
-        /**
-         *    Chains to the wrapped reporter.
-         *    @param string $type        Event type as text.
-         *    @param mixed $payload      Message or object.
-         *    @return boolean            Should return false if this
-         *                               type of signal should fail the
-         *                               test suite.
-         *    @access public
-         */
-        function paintSignal($type, $payload) {
-            for ($i = 0; $i < count($this->_reporters); $i++) {
-                $this->_reporters[$i]->paintSignal($type, $payload);
-            }
-        }
-    }
\ No newline at end of file
+	 */
+	class MultipleReporter {
+		protected $_reporters = array();
+
+		/**
+		 *    Adds a reporter to the subscriber list.
+		 *    @param SimpleScorer $reporter     Reporter to receive events.
+		 *    @access public
+		 */
+		function attachReporter($reporter) {
+			$this->_reporters[] = $reporter;
+		}
+
+		/**
+		 *    Signals that the next evaluation will be a dry
+		 *    run. That is, the structure events will be
+		 *    recorded, but no tests will be run.
+		 *    @param boolean $is_dry        Dry run if true.
+		 *    @access public
+		 */
+		function makeDry($is_dry = true) {
+			for ($i = 0; $i < count($this->_reporters); $i++) {
+				$this->_reporters[$i]->makeDry($is_dry);
+			}
+		}
+
+		/**
+		 *    Accessor for current status. Will be false
+		 *    if there have been any failures or exceptions.
+		 *    If any reporter reports a failure, the whole
+		 *    suite fails.
+		 *    @return boolean        True if no failures.
+		 *    @access public
+		 */
+		function getStatus() {
+			for ($i = 0; $i < count($this->_reporters); $i++) {
+				if (! $this->_reporters[$i]->getStatus()) {
+					return false;
+				}
+			}
+			return true;
+		}
+
+		/**
+		 *    The reporter has a veto on what should be run.
+		 *    It requires all reporters to want to run the method.
+		 *    @param string $test_case_name  name of test case.
+		 *    @param string $method          Name of test method.
+		 *    @access public
+		 */
+		function shouldInvoke($test_case_name, $method) {
+			for ($i = 0; $i < count($this->_reporters); $i++) {
+				if (! $this->_reporters[$i]->shouldInvoke($test_case_name, $method)) {
+					return false;
+				}
+			}
+			return true;
+		}
+
+		/**
+		 *    Every reporter gets a chance to wrap the invoker.
+		 *    @param SimpleInvoker $invoker   Individual test runner.
+		 *    @return SimpleInvoker           Wrapped test runner.
+		 *    @access public
+		 */
+		function &createInvoker($invoker) {
+			for ($i = 0; $i < count($this->_reporters); $i++) {
+				$invoker = $this->_reporters[$i]->createInvoker($invoker);
+			}
+			return $invoker;
+		}
+
+		/**
+		 *    Paints the start of a group test.
+		 *    @param string $test_name     Name of test or other label.
+		 *    @param integer $size         Number of test cases starting.
+		 *    @access public
+		 */
+		function paintGroupStart($test_name, $size) {
+			for ($i = 0; $i < count($this->_reporters); $i++) {
+				$this->_reporters[$i]->paintGroupStart($test_name, $size);
+			}
+		}
+
+		/**
+		 *    Paints the end of a group test.
+		 *    @param string $test_name     Name of test or other label.
+		 *    @access public
+		 */
+		function paintGroupEnd($test_name) {
+			for ($i = 0; $i < count($this->_reporters); $i++) {
+				$this->_reporters[$i]->paintGroupEnd($test_name);
+			}
+		}
+
+		/**
+		 *    Paints the start of a test case.
+		 *    @param string $test_name     Name of test or other label.
+		 *    @access public
+		 */
+		function paintCaseStart($test_name) {
+			for ($i = 0; $i < count($this->_reporters); $i++) {
+				$this->_reporters[$i]->paintCaseStart($test_name);
+			}
+		}
+
+		/**
+		 *    Paints the end of a test case.
+		 *    @param string $test_name     Name of test or other label.
+		 *    @access public
+		 */
+		function paintCaseEnd($test_name) {
+			for ($i = 0; $i < count($this->_reporters); $i++) {
+				$this->_reporters[$i]->paintCaseEnd($test_name);
+			}
+		}
+
+		/**
+		 *    Paints the start of a test method.
+		 *    @param string $test_name     Name of test or other label.
+		 *    @access public
+		 */
+		function paintMethodStart($test_name) {
+			for ($i = 0; $i < count($this->_reporters); $i++) {
+				$this->_reporters[$i]->paintMethodStart($test_name);
+			}
+		}
+
+		/**
+		 *    Paints the end of a test method.
+		 *    @param string $test_name     Name of test or other label.
+		 *    @access public
+		 */
+		function paintMethodEnd($test_name) {
+			for ($i = 0; $i < count($this->_reporters); $i++) {
+				$this->_reporters[$i]->paintMethodEnd($test_name);
+			}
+		}
+
+		/**
+		 *    Chains to the wrapped reporter.
+		 *    @param string $message        Message is ignored.
+		 *    @access public
+		 */
+		function paintPass($message) {
+			for ($i = 0; $i < count($this->_reporters); $i++) {
+				$this->_reporters[$i]->paintPass($message);
+			}
+		}
+
+		/**
+		 *    Chains to the wrapped reporter.
+		 *    @param string $message        Message is ignored.
+		 *    @access public
+		 */
+		function paintFail($message) {
+			for ($i = 0; $i < count($this->_reporters); $i++) {
+				$this->_reporters[$i]->paintFail($message);
+			}
+		}
+
+		/**
+		 *    Chains to the wrapped reporter.
+		 *    @param string $message    Text of error formatted by
+		 *                              the test case.
+		 *    @access public
+		 */
+		function paintError($message) {
+			for ($i = 0; $i < count($this->_reporters); $i++) {
+				$this->_reporters[$i]->paintError($message);
+			}
+		}
+
+		/**
+		 *    Chains to the wrapped reporter.
+		 *    @param string $message        Text to display.
+		 *    @access public
+		 */
+		function paintMessage($message) {
+			for ($i = 0; $i < count($this->_reporters); $i++) {
+				$this->_reporters[$i]->paintMessage($message);
+			}
+		}
+
+		/**
+		 *    Chains to the wrapped reporter.
+		 *    @param string $message        Text to display.
+		 *    @access public
+		 */
+		function paintFormattedMessage($message) {
+			for ($i = 0; $i < count($this->_reporters); $i++) {
+				$this->_reporters[$i]->paintFormattedMessage($message);
+			}
+		}
+
+		/**
+		 *    Chains to the wrapped reporter.
+		 *    @param string $type        Event type as text.
+		 *    @param mixed $payload      Message or object.
+		 *    @return boolean            Should return false if this
+		 *                               type of signal should fail the
+		 *                               test suite.
+		 *    @access public
+		 */
+		function paintSignal($type, $payload) {
+			for ($i = 0; $i < count($this->_reporters); $i++) {
+				$this->_reporters[$i]->paintSignal($type, $payload);
+			}
+		}
+	}
\ No newline at end of file

tests/test_tools/simpletest/expectation.php

Indentation +716 added lines, -716 removed lines

@@ -1,719 +1,719 @@
 <?php
-    /**
-     *    base include file for SimpleTest
-     *    @package    SimpleTest
-     *    @subpackage    UnitTester
-     *    @version    $Id: expectation.php 1532 2006-12-01 12:28:55Z xue $
-     */
-
-    /**#@+
+	/**
+	 *    base include file for SimpleTest
+	 *    @package    SimpleTest
+	 *    @subpackage    UnitTester
+	 *    @version    $Id: expectation.php 1532 2006-12-01 12:28:55Z xue $
+	 */
+
+	/**#@+
      *    include other SimpleTest class files
      */
-    require_once(dirname(__FILE__) . '/dumper.php');
-    require_once(dirname(__FILE__) . '/compatibility.php');
-    /**#@-*/
-
-    /**
-     *    Assertion that can display failure information.
-     *    Also includes various helper methods.
-     *    @package SimpleTest
-     *    @subpackage UnitTester
-     *    @abstract
-     */
-    class SimpleExpectation {
-        protected $_dumper;
-        protected $_message;
-
-        /**
-         *    Creates a dumper for displaying values and sets
-         *    the test message.
-         *    @param string $message    Customised message on failure.
-         */
-        function SimpleExpectation($message = '%s') {
-            $this->_dumper = new SimpleDumper();
-            $this->_message = $message;
-        }
-
-        /**
-         *    Tests the expectation. True if correct.
-         *    @param mixed $compare        Comparison value.
-         *    @return boolean              True if correct.
-         *    @access public
-         *    @abstract
-         */
-        function test($compare) {
-        }
-
-        /**
-         *    Returns a human readable test message.
-         *    @param mixed $compare      Comparison value.
-         *    @return string             Description of success
-         *                               or failure.
-         *    @access public
-         *    @abstract
-         */
-        function testMessage($compare) {
-        }
-
-        /**
-         *    Overlays the generated message onto the stored user
-         *    message. An additional message can be interjected.
-         *    @param mixed $compare      Comparison value.
-         *    @return string             Description of success
-         *                               or failure.
-         *    @access public
-         */
-        function overlayMessage($compare) {
-            return sprintf($this->_message, $this->testMessage($compare));
-        }
-
-        /**
-         *    Accessor for the dumper.
-         *    @return SimpleDumper    Current value dumper.
-         *    @access protected
-         */
-        function &_getDumper() {
-            return $this->_dumper;
-        }
-
-        /**
-         *    Test to see if a value is an expectation object.
-         *    A useful utility method.
-         *    @param mixed $expectation    Hopefully an Epectation
-         *                                 class.
-         *    @return boolean              True if descended from
-         *                                 this class.
-         *    @access public
-         *    @static
-         */
-        static function isExpectation($expectation) {
-            return is_object($expectation) &&
-                    SimpleTestCompatibility::isA($expectation, 'SimpleExpectation');
-        }
-    }
-
-    /**
-     *    Test for equality.
-     *      @package SimpleTest
-     *      @subpackage UnitTester
-     */
-    class EqualExpectation extends SimpleExpectation {
-        protected $_value;
-
-        /**
-         *    Sets the value to compare against.
-         *    @param mixed $value        Test value to match.
-         *    @param string $message     Customised message on failure.
-         *    @access public
-         */
-        function EqualExpectation($value, $message = '%s') {
-            $this->SimpleExpectation($message);
-            $this->_value = $value;
-        }
-
-        /**
-         *    Tests the expectation. True if it matches the
-         *    held value.
-         *    @param mixed $compare        Comparison value.
-         *    @return boolean              True if correct.
-         *    @access public
-         */
-        function test($compare) {
-            return (($this->_value == $compare) && ($compare == $this->_value));
-        }
-
-        /**
-         *    Returns a human readable test message.
-         *    @param mixed $compare      Comparison value.
-         *    @return string             Description of success
-         *                               or failure.
-         *    @access public
-         */
-        function testMessage($compare) {
-            if ($this->test($compare)) {
-                return "Equal expectation [" . $this->_dumper->describeValue($this->_value) . "]";
-            } else {
-                return "Equal expectation fails " .
-                        $this->_dumper->describeDifference($this->_value, $compare);
-            }
-        }
-
-        /**
-         *    Accessor for comparison value.
-         *    @return mixed       Held value to compare with.
-         *    @access protected
-         */
-        function _getValue() {
-            return $this->_value;
-        }
-    }
-
-    /**
-     *    Test for inequality.
-     *      @package SimpleTest
-     *      @subpackage UnitTester
-     */
-    class NotEqualExpectation extends EqualExpectation {
-
-        /**
-         *    Sets the value to compare against.
-         *    @param mixed $value       Test value to match.
-         *    @param string $message    Customised message on failure.
-         *    @access public
-         */
-        function NotEqualExpectation($value, $message = '%s') {
-            $this->EqualExpectation($value, $message);
-        }
-
-        /**
-         *    Tests the expectation. True if it differs from the
-         *    held value.
-         *    @param mixed $compare        Comparison value.
-         *    @return boolean              True if correct.
-         *    @access public
-         */
-        function test($compare) {
-            return ! parent::test($compare);
-        }
-
-        /**
-         *    Returns a human readable test message.
-         *    @param mixed $compare      Comparison value.
-         *    @return string             Description of success
-         *                               or failure.
-         *    @access public
-         */
-        function testMessage($compare) {
-            $dumper = $this->_getDumper();
-            if ($this->test($compare)) {
-                return "Not equal expectation passes " .
-                        $dumper->describeDifference($this->_getValue(), $compare);
-            } else {
-                return "Not equal expectation fails [" .
-                        $dumper->describeValue($this->_getValue()) .
-                        "] matches";
-            }
-        }
-    }
-
-    /**
-     *    Test for being within a range.
-     *      @package SimpleTest
-     *      @subpackage UnitTester
-     */
-    class WithinMarginExpectation extends SimpleExpectation {
-        protected $_upper;
-        protected $_lower;
-
-        /**
-         *    Sets the value to compare against and the fuzziness of
-         *    the match. Used for comparing floating point values.
-         *    @param mixed $value        Test value to match.
-         *    @param mixed $margin       Fuzziness of match.
-         *    @param string $message     Customised message on failure.
-         *    @access public
-         */
-        function WithinMarginExpectation($value, $margin, $message = '%s') {
-            $this->SimpleExpectation($message);
-            $this->_upper = $value + $margin;
-            $this->_lower = $value - $margin;
-        }
-
-        /**
-         *    Tests the expectation. True if it matches the
-         *    held value.
-         *    @param mixed $compare        Comparison value.
-         *    @return boolean              True if correct.
-         *    @access public
-         */
-        function test($compare) {
-            return (($compare <= $this->_upper) && ($compare >= $this->_lower));
-        }
-
-        /**
-         *    Returns a human readable test message.
-         *    @param mixed $compare      Comparison value.
-         *    @return string             Description of success
-         *                               or failure.
-         *    @access public
-         */
-        function testMessage($compare) {
-            if ($this->test($compare)) {
-                return $this->_withinMessage($compare);
-            } else {
-                return $this->_outsideMessage($compare);
-            }
-        }
-
-        /**
-         *    Creates a the message for being within the range.
-         *    @param mixed $compare        Value being tested.
-         *    @access private
-         */
-        function _withinMessage($compare) {
-            return "Within expectation [" . $this->_dumper->describeValue($this->_lower) . "] and [" .
-                    $this->_dumper->describeValue($this->_upper) . "]";
-        }
-
-        /**
-         *    Creates a the message for being within the range.
-         *    @param mixed $compare        Value being tested.
-         *    @access private
-         */
-        function _outsideMessage($compare) {
-            if ($compare > $this->_upper) {
-                return "Outside expectation " .
-                        $this->_dumper->describeDifference($compare, $this->_upper);
-            } else {
-                return "Outside expectation " .
-                        $this->_dumper->describeDifference($compare, $this->_lower);
-            }
-        }
-    }
-
-    /**
-     *    Test for being outside of a range.
-     *      @package SimpleTest
-     *      @subpackage UnitTester
-     */
-    class OutsideMarginExpectation extends WithinMarginExpectation {
-
-        /**
-         *    Sets the value to compare against and the fuzziness of
-         *    the match. Used for comparing floating point values.
-         *    @param mixed $value        Test value to not match.
-         *    @param mixed $margin       Fuzziness of match.
-         *    @param string $message     Customised message on failure.
-         *    @access public
-         */
-        function OutsideMarginExpectation($value, $margin, $message = '%s') {
-            $this->WithinMarginExpectation($value, $margin, $message);
-        }
-
-        /**
-         *    Tests the expectation. True if it matches the
-         *    held value.
-         *    @param mixed $compare        Comparison value.
-         *    @return boolean              True if correct.
-         *    @access public
-         */
-        function test($compare) {
-            return ! parent::test($compare);
-        }
-
-        /**
-         *    Returns a human readable test message.
-         *    @param mixed $compare      Comparison value.
-         *    @return string             Description of success
-         *                               or failure.
-         *    @access public
-         */
-        function testMessage($compare) {
-            if (! $this->test($compare)) {
-                return $this->_withinMessage($compare);
-            } else {
-                return $this->_outsideMessage($compare);
-            }
-        }
-    }
-
-    /**
-     *    Test for identity.
-     *    @package SimpleTest
-     *    @subpackage UnitTester
-     */
-    class IdenticalExpectation extends EqualExpectation {
-
-        /**
-         *    Sets the value to compare against.
-         *    @param mixed $value       Test value to match.
-         *    @param string $message    Customised message on failure.
-         *    @access public
-         */
-        function IdenticalExpectation($value, $message = '%s') {
-            $this->EqualExpectation($value, $message);
-        }
-
-        /**
-         *    Tests the expectation. True if it exactly
-         *    matches the held value.
-         *    @param mixed $compare        Comparison value.
-         *    @return boolean              True if correct.
-         *    @access public
-         */
-        function test($compare) {
-            return SimpleTestCompatibility::isIdentical($this->_getValue(), $compare);
-        }
-
-        /**
-         *    Returns a human readable test message.
-         *    @param mixed $compare      Comparison value.
-         *    @return string             Description of success
-         *                               or failure.
-         *    @access public
-         */
-        function testMessage($compare) {
-            $dumper = $this->_getDumper();
-            if ($this->test($compare)) {
-                return "Identical expectation [" . $dumper->describeValue($this->_getValue()) . "]";
-            } else {
-                return "Identical expectation [" . $dumper->describeValue($this->_getValue()) .
-                        "] fails with [" .
-                        $dumper->describeValue($compare) . "] " .
-                        $dumper->describeDifference($this->_getValue(), $compare, TYPE_MATTERS);
-            }
-        }
-    }
-
-    /**
-     *    Test for non-identity.
-     *    @package SimpleTest
-     *    @subpackage UnitTester
-     */
-    class NotIdenticalExpectation extends IdenticalExpectation {
-
-        /**
-         *    Sets the value to compare against.
-         *    @param mixed $value        Test value to match.
-         *    @param string $message     Customised message on failure.
-         *    @access public
-         */
-        function NotIdenticalExpectation($value, $message = '%s') {
-            $this->IdenticalExpectation($value, $message);
-        }
-
-        /**
-         *    Tests the expectation. True if it differs from the
-         *    held value.
-         *    @param mixed $compare        Comparison value.
-         *    @return boolean              True if correct.
-         *    @access public
-         */
-        function test($compare) {
-            return ! parent::test($compare);
-        }
-
-        /**
-         *    Returns a human readable test message.
-         *    @param mixed $compare      Comparison value.
-         *    @return string             Description of success
-         *                               or failure.
-         *    @access public
-         */
-        function testMessage($compare) {
-            $dumper = $this->_getDumper();
-            if ($this->test($compare)) {
-                return "Not identical expectation passes " .
-                        $dumper->describeDifference($this->_getValue(), $compare, TYPE_MATTERS);
-            } else {
-                return "Not identical expectation [" . $dumper->describeValue($this->_getValue()) . "] matches";
-            }
-        }
-    }
-
-    /**
-     *    Test for a pattern using Perl regex rules.
-     *    @package SimpleTest
-     *    @subpackage UnitTester
-     */
-    class PatternExpectation extends SimpleExpectation {
-        protected $_pattern;
-
-        /**
-         *    Sets the value to compare against.
-         *    @param string $pattern    Pattern to search for.
-         *    @param string $message    Customised message on failure.
-         *    @access public
-         */
-        function PatternExpectation($pattern, $message = '%s') {
-            $this->SimpleExpectation($message);
-            $this->_pattern = $pattern;
-        }
-
-        /**
-         *    Accessor for the pattern.
-         *    @return string       Perl regex as string.
-         *    @access protected
-         */
-        function _getPattern() {
-            return $this->_pattern;
-        }
-
-        /**
-         *    Tests the expectation. True if the Perl regex
-         *    matches the comparison value.
-         *    @param string $compare        Comparison value.
-         *    @return boolean               True if correct.
-         *    @access public
-         */
-        function test($compare) {
-            return (boolean)preg_match($this->_getPattern(), $compare);
-        }
-
-        /**
-         *    Returns a human readable test message.
-         *    @param mixed $compare      Comparison value.
-         *    @return string             Description of success
-         *                               or failure.
-         *    @access public
-         */
-        function testMessage($compare) {
-            if ($this->test($compare)) {
-                return $this->_describePatternMatch($this->_getPattern(), $compare);
-            } else {
-                $dumper = $this->_getDumper();
-                return "Pattern [" . $this->_getPattern() .
-                        "] not detected in [" .
-                        $dumper->describeValue($compare) . "]";
-            }
-        }
-
-        /**
-         *    Describes a pattern match including the string
-         *    found and it's position.
-     *    @package SimpleTest
-     *    @subpackage UnitTester
-         *    @param string $pattern        Regex to match against.
-         *    @param string $subject        Subject to search.
-         *    @access protected
-         */
-        function _describePatternMatch($pattern, $subject) {
-            preg_match($pattern, $subject, $matches);
-            $position = strpos($subject, $matches[0]);
-            $dumper = $this->_getDumper();
-            return "Pattern [$pattern] detected at character [$position] in [" .
-                    $dumper->describeValue($subject) . "] as [" .
-                    $matches[0] . "] in region [" .
-                    $dumper->clipString($subject, 100, $position) . "]";
-        }
-    }
-
-    /**
-     *      @deprecated
-     */
-    class WantedPatternExpectation extends PatternExpectation {
-    }
-
-    /**
-     *    Fail if a pattern is detected within the
-     *    comparison.
-     *      @package SimpleTest
-     *      @subpackage UnitTester
-     */
-    class NoPatternExpectation extends PatternExpectation {
-
-        /**
-         *    Sets the reject pattern
-         *    @param string $pattern    Pattern to search for.
-         *    @param string $message    Customised message on failure.
-         *    @access public
-         */
-        function NoPatternExpectation($pattern, $message = '%s') {
-            $this->PatternExpectation($pattern, $message);
-        }
-
-        /**
-         *    Tests the expectation. False if the Perl regex
-         *    matches the comparison value.
-         *    @param string $compare        Comparison value.
-         *    @return boolean               True if correct.
-         *    @access public
-         */
-        function test($compare) {
-            return ! parent::test($compare);
-        }
-
-        /**
-         *    Returns a human readable test message.
-         *    @param string $compare      Comparison value.
-         *    @return string              Description of success
-         *                                or failure.
-         *    @access public
-         */
-        function testMessage($compare) {
-            if ($this->test($compare)) {
-                $dumper = $this->_getDumper();
-                return "Pattern [" . $this->_getPattern() .
-                        "] not detected in [" .
-                        $dumper->describeValue($compare) . "]";
-            } else {
-                return $this->_describePatternMatch($this->_getPattern(), $compare);
-            }
-        }
-    }
-
-    /**
-     *    @package SimpleTest
-     *    @subpackage UnitTester
-     *      @deprecated
-     */
-    class UnwantedPatternExpectation extends NoPatternExpectation {
-    }
-
-    /**
-     *    Tests either type or class name if it's an object.
-     *      @package SimpleTest
-     *      @subpackage UnitTester
-     */
-    class IsAExpectation extends SimpleExpectation {
-        protected $_type;
-
-        /**
-         *    Sets the type to compare with.
-         *    @param string $type       Type or class name.
-         *    @param string $message    Customised message on failure.
-         *    @access public
-         */
-        function IsAExpectation($type, $message = '%s') {
-            $this->SimpleExpectation($message);
-            $this->_type = $type;
-        }
-
-        /**
-         *    Accessor for type to check against.
-         *    @return string    Type or class name.
-         *    @access protected
-         */
-        function _getType() {
-            return $this->_type;
-        }
-
-        /**
-         *    Tests the expectation. True if the type or
-         *    class matches the string value.
-         *    @param string $compare        Comparison value.
-         *    @return boolean               True if correct.
-         *    @access public
-         */
-        function test($compare) {
-            if (is_object($compare)) {
-                return SimpleTestCompatibility::isA($compare, $this->_type);
-            } else {
-                return (strtolower(gettype($compare)) == $this->_canonicalType($this->_type));
-            }
-        }
-
-        /**
-         *    Coerces type name into a gettype() match.
-         *    @param string $type        User type.
-         *    @return string             Simpler type.
-         *    @access private
-         */
-        function _canonicalType($type) {
-            $type = strtolower($type);
-            $map = array(
-                    'bool' => 'boolean',
-                    'float' => 'double',
-                    'real' => 'double',
-                    'int' => 'integer');
-            if (isset($map[$type])) {
-                $type = $map[$type];
-            }
-            return $type;
-        }
-
-        /**
-         *    Returns a human readable test message.
-         *    @param mixed $compare      Comparison value.
-         *    @return string             Description of success
-         *                               or failure.
-         *    @access public
-         */
-        function testMessage($compare) {
-            $dumper = $this->_getDumper();
-            return "Value [" . $dumper->describeValue($compare) .
-                    "] should be type [" . $this->_type . "]";
-        }
-    }
-
-    /**
-     *    Tests either type or class name if it's an object.
-     *    Will succeed if the type does not match.
-     *      @package SimpleTest
-     *      @subpackage UnitTester
-     */
-    class NotAExpectation extends IsAExpectation {
-        protected $_type;
-
-        /**
-         *    Sets the type to compare with.
-         *    @param string $type       Type or class name.
-         *    @param string $message    Customised message on failure.
-         *    @access public
-         */
-        function NotAExpectation($type, $message = '%s') {
-            $this->IsAExpectation($type, $message);
-        }
-
-        /**
-         *    Tests the expectation. False if the type or
-         *    class matches the string value.
-         *    @param string $compare        Comparison value.
-         *    @return boolean               True if different.
-         *    @access public
-         */
-        function test($compare) {
-            return ! parent::test($compare);
-        }
-
-        /**
-         *    Returns a human readable test message.
-         *    @param mixed $compare      Comparison value.
-         *    @return string             Description of success
-         *                               or failure.
-         *    @access public
-         */
-        function testMessage($compare) {
-            $dumper = $this->_getDumper();
-            return "Value [" . $dumper->describeValue($compare) .
-                    "] should not be type [" . $this->_getType() . "]";
-        }
-    }
-
-    /**
-     *    Tests for existance of a method in an object
-     *      @package SimpleTest
-     *      @subpackage UnitTester
-     */
-    class MethodExistsExpectation extends SimpleExpectation {
-        protected $_method;
-
-        /**
-         *    Sets the value to compare against.
-         *    @param string $method     Method to check.
-         *    @param string $message    Customised message on failure.
-         *    @access public
-         *    @return void
-         */
-        function MethodExistsExpectation($method, $message = '%s') {
-            $this->SimpleExpectation($message);
-            $this->_method = $method;
-        }
-
-        /**
-         *    Tests the expectation. True if the method exists in the test object.
-         *    @param string $compare        Comparison method name.
-         *    @return boolean               True if correct.
-         *    @access public
-         */
-        function test($compare) {
-            return (boolean)(is_object($compare) && method_exists($compare, $this->_method));
-        }
-
-        /**
-         *    Returns a human readable test message.
-         *    @param mixed $compare      Comparison value.
-         *    @return string             Description of success
-         *                               or failure.
-         *    @access public
-         */
-        function testMessage($compare) {
-            $dumper = $this->_getDumper();
-            if (! is_object($compare)) {
-                return 'No method on non-object [' . $dumper->describeValue($compare) . ']';
-            }
-            $method = $this->_method;
-            return "Object [" . $dumper->describeValue($compare) .
-                    "] should contain method [$method]";
-        }
-    }
+	require_once(dirname(__FILE__) . '/dumper.php');
+	require_once(dirname(__FILE__) . '/compatibility.php');
+	/**#@-*/
+
+	/**
+	 *    Assertion that can display failure information.
+	 *    Also includes various helper methods.
+	 *    @package SimpleTest
+	 *    @subpackage UnitTester
+	 *    @abstract
+	 */
+	class SimpleExpectation {
+		protected $_dumper;
+		protected $_message;
+
+		/**
+		 *    Creates a dumper for displaying values and sets
+		 *    the test message.
+		 *    @param string $message    Customised message on failure.
+		 */
+		function SimpleExpectation($message = '%s') {
+			$this->_dumper = new SimpleDumper();
+			$this->_message = $message;
+		}
+
+		/**
+		 *    Tests the expectation. True if correct.
+		 *    @param mixed $compare        Comparison value.
+		 *    @return boolean              True if correct.
+		 *    @access public
+		 *    @abstract
+		 */
+		function test($compare) {
+		}
+
+		/**
+		 *    Returns a human readable test message.
+		 *    @param mixed $compare      Comparison value.
+		 *    @return string             Description of success
+		 *                               or failure.
+		 *    @access public
+		 *    @abstract
+		 */
+		function testMessage($compare) {
+		}
+
+		/**
+		 *    Overlays the generated message onto the stored user
+		 *    message. An additional message can be interjected.
+		 *    @param mixed $compare      Comparison value.
+		 *    @return string             Description of success
+		 *                               or failure.
+		 *    @access public
+		 */
+		function overlayMessage($compare) {
+			return sprintf($this->_message, $this->testMessage($compare));
+		}
+
+		/**
+		 *    Accessor for the dumper.
+		 *    @return SimpleDumper    Current value dumper.
+		 *    @access protected
+		 */
+		function &_getDumper() {
+			return $this->_dumper;
+		}
+
+		/**
+		 *    Test to see if a value is an expectation object.
+		 *    A useful utility method.
+		 *    @param mixed $expectation    Hopefully an Epectation
+		 *                                 class.
+		 *    @return boolean              True if descended from
+		 *                                 this class.
+		 *    @access public
+		 *    @static
+		 */
+		static function isExpectation($expectation) {
+			return is_object($expectation) &&
+					SimpleTestCompatibility::isA($expectation, 'SimpleExpectation');
+		}
+	}
+
+	/**
+	 *    Test for equality.
+	 *      @package SimpleTest
+	 *      @subpackage UnitTester
+	 */
+	class EqualExpectation extends SimpleExpectation {
+		protected $_value;
+
+		/**
+		 *    Sets the value to compare against.
+		 *    @param mixed $value        Test value to match.
+		 *    @param string $message     Customised message on failure.
+		 *    @access public
+		 */
+		function EqualExpectation($value, $message = '%s') {
+			$this->SimpleExpectation($message);
+			$this->_value = $value;
+		}
+
+		/**
+		 *    Tests the expectation. True if it matches the
+		 *    held value.
+		 *    @param mixed $compare        Comparison value.
+		 *    @return boolean              True if correct.
+		 *    @access public
+		 */
+		function test($compare) {
+			return (($this->_value == $compare) && ($compare == $this->_value));
+		}
+
+		/**
+		 *    Returns a human readable test message.
+		 *    @param mixed $compare      Comparison value.
+		 *    @return string             Description of success
+		 *                               or failure.
+		 *    @access public
+		 */
+		function testMessage($compare) {
+			if ($this->test($compare)) {
+				return "Equal expectation [" . $this->_dumper->describeValue($this->_value) . "]";
+			} else {
+				return "Equal expectation fails " .
+						$this->_dumper->describeDifference($this->_value, $compare);
+			}
+		}
+
+		/**
+		 *    Accessor for comparison value.
+		 *    @return mixed       Held value to compare with.
+		 *    @access protected
+		 */
+		function _getValue() {
+			return $this->_value;
+		}
+	}
+
+	/**
+	 *    Test for inequality.
+	 *      @package SimpleTest
+	 *      @subpackage UnitTester
+	 */
+	class NotEqualExpectation extends EqualExpectation {
+
+		/**
+		 *    Sets the value to compare against.
+		 *    @param mixed $value       Test value to match.
+		 *    @param string $message    Customised message on failure.
+		 *    @access public
+		 */
+		function NotEqualExpectation($value, $message = '%s') {
+			$this->EqualExpectation($value, $message);
+		}
+
+		/**
+		 *    Tests the expectation. True if it differs from the
+		 *    held value.
+		 *    @param mixed $compare        Comparison value.
+		 *    @return boolean              True if correct.
+		 *    @access public
+		 */
+		function test($compare) {
+			return ! parent::test($compare);
+		}
+
+		/**
+		 *    Returns a human readable test message.
+		 *    @param mixed $compare      Comparison value.
+		 *    @return string             Description of success
+		 *                               or failure.
+		 *    @access public
+		 */
+		function testMessage($compare) {
+			$dumper = $this->_getDumper();
+			if ($this->test($compare)) {
+				return "Not equal expectation passes " .
+						$dumper->describeDifference($this->_getValue(), $compare);
+			} else {
+				return "Not equal expectation fails [" .
+						$dumper->describeValue($this->_getValue()) .
+						"] matches";
+			}
+		}
+	}
+
+	/**
+	 *    Test for being within a range.
+	 *      @package SimpleTest
+	 *      @subpackage UnitTester
+	 */
+	class WithinMarginExpectation extends SimpleExpectation {
+		protected $_upper;
+		protected $_lower;
+
+		/**
+		 *    Sets the value to compare against and the fuzziness of
+		 *    the match. Used for comparing floating point values.
+		 *    @param mixed $value        Test value to match.
+		 *    @param mixed $margin       Fuzziness of match.
+		 *    @param string $message     Customised message on failure.
+		 *    @access public
+		 */
+		function WithinMarginExpectation($value, $margin, $message = '%s') {
+			$this->SimpleExpectation($message);
+			$this->_upper = $value + $margin;
+			$this->_lower = $value - $margin;
+		}
+
+		/**
+		 *    Tests the expectation. True if it matches the
+		 *    held value.
+		 *    @param mixed $compare        Comparison value.
+		 *    @return boolean              True if correct.
+		 *    @access public
+		 */
+		function test($compare) {
+			return (($compare <= $this->_upper) && ($compare >= $this->_lower));
+		}
+
+		/**
+		 *    Returns a human readable test message.
+		 *    @param mixed $compare      Comparison value.
+		 *    @return string             Description of success
+		 *                               or failure.
+		 *    @access public
+		 */
+		function testMessage($compare) {
+			if ($this->test($compare)) {
+				return $this->_withinMessage($compare);
+			} else {
+				return $this->_outsideMessage($compare);
+			}
+		}
+
+		/**
+		 *    Creates a the message for being within the range.
+		 *    @param mixed $compare        Value being tested.
+		 *    @access private
+		 */
+		function _withinMessage($compare) {
+			return "Within expectation [" . $this->_dumper->describeValue($this->_lower) . "] and [" .
+					$this->_dumper->describeValue($this->_upper) . "]";
+		}
+
+		/**
+		 *    Creates a the message for being within the range.
+		 *    @param mixed $compare        Value being tested.
+		 *    @access private
+		 */
+		function _outsideMessage($compare) {
+			if ($compare > $this->_upper) {
+				return "Outside expectation " .
+						$this->_dumper->describeDifference($compare, $this->_upper);
+			} else {
+				return "Outside expectation " .
+						$this->_dumper->describeDifference($compare, $this->_lower);
+			}
+		}
+	}
+
+	/**
+	 *    Test for being outside of a range.
+	 *      @package SimpleTest
+	 *      @subpackage UnitTester
+	 */
+	class OutsideMarginExpectation extends WithinMarginExpectation {
+
+		/**
+		 *    Sets the value to compare against and the fuzziness of
+		 *    the match. Used for comparing floating point values.
+		 *    @param mixed $value        Test value to not match.
+		 *    @param mixed $margin       Fuzziness of match.
+		 *    @param string $message     Customised message on failure.
+		 *    @access public
+		 */
+		function OutsideMarginExpectation($value, $margin, $message = '%s') {
+			$this->WithinMarginExpectation($value, $margin, $message);
+		}
+
+		/**
+		 *    Tests the expectation. True if it matches the
+		 *    held value.
+		 *    @param mixed $compare        Comparison value.
+		 *    @return boolean              True if correct.
+		 *    @access public
+		 */
+		function test($compare) {
+			return ! parent::test($compare);
+		}
+
+		/**
+		 *    Returns a human readable test message.
+		 *    @param mixed $compare      Comparison value.
+		 *    @return string             Description of success
+		 *                               or failure.
+		 *    @access public
+		 */
+		function testMessage($compare) {
+			if (! $this->test($compare)) {
+				return $this->_withinMessage($compare);
+			} else {
+				return $this->_outsideMessage($compare);
+			}
+		}
+	}
+
+	/**
+	 *    Test for identity.
+	 *    @package SimpleTest
+	 *    @subpackage UnitTester
+	 */
+	class IdenticalExpectation extends EqualExpectation {
+
+		/**
+		 *    Sets the value to compare against.
+		 *    @param mixed $value       Test value to match.
+		 *    @param string $message    Customised message on failure.
+		 *    @access public
+		 */
+		function IdenticalExpectation($value, $message = '%s') {
+			$this->EqualExpectation($value, $message);
+		}
+
+		/**
+		 *    Tests the expectation. True if it exactly
+		 *    matches the held value.
+		 *    @param mixed $compare        Comparison value.
+		 *    @return boolean              True if correct.
+		 *    @access public
+		 */
+		function test($compare) {
+			return SimpleTestCompatibility::isIdentical($this->_getValue(), $compare);
+		}
+
+		/**
+		 *    Returns a human readable test message.
+		 *    @param mixed $compare      Comparison value.
+		 *    @return string             Description of success
+		 *                               or failure.
+		 *    @access public
+		 */
+		function testMessage($compare) {
+			$dumper = $this->_getDumper();
+			if ($this->test($compare)) {
+				return "Identical expectation [" . $dumper->describeValue($this->_getValue()) . "]";
+			} else {
+				return "Identical expectation [" . $dumper->describeValue($this->_getValue()) .
+						"] fails with [" .
+						$dumper->describeValue($compare) . "] " .
+						$dumper->describeDifference($this->_getValue(), $compare, TYPE_MATTERS);
+			}
+		}
+	}
+
+	/**
+	 *    Test for non-identity.
+	 *    @package SimpleTest
+	 *    @subpackage UnitTester
+	 */
+	class NotIdenticalExpectation extends IdenticalExpectation {
+
+		/**
+		 *    Sets the value to compare against.
+		 *    @param mixed $value        Test value to match.
+		 *    @param string $message     Customised message on failure.
+		 *    @access public
+		 */
+		function NotIdenticalExpectation($value, $message = '%s') {
+			$this->IdenticalExpectation($value, $message);
+		}
+
+		/**
+		 *    Tests the expectation. True if it differs from the
+		 *    held value.
+		 *    @param mixed $compare        Comparison value.
+		 *    @return boolean              True if correct.
+		 *    @access public
+		 */
+		function test($compare) {
+			return ! parent::test($compare);
+		}
+
+		/**
+		 *    Returns a human readable test message.
+		 *    @param mixed $compare      Comparison value.
+		 *    @return string             Description of success
+		 *                               or failure.
+		 *    @access public
+		 */
+		function testMessage($compare) {
+			$dumper = $this->_getDumper();
+			if ($this->test($compare)) {
+				return "Not identical expectation passes " .
+						$dumper->describeDifference($this->_getValue(), $compare, TYPE_MATTERS);
+			} else {
+				return "Not identical expectation [" . $dumper->describeValue($this->_getValue()) . "] matches";
+			}
+		}
+	}
+
+	/**
+	 *    Test for a pattern using Perl regex rules.
+	 *    @package SimpleTest
+	 *    @subpackage UnitTester
+	 */
+	class PatternExpectation extends SimpleExpectation {
+		protected $_pattern;
+
+		/**
+		 *    Sets the value to compare against.
+		 *    @param string $pattern    Pattern to search for.
+		 *    @param string $message    Customised message on failure.
+		 *    @access public
+		 */
+		function PatternExpectation($pattern, $message = '%s') {
+			$this->SimpleExpectation($message);
+			$this->_pattern = $pattern;
+		}
+
+		/**
+		 *    Accessor for the pattern.
+		 *    @return string       Perl regex as string.
+		 *    @access protected
+		 */
+		function _getPattern() {
+			return $this->_pattern;
+		}
+
+		/**
+		 *    Tests the expectation. True if the Perl regex
+		 *    matches the comparison value.
+		 *    @param string $compare        Comparison value.
+		 *    @return boolean               True if correct.
+		 *    @access public
+		 */
+		function test($compare) {
+			return (boolean)preg_match($this->_getPattern(), $compare);
+		}
+
+		/**
+		 *    Returns a human readable test message.
+		 *    @param mixed $compare      Comparison value.
+		 *    @return string             Description of success
+		 *                               or failure.
+		 *    @access public
+		 */
+		function testMessage($compare) {
+			if ($this->test($compare)) {
+				return $this->_describePatternMatch($this->_getPattern(), $compare);
+			} else {
+				$dumper = $this->_getDumper();
+				return "Pattern [" . $this->_getPattern() .
+						"] not detected in [" .
+						$dumper->describeValue($compare) . "]";
+			}
+		}
+
+		/**
+		 *    Describes a pattern match including the string
+		 *    found and it's position.
+		 *    @package SimpleTest
+		 *    @subpackage UnitTester
+		 *    @param string $pattern        Regex to match against.
+		 *    @param string $subject        Subject to search.
+		 *    @access protected
+		 */
+		function _describePatternMatch($pattern, $subject) {
+			preg_match($pattern, $subject, $matches);
+			$position = strpos($subject, $matches[0]);
+			$dumper = $this->_getDumper();
+			return "Pattern [$pattern] detected at character [$position] in [" .
+					$dumper->describeValue($subject) . "] as [" .
+					$matches[0] . "] in region [" .
+					$dumper->clipString($subject, 100, $position) . "]";
+		}
+	}
+
+	/**
+	 *      @deprecated
+	 */
+	class WantedPatternExpectation extends PatternExpectation {
+	}
+
+	/**
+	 *    Fail if a pattern is detected within the
+	 *    comparison.
+	 *      @package SimpleTest
+	 *      @subpackage UnitTester
+	 */
+	class NoPatternExpectation extends PatternExpectation {
+
+		/**
+		 *    Sets the reject pattern
+		 *    @param string $pattern    Pattern to search for.
+		 *    @param string $message    Customised message on failure.
+		 *    @access public
+		 */
+		function NoPatternExpectation($pattern, $message = '%s') {
+			$this->PatternExpectation($pattern, $message);
+		}
+
+		/**
+		 *    Tests the expectation. False if the Perl regex
+		 *    matches the comparison value.
+		 *    @param string $compare        Comparison value.
+		 *    @return boolean               True if correct.
+		 *    @access public
+		 */
+		function test($compare) {
+			return ! parent::test($compare);
+		}
+
+		/**
+		 *    Returns a human readable test message.
+		 *    @param string $compare      Comparison value.
+		 *    @return string              Description of success
+		 *                                or failure.
+		 *    @access public
+		 */
+		function testMessage($compare) {
+			if ($this->test($compare)) {
+				$dumper = $this->_getDumper();
+				return "Pattern [" . $this->_getPattern() .
+						"] not detected in [" .
+						$dumper->describeValue($compare) . "]";
+			} else {
+				return $this->_describePatternMatch($this->_getPattern(), $compare);
+			}
+		}
+	}
+
+	/**
+	 *    @package SimpleTest
+	 *    @subpackage UnitTester
+	 *      @deprecated
+	 */
+	class UnwantedPatternExpectation extends NoPatternExpectation {
+	}
+
+	/**
+	 *    Tests either type or class name if it's an object.
+	 *      @package SimpleTest
+	 *      @subpackage UnitTester
+	 */
+	class IsAExpectation extends SimpleExpectation {
+		protected $_type;
+
+		/**
+		 *    Sets the type to compare with.
+		 *    @param string $type       Type or class name.
+		 *    @param string $message    Customised message on failure.
+		 *    @access public
+		 */
+		function IsAExpectation($type, $message = '%s') {
+			$this->SimpleExpectation($message);
+			$this->_type = $type;
+		}
+
+		/**
+		 *    Accessor for type to check against.
+		 *    @return string    Type or class name.
+		 *    @access protected
+		 */
+		function _getType() {
+			return $this->_type;
+		}
+
+		/**
+		 *    Tests the expectation. True if the type or
+		 *    class matches the string value.
+		 *    @param string $compare        Comparison value.
+		 *    @return boolean               True if correct.
+		 *    @access public
+		 */
+		function test($compare) {
+			if (is_object($compare)) {
+				return SimpleTestCompatibility::isA($compare, $this->_type);
+			} else {
+				return (strtolower(gettype($compare)) == $this->_canonicalType($this->_type));
+			}
+		}
+
+		/**
+		 *    Coerces type name into a gettype() match.
+		 *    @param string $type        User type.
+		 *    @return string             Simpler type.
+		 *    @access private
+		 */
+		function _canonicalType($type) {
+			$type = strtolower($type);
+			$map = array(
+					'bool' => 'boolean',
+					'float' => 'double',
+					'real' => 'double',
+					'int' => 'integer');
+			if (isset($map[$type])) {
+				$type = $map[$type];
+			}
+			return $type;
+		}
+
+		/**
+		 *    Returns a human readable test message.
+		 *    @param mixed $compare      Comparison value.
+		 *    @return string             Description of success
+		 *                               or failure.
+		 *    @access public
+		 */
+		function testMessage($compare) {
+			$dumper = $this->_getDumper();
+			return "Value [" . $dumper->describeValue($compare) .
+					"] should be type [" . $this->_type . "]";
+		}
+	}
+
+	/**
+	 *    Tests either type or class name if it's an object.
+	 *    Will succeed if the type does not match.
+	 *      @package SimpleTest
+	 *      @subpackage UnitTester
+	 */
+	class NotAExpectation extends IsAExpectation {
+		protected $_type;
+
+		/**
+		 *    Sets the type to compare with.
+		 *    @param string $type       Type or class name.
+		 *    @param string $message    Customised message on failure.
+		 *    @access public
+		 */
+		function NotAExpectation($type, $message = '%s') {
+			$this->IsAExpectation($type, $message);
+		}
+
+		/**
+		 *    Tests the expectation. False if the type or
+		 *    class matches the string value.
+		 *    @param string $compare        Comparison value.
+		 *    @return boolean               True if different.
+		 *    @access public
+		 */
+		function test($compare) {
+			return ! parent::test($compare);
+		}
+
+		/**
+		 *    Returns a human readable test message.
+		 *    @param mixed $compare      Comparison value.
+		 *    @return string             Description of success
+		 *                               or failure.
+		 *    @access public
+		 */
+		function testMessage($compare) {
+			$dumper = $this->_getDumper();
+			return "Value [" . $dumper->describeValue($compare) .
+					"] should not be type [" . $this->_getType() . "]";
+		}
+	}
+
+	/**
+	 *    Tests for existance of a method in an object
+	 *      @package SimpleTest
+	 *      @subpackage UnitTester
+	 */
+	class MethodExistsExpectation extends SimpleExpectation {
+		protected $_method;
+
+		/**
+		 *    Sets the value to compare against.
+		 *    @param string $method     Method to check.
+		 *    @param string $message    Customised message on failure.
+		 *    @access public
+		 *    @return void
+		 */
+		function MethodExistsExpectation($method, $message = '%s') {
+			$this->SimpleExpectation($message);
+			$this->_method = $method;
+		}
+
+		/**
+		 *    Tests the expectation. True if the method exists in the test object.
+		 *    @param string $compare        Comparison method name.
+		 *    @return boolean               True if correct.
+		 *    @access public
+		 */
+		function test($compare) {
+			return (boolean)(is_object($compare) && method_exists($compare, $this->_method));
+		}
+
+		/**
+		 *    Returns a human readable test message.
+		 *    @param mixed $compare      Comparison value.
+		 *    @return string             Description of success
+		 *                               or failure.
+		 *    @access public
+		 */
+		function testMessage($compare) {
+			$dumper = $this->_getDumper();
+			if (! is_object($compare)) {
+				return 'No method on non-object [' . $dumper->describeValue($compare) . ']';
+			}
+			$method = $this->_method;
+			return "Object [" . $dumper->describeValue($compare) .
+					"] should contain method [$method]";
+		}
+	}

tests/test_tools/simpletest/encoding.php

Indentation +502 added lines, -502 removed lines

@@ -1,520 +1,520 @@
 <?php
-    /**
-     *	base include file for SimpleTest
-     *	@package	SimpleTest
-     *	@subpackage	WebTester
-     *	@version	$Id: encoding.php 1398 2006-09-08 19:31:03Z xue $
-     */
-
-    /**#@+
+	/**
+	 *	base include file for SimpleTest
+	 *	@package	SimpleTest
+	 *	@subpackage	WebTester
+	 *	@version	$Id: encoding.php 1398 2006-09-08 19:31:03Z xue $
+	 */
+
+	/**#@+
      *	include other SimpleTest class files
      */
-    require_once(dirname(__FILE__) . '/socket.php');
-    /**#@-*/
+	require_once(dirname(__FILE__) . '/socket.php');
+	/**#@-*/
 
-    /**
-     *    Single post parameter.
+	/**
+	 *    Single post parameter.
 	 *    @package SimpleTest
 	 *    @subpackage WebTester
-     */
-    class SimpleEncodedPair {
-        protected $_key;
-        protected $_value;
-
-        /**
-         *    Stashes the data for rendering later.
-         *    @param string $key       Form element name.
-         *    @param string $value     Data to send.
-         */
-        function SimpleEncodedPair($key, $value) {
-            $this->_key = $key;
-            $this->_value = $value;
-        }
-
-        /**
-         *    The pair as a single string.
-         *    @return string        Encoded pair.
-         *    @access public
-         */
-        function asRequest() {
-            return $this->_key . '=' . urlencode($this->_value);
-        }
-
-        /**
-         *    The MIME part as a string.
-         *    @return string        MIME part encoding.
-         *    @access public
-         */
-        function asMime() {
-            $part = 'Content-Disposition: form-data; ';
-            $part .= "name=\"" . $this->_key . "\"\r\n";
-            $part .= "\r\n" . $this->_value;
-            return $part;
-        }
-
-        /**
-         *    Is this the value we are looking for?
-         *    @param string $key    Identifier.
-         *    @return boolean       True if matched.
-         *    @access public
-         */
-        function isKey($key) {
-            return $key == $this->_key;
-        }
-
-        /**
-         *    Is this the value we are looking for?
-         *    @return string       Identifier.
-         *    @access public
-         */
-        function getKey() {
-            return $this->_key;
-        }
-
-        /**
-         *    Is this the value we are looking for?
-         *    @return string       Content.
-         *    @access public
-         */
-        function getValue() {
-            return $this->_value;
-        }
-    }
-
-    /**
-     *    Single post parameter.
+	 */
+	class SimpleEncodedPair {
+		protected $_key;
+		protected $_value;
+
+		/**
+		 *    Stashes the data for rendering later.
+		 *    @param string $key       Form element name.
+		 *    @param string $value     Data to send.
+		 */
+		function SimpleEncodedPair($key, $value) {
+			$this->_key = $key;
+			$this->_value = $value;
+		}
+
+		/**
+		 *    The pair as a single string.
+		 *    @return string        Encoded pair.
+		 *    @access public
+		 */
+		function asRequest() {
+			return $this->_key . '=' . urlencode($this->_value);
+		}
+
+		/**
+		 *    The MIME part as a string.
+		 *    @return string        MIME part encoding.
+		 *    @access public
+		 */
+		function asMime() {
+			$part = 'Content-Disposition: form-data; ';
+			$part .= "name=\"" . $this->_key . "\"\r\n";
+			$part .= "\r\n" . $this->_value;
+			return $part;
+		}
+
+		/**
+		 *    Is this the value we are looking for?
+		 *    @param string $key    Identifier.
+		 *    @return boolean       True if matched.
+		 *    @access public
+		 */
+		function isKey($key) {
+			return $key == $this->_key;
+		}
+
+		/**
+		 *    Is this the value we are looking for?
+		 *    @return string       Identifier.
+		 *    @access public
+		 */
+		function getKey() {
+			return $this->_key;
+		}
+
+		/**
+		 *    Is this the value we are looking for?
+		 *    @return string       Content.
+		 *    @access public
+		 */
+		function getValue() {
+			return $this->_value;
+		}
+	}
+
+	/**
+	 *    Single post parameter.
 	 *    @package SimpleTest
 	 *    @subpackage WebTester
-     */
-    class SimpleAttachment {
-        protected $_key;
-        protected $_content;
-        protected $_filename;
-
-        /**
-         *    Stashes the data for rendering later.
-         *    @param string $key          Key to add value to.
-         *    @param string $content      Raw data.
-         *    @param hash $filename       Original filename.
-         */
-        function SimpleAttachment($key, $content, $filename) {
-            $this->_key = $key;
-            $this->_content = $content;
-            $this->_filename = $filename;
-        }
-
-        /**
-         *    The pair as a single string.
-         *    @return string        Encoded pair.
-         *    @access public
-         */
-        function asRequest() {
-            return '';
-        }
-
-        /**
-         *    The MIME part as a string.
-         *    @return string        MIME part encoding.
-         *    @access public
-         */
-        function asMime() {
-            $part = 'Content-Disposition: form-data; ';
-            $part .= 'name="' . $this->_key . '"; ';
-            $part .= 'filename="' . $this->_filename . '"';
-            $part .= "\r\nContent-Type: " . $this->_deduceMimeType();
-            $part .= "\r\n\r\n" . $this->_content;
-            return $part;
-        }
-
-        /**
-         *    Attempts to figure out the MIME type from the
-         *    file extension and the content.
-         *    @return string        MIME type.
-         *    @access private
-         */
-        function _deduceMimeType() {
-            if ($this->_isOnlyAscii($this->_content)) {
-                return 'text/plain';
-            }
-            return 'application/octet-stream';
-        }
-
-        /**
-         *    Tests each character is in the range 0-127.
-         *    @param string $ascii    String to test.
-         *    @access private
-         */
-        function _isOnlyAscii($ascii) {
-            for ($i = 0, $length = strlen($ascii); $i < $length; $i++) {
-                if (ord($ascii[$i]) > 127) {
-                    return false;
-                }
-            }
-            return true;
-        }
-
-        /**
-         *    Is this the value we are looking for?
-         *    @param string $key    Identifier.
-         *    @return boolean       True if matched.
-         *    @access public
-         */
-        function isKey($key) {
-            return $key == $this->_key;
-        }
-
-        /**
-         *    Is this the value we are looking for?
-         *    @return string       Identifier.
-         *    @access public
-         */
-        function getKey() {
-            return $this->_key;
-        }
-
-        /**
-         *    Is this the value we are looking for?
-         *    @return string       Content.
-         *    @access public
-         */
-        function getValue() {
-            return $this->_filename;
-        }
-    }
-
-    /**
-     *    Bundle of GET/POST parameters. Can include
-     *    repeated parameters.
+	 */
+	class SimpleAttachment {
+		protected $_key;
+		protected $_content;
+		protected $_filename;
+
+		/**
+		 *    Stashes the data for rendering later.
+		 *    @param string $key          Key to add value to.
+		 *    @param string $content      Raw data.
+		 *    @param hash $filename       Original filename.
+		 */
+		function SimpleAttachment($key, $content, $filename) {
+			$this->_key = $key;
+			$this->_content = $content;
+			$this->_filename = $filename;
+		}
+
+		/**
+		 *    The pair as a single string.
+		 *    @return string        Encoded pair.
+		 *    @access public
+		 */
+		function asRequest() {
+			return '';
+		}
+
+		/**
+		 *    The MIME part as a string.
+		 *    @return string        MIME part encoding.
+		 *    @access public
+		 */
+		function asMime() {
+			$part = 'Content-Disposition: form-data; ';
+			$part .= 'name="' . $this->_key . '"; ';
+			$part .= 'filename="' . $this->_filename . '"';
+			$part .= "\r\nContent-Type: " . $this->_deduceMimeType();
+			$part .= "\r\n\r\n" . $this->_content;
+			return $part;
+		}
+
+		/**
+		 *    Attempts to figure out the MIME type from the
+		 *    file extension and the content.
+		 *    @return string        MIME type.
+		 *    @access private
+		 */
+		function _deduceMimeType() {
+			if ($this->_isOnlyAscii($this->_content)) {
+				return 'text/plain';
+			}
+			return 'application/octet-stream';
+		}
+
+		/**
+		 *    Tests each character is in the range 0-127.
+		 *    @param string $ascii    String to test.
+		 *    @access private
+		 */
+		function _isOnlyAscii($ascii) {
+			for ($i = 0, $length = strlen($ascii); $i < $length; $i++) {
+				if (ord($ascii[$i]) > 127) {
+					return false;
+				}
+			}
+			return true;
+		}
+
+		/**
+		 *    Is this the value we are looking for?
+		 *    @param string $key    Identifier.
+		 *    @return boolean       True if matched.
+		 *    @access public
+		 */
+		function isKey($key) {
+			return $key == $this->_key;
+		}
+
+		/**
+		 *    Is this the value we are looking for?
+		 *    @return string       Identifier.
+		 *    @access public
+		 */
+		function getKey() {
+			return $this->_key;
+		}
+
+		/**
+		 *    Is this the value we are looking for?
+		 *    @return string       Content.
+		 *    @access public
+		 */
+		function getValue() {
+			return $this->_filename;
+		}
+	}
+
+	/**
+	 *    Bundle of GET/POST parameters. Can include
+	 *    repeated parameters.
 	 *    @package SimpleTest
 	 *    @subpackage WebTester
-     */
-    class SimpleEncoding {
-        protected $_request;
-
-        /**
-         *    Starts empty.
-         *    @param array $query       Hash of parameters.
-         *                              Multiple values are
-         *                              as lists on a single key.
-         *    @access public
-         */
-        function SimpleEncoding($query = false) {
-            if (! $query) {
-                $query = array();
-            }
-            $this->clear();
-            $this->merge($query);
-        }
-
-        /**
-         *    Empties the request of parameters.
-         *    @access public
-         */
-        function clear() {
-            $this->_request = array();
-        }
-
-        /**
-         *    Adds a parameter to the query.
-         *    @param string $key            Key to add value to.
-         *    @param string/array $value    New data.
-         *    @access public
-         */
-        function add($key, $value) {
-            if ($value === false) {
-                return;
-            }
-            if (is_array($value)) {
-                foreach ($value as $item) {
-                    $this->_addPair($key, $item);
-                }
-            } else {
-                $this->_addPair($key, $value);
-            }
-        }
-
-        /**
-         *    Adds a new value into the request.
-         *    @param string $key            Key to add value to.
-         *    @param string/array $value    New data.
-         *    @access private
-         */
-        function _addPair($key, $value) {
-            $this->_request[] = new SimpleEncodedPair($key, $value);
-        }
-
-        /**
-         *    Adds a MIME part to the query. Does nothing for a
-         *    form encoded packet.
-         *    @param string $key          Key to add value to.
-         *    @param string $content      Raw data.
-         *    @param hash $filename       Original filename.
-         *    @access public
-         */
-        function attach($key, $content, $filename) {
-            $this->_request[] = new SimpleAttachment($key, $content, $filename);
-        }
-
-        /**
-         *    Adds a set of parameters to this query.
-         *    @param array/SimpleQueryString $query  Multiple values are
-         *                                           as lists on a single key.
-         *    @access public
-         */
-        function merge($query) {
-            if (is_object($query)) {
-                $this->_request = array_merge($this->_request, $query->getAll());
-            } elseif (is_array($query)) {
-                foreach ($query as $key => $value) {
-                    $this->add($key, $value);
-                }
-            }
-        }
-
-        /**
-         *    Accessor for single value.
-         *    @return string/array    False if missing, string
-         *                            if present and array if
-         *                            multiple entries.
-         *    @access public
-         */
-        function getValue($key) {
-            $values = array();
-            foreach ($this->_request as $pair) {
-                if ($pair->isKey($key)) {
-                    $values[] = $pair->getValue();
-                }
-            }
-            if (count($values) == 0) {
-                return false;
-            } elseif (count($values) == 1) {
-                return $values[0];
-            } else {
-                return $values;
-            }
-        }
-
-        /**
-         *    Accessor for listing of pairs.
-         *    @return array        All pair objects.
-         *    @access public
-         */
-        function getAll() {
-            return $this->_request;
-        }
-
-        /**
-         *    Renders the query string as a URL encoded
-         *    request part.
-         *    @return string        Part of URL.
-         *    @access protected
-         */
-        function _encode() {
-            $statements = array();
-            foreach ($this->_request as $pair) {
-                if ($statement = $pair->asRequest()) {
-                    $statements[] = $statement;
-                }
-            }
-            return implode('&', $statements);
-        }
-    }
-
-    /**
-     *    Bundle of GET parameters. Can include
-     *    repeated parameters.
+	 */
+	class SimpleEncoding {
+		protected $_request;
+
+		/**
+		 *    Starts empty.
+		 *    @param array $query       Hash of parameters.
+		 *                              Multiple values are
+		 *                              as lists on a single key.
+		 *    @access public
+		 */
+		function SimpleEncoding($query = false) {
+			if (! $query) {
+				$query = array();
+			}
+			$this->clear();
+			$this->merge($query);
+		}
+
+		/**
+		 *    Empties the request of parameters.
+		 *    @access public
+		 */
+		function clear() {
+			$this->_request = array();
+		}
+
+		/**
+		 *    Adds a parameter to the query.
+		 *    @param string $key            Key to add value to.
+		 *    @param string/array $value    New data.
+		 *    @access public
+		 */
+		function add($key, $value) {
+			if ($value === false) {
+				return;
+			}
+			if (is_array($value)) {
+				foreach ($value as $item) {
+					$this->_addPair($key, $item);
+				}
+			} else {
+				$this->_addPair($key, $value);
+			}
+		}
+
+		/**
+		 *    Adds a new value into the request.
+		 *    @param string $key            Key to add value to.
+		 *    @param string/array $value    New data.
+		 *    @access private
+		 */
+		function _addPair($key, $value) {
+			$this->_request[] = new SimpleEncodedPair($key, $value);
+		}
+
+		/**
+		 *    Adds a MIME part to the query. Does nothing for a
+		 *    form encoded packet.
+		 *    @param string $key          Key to add value to.
+		 *    @param string $content      Raw data.
+		 *    @param hash $filename       Original filename.
+		 *    @access public
+		 */
+		function attach($key, $content, $filename) {
+			$this->_request[] = new SimpleAttachment($key, $content, $filename);
+		}
+
+		/**
+		 *    Adds a set of parameters to this query.
+		 *    @param array/SimpleQueryString $query  Multiple values are
+		 *                                           as lists on a single key.
+		 *    @access public
+		 */
+		function merge($query) {
+			if (is_object($query)) {
+				$this->_request = array_merge($this->_request, $query->getAll());
+			} elseif (is_array($query)) {
+				foreach ($query as $key => $value) {
+					$this->add($key, $value);
+				}
+			}
+		}
+
+		/**
+		 *    Accessor for single value.
+		 *    @return string/array    False if missing, string
+		 *                            if present and array if
+		 *                            multiple entries.
+		 *    @access public
+		 */
+		function getValue($key) {
+			$values = array();
+			foreach ($this->_request as $pair) {
+				if ($pair->isKey($key)) {
+					$values[] = $pair->getValue();
+				}
+			}
+			if (count($values) == 0) {
+				return false;
+			} elseif (count($values) == 1) {
+				return $values[0];
+			} else {
+				return $values;
+			}
+		}
+
+		/**
+		 *    Accessor for listing of pairs.
+		 *    @return array        All pair objects.
+		 *    @access public
+		 */
+		function getAll() {
+			return $this->_request;
+		}
+
+		/**
+		 *    Renders the query string as a URL encoded
+		 *    request part.
+		 *    @return string        Part of URL.
+		 *    @access protected
+		 */
+		function _encode() {
+			$statements = array();
+			foreach ($this->_request as $pair) {
+				if ($statement = $pair->asRequest()) {
+					$statements[] = $statement;
+				}
+			}
+			return implode('&', $statements);
+		}
+	}
+
+	/**
+	 *    Bundle of GET parameters. Can include
+	 *    repeated parameters.
 	 *    @package SimpleTest
 	 *    @subpackage WebTester
-     */
-    class SimpleGetEncoding extends SimpleEncoding {
-
-        /**
-         *    Starts empty.
-         *    @param array $query       Hash of parameters.
-         *                              Multiple values are
-         *                              as lists on a single key.
-         *    @access public
-         */
-        function SimpleGetEncoding($query = false) {
-            $this->SimpleEncoding($query);
-        }
-
-        /**
-         *    HTTP request method.
-         *    @return string        Always GET.
-         *    @access public
-         */
-        function getMethod() {
-            return 'GET';
-        }
-
-        /**
-         *    Writes no extra headers.
-         *    @param SimpleSocket $socket        Socket to write to.
-         *    @access public
-         */
-        function writeHeadersTo($socket) {
-        }
-
-        /**
-         *    No data is sent to the socket as the data is encoded into
-         *    the URL.
-         *    @param SimpleSocket $socket        Socket to write to.
-         *    @access public
-         */
-        function writeTo($socket) {
-        }
-
-        /**
-         *    Renders the query string as a URL encoded
-         *    request part for attaching to a URL.
-         *    @return string        Part of URL.
-         *    @access public
-         */
-        function asUrlRequest() {
-            return $this->_encode();
-        }
-    }
-
-    /**
-     *    Bundle of URL parameters for a HEAD request.
+	 */
+	class SimpleGetEncoding extends SimpleEncoding {
+
+		/**
+		 *    Starts empty.
+		 *    @param array $query       Hash of parameters.
+		 *                              Multiple values are
+		 *                              as lists on a single key.
+		 *    @access public
+		 */
+		function SimpleGetEncoding($query = false) {
+			$this->SimpleEncoding($query);
+		}
+
+		/**
+		 *    HTTP request method.
+		 *    @return string        Always GET.
+		 *    @access public
+		 */
+		function getMethod() {
+			return 'GET';
+		}
+
+		/**
+		 *    Writes no extra headers.
+		 *    @param SimpleSocket $socket        Socket to write to.
+		 *    @access public
+		 */
+		function writeHeadersTo($socket) {
+		}
+
+		/**
+		 *    No data is sent to the socket as the data is encoded into
+		 *    the URL.
+		 *    @param SimpleSocket $socket        Socket to write to.
+		 *    @access public
+		 */
+		function writeTo($socket) {
+		}
+
+		/**
+		 *    Renders the query string as a URL encoded
+		 *    request part for attaching to a URL.
+		 *    @return string        Part of URL.
+		 *    @access public
+		 */
+		function asUrlRequest() {
+			return $this->_encode();
+		}
+	}
+
+	/**
+	 *    Bundle of URL parameters for a HEAD request.
 	 *    @package SimpleTest
 	 *    @subpackage WebTester
-     */
-    class SimpleHeadEncoding extends SimpleGetEncoding {
-
-        /**
-         *    Starts empty.
-         *    @param array $query       Hash of parameters.
-         *                              Multiple values are
-         *                              as lists on a single key.
-         *    @access public
-         */
-        function SimpleHeadEncoding($query = false) {
-            $this->SimpleGetEncoding($query);
-        }
-
-        /**
-         *    HTTP request method.
-         *    @return string        Always HEAD.
-         *    @access public
-         */
-        function getMethod() {
-            return 'HEAD';
-        }
-    }
-
-    /**
-     *    Bundle of POST parameters. Can include
-     *    repeated parameters.
+	 */
+	class SimpleHeadEncoding extends SimpleGetEncoding {
+
+		/**
+		 *    Starts empty.
+		 *    @param array $query       Hash of parameters.
+		 *                              Multiple values are
+		 *                              as lists on a single key.
+		 *    @access public
+		 */
+		function SimpleHeadEncoding($query = false) {
+			$this->SimpleGetEncoding($query);
+		}
+
+		/**
+		 *    HTTP request method.
+		 *    @return string        Always HEAD.
+		 *    @access public
+		 */
+		function getMethod() {
+			return 'HEAD';
+		}
+	}
+
+	/**
+	 *    Bundle of POST parameters. Can include
+	 *    repeated parameters.
 	 *    @package SimpleTest
 	 *    @subpackage WebTester
-     */
-    class SimplePostEncoding extends SimpleEncoding {
-
-        /**
-         *    Starts empty.
-         *    @param array $query       Hash of parameters.
-         *                              Multiple values are
-         *                              as lists on a single key.
-         *    @access public
-         */
-        function SimplePostEncoding($query = false) {
-            $this->SimpleEncoding($query);
-        }
-
-        /**
-         *    HTTP request method.
-         *    @return string        Always POST.
-         *    @access public
-         */
-        function getMethod() {
-            return 'POST';
-        }
-
-        /**
-         *    Dispatches the form headers down the socket.
-         *    @param SimpleSocket $socket        Socket to write to.
-         *    @access public
-         */
-        function writeHeadersTo($socket) {
-            $socket->write("Content-Length: " . (integer)strlen($this->_encode()) . "\r\n");
-            $socket->write("Content-Type: application/x-www-form-urlencoded\r\n");
-        }
-
-        /**
-         *    Dispatches the form data down the socket.
-         *    @param SimpleSocket $socket        Socket to write to.
-         *    @access public
-         */
-        function writeTo($socket) {
-            $socket->write($this->_encode());
-        }
-
-        /**
-         *    Renders the query string as a URL encoded
-         *    request part for attaching to a URL.
-         *    @return string        Part of URL.
-         *    @access public
-         */
-        function asUrlRequest() {
-            return '';
-        }
-    }
-
-    /**
-     *    Bundle of POST parameters in the multipart
-     *    format. Can include file uploads.
+	 */
+	class SimplePostEncoding extends SimpleEncoding {
+
+		/**
+		 *    Starts empty.
+		 *    @param array $query       Hash of parameters.
+		 *                              Multiple values are
+		 *                              as lists on a single key.
+		 *    @access public
+		 */
+		function SimplePostEncoding($query = false) {
+			$this->SimpleEncoding($query);
+		}
+
+		/**
+		 *    HTTP request method.
+		 *    @return string        Always POST.
+		 *    @access public
+		 */
+		function getMethod() {
+			return 'POST';
+		}
+
+		/**
+		 *    Dispatches the form headers down the socket.
+		 *    @param SimpleSocket $socket        Socket to write to.
+		 *    @access public
+		 */
+		function writeHeadersTo($socket) {
+			$socket->write("Content-Length: " . (integer)strlen($this->_encode()) . "\r\n");
+			$socket->write("Content-Type: application/x-www-form-urlencoded\r\n");
+		}
+
+		/**
+		 *    Dispatches the form data down the socket.
+		 *    @param SimpleSocket $socket        Socket to write to.
+		 *    @access public
+		 */
+		function writeTo($socket) {
+			$socket->write($this->_encode());
+		}
+
+		/**
+		 *    Renders the query string as a URL encoded
+		 *    request part for attaching to a URL.
+		 *    @return string        Part of URL.
+		 *    @access public
+		 */
+		function asUrlRequest() {
+			return '';
+		}
+	}
+
+	/**
+	 *    Bundle of POST parameters in the multipart
+	 *    format. Can include file uploads.
 	 *    @package SimpleTest
 	 *    @subpackage WebTester
-     */
-    class SimpleMultipartEncoding extends SimplePostEncoding {
-        protected $_boundary;
-
-        /**
-         *    Starts empty.
-         *    @param array $query       Hash of parameters.
-         *                              Multiple values are
-         *                              as lists on a single key.
-         *    @access public
-         */
-        function SimpleMultipartEncoding($query = false, $boundary = false) {
-            $this->SimplePostEncoding($query);
-            $this->_boundary = ($boundary === false ? uniqid('st') : $boundary);
-        }
-
-        /**
-         *    Dispatches the form headers down the socket.
-         *    @param SimpleSocket $socket        Socket to write to.
-         *    @access public
-         */
-        function writeHeadersTo($socket) {
-            $socket->write("Content-Length: " . (integer)strlen($this->_encode()) . "\r\n");
-            $socket->write("Content-Type: multipart/form-data, boundary=" . $this->_boundary . "\r\n");
-        }
-
-        /**
-         *    Dispatches the form data down the socket.
-         *    @param SimpleSocket $socket        Socket to write to.
-         *    @access public
-         */
-        function writeTo($socket) {
-            $socket->write($this->_encode());
-        }
-
-        /**
-         *    Renders the query string as a URL encoded
-         *    request part.
-         *    @return string        Part of URL.
-         *    @access public
-         */
-        function _encode() {
-            $stream = '';
-            foreach ($this->_request as $pair) {
-                $stream .= "--" . $this->_boundary . "\r\n";
-                $stream .= $pair->asMime() . "\r\n";
-            }
-            $stream .= "--" . $this->_boundary . "--\r\n";
-            return $stream;
-        }
-    }
\ No newline at end of file
+	 */
+	class SimpleMultipartEncoding extends SimplePostEncoding {
+		protected $_boundary;
+
+		/**
+		 *    Starts empty.
+		 *    @param array $query       Hash of parameters.
+		 *                              Multiple values are
+		 *                              as lists on a single key.
+		 *    @access public
+		 */
+		function SimpleMultipartEncoding($query = false, $boundary = false) {
+			$this->SimplePostEncoding($query);
+			$this->_boundary = ($boundary === false ? uniqid('st') : $boundary);
+		}
+
+		/**
+		 *    Dispatches the form headers down the socket.
+		 *    @param SimpleSocket $socket        Socket to write to.
+		 *    @access public
+		 */
+		function writeHeadersTo($socket) {
+			$socket->write("Content-Length: " . (integer)strlen($this->_encode()) . "\r\n");
+			$socket->write("Content-Type: multipart/form-data, boundary=" . $this->_boundary . "\r\n");
+		}
+
+		/**
+		 *    Dispatches the form data down the socket.
+		 *    @param SimpleSocket $socket        Socket to write to.
+		 *    @access public
+		 */
+		function writeTo($socket) {
+			$socket->write($this->_encode());
+		}
+
+		/**
+		 *    Renders the query string as a URL encoded
+		 *    request part.
+		 *    @return string        Part of URL.
+		 *    @access public
+		 */
+		function _encode() {
+			$stream = '';
+			foreach ($this->_request as $pair) {
+				$stream .= "--" . $this->_boundary . "\r\n";
+				$stream .= $pair->asMime() . "\r\n";
+			}
+			$stream .= "--" . $this->_boundary . "--\r\n";
+			return $stream;
+		}
+	}
\ No newline at end of file

tests/test_tools/simpletest/exceptions.php

Indentation +35 added lines, -35 removed lines

@@ -1,45 +1,45 @@
 <?php
-    /**
-     *	base include file for SimpleTest
-     *	@package	SimpleTest
-     *	@subpackage	UnitTester
-     *	@version	$Id: exceptions.php 1398 2006-09-08 19:31:03Z xue $
-     */
+	/**
+	 *	base include file for SimpleTest
+	 *	@package	SimpleTest
+	 *	@subpackage	UnitTester
+	 *	@version	$Id: exceptions.php 1398 2006-09-08 19:31:03Z xue $
+	 */
 
-    /**#@+
+	/**#@+
      * Includes SimpleTest files and defined the root constant
      * for dependent libraries.
      */
-    require_once(dirname(__FILE__) . '/invoker.php');
+	require_once(dirname(__FILE__) . '/invoker.php');
 
-    /**
-     *    Extension that traps exceptions and turns them into
-     *    an error message.
+	/**
+	 *    Extension that traps exceptions and turns them into
+	 *    an error message.
 	 *	  @package SimpleTest
 	 *	  @subpackage UnitTester
-     */
-    class SimpleExceptionTrappingInvoker extends SimpleInvokerDecorator {
+	 */
+	class SimpleExceptionTrappingInvoker extends SimpleInvokerDecorator {
 
-        /**
-         *    Stores the invoker to be wrapped.
-         *    @param SimpleInvoker $invoker   Test method runner.
-         */
-        function SimpleExceptionTrappingInvoker($invoker) {
-            $this->SimpleInvokerDecorator($invoker);
-        }
+		/**
+		 *    Stores the invoker to be wrapped.
+		 *    @param SimpleInvoker $invoker   Test method runner.
+		 */
+		function SimpleExceptionTrappingInvoker($invoker) {
+			$this->SimpleInvokerDecorator($invoker);
+		}
 
-        /**
-         *    Invokes a test method and dispatches any
-         *    untrapped errors.
-         *    @param string $method    Test method to call.
-         *    @access public
-         */
-        function invoke($method) {
-            try {
-                parent::invoke($method);
-            } catch (Exception $exception) {
-                $test_case = $this->getTestCase();
-                $test_case->exception($exception);
-            }
-        }
-    }
\ No newline at end of file
+		/**
+		 *    Invokes a test method and dispatches any
+		 *    untrapped errors.
+		 *    @param string $method    Test method to call.
+		 *    @access public
+		 */
+		function invoke($method) {
+			try {
+				parent::invoke($method);
+			} catch (Exception $exception) {
+				$test_case = $this->getTestCase();
+				$test_case->exception($exception);
+			}
+		}
+	}
\ No newline at end of file