Source for file simpletest.php

Documentation is available at simpletest.php

  1. <?php
  2. /**
  3.  *  Global state for SimpleTest and kicker script in future versions.
  4.  *  @package    SimpleTest
  5.  *  @subpackage UnitTester
  6.  *  @version    $Id: simpletest.php 1723 2008-04-08 00:34:10Z lastcraft $
  7.  */
  8.  
  9. /**#@+
  10.  * include SimpleTest files
  11.  */
  12. if (version_compare(phpversion(), '5') >= 0) {
  13.     require_once(dirname(__FILE__) . '/reflection_php5.php');
  14. } else {
  15.     require_once(dirname(__FILE__) . '/reflection_php4.php');
  16. }
  17. require_once(dirname(__FILE__) . '/default_reporter.php');
  18. require_once(dirname(__FILE__) . '/compatibility.php');
  19. /**#@-*/
  20.  
  21.  *    Registry and test context. Includes a few
  22.  *    global options that I'm slowly getting rid of.
  23.  *    @package  SimpleTest
  24.  *    @subpackage   UnitTester
  25.  */
  26. class SimpleTest {
  27.  
  28.     /**
  29.      *    Reads the SimpleTest version from the release file.
  30.      *    @return string        Version string.
  31.      *    @static
  32.      *    @access public
  33.      */
  34.     function getVersion() {
  35.         $content = file(dirname(__FILE__) . '/VERSION');
  36.         return trim($content[0]);
  37.     }
  38.  
  39.     /**
  40.      *    Sets the name of a test case to ignore, usually
  41.      *    because the class is an abstract case that should
  42.      *    not be run. Once PHP4 is dropped this will disappear
  43.      *    as a public method and "abstract" will rule.
  44.      *    @param string $class        Add a class to ignore.
  45.      *    @static
  46.      *    @access public
  47.      */
  48.     function ignore($class) {
  49.         $registry = &SimpleTest::_getRegistry();
  50.         $registry['IgnoreList'][strtolower($class)] = true;
  51.     }
  52.  
  53.     /**
  54.      *    Scans the now complete ignore list, and adds
  55.      *    all parent classes to the list. If a class
  56.      *    is not a runnable test case, then it's parents
  57.      *    wouldn't be either. This is syntactic sugar
  58.      *    to cut down on ommissions of ignore()'s or
  59.      *    missing abstract declarations. This cannot
  60.      *    be done whilst loading classes wiithout forcing
  61.      *    a particular order on the class declarations and
  62.      *    the ignore() calls. It's just nice to have the ignore()
  63.      *    calls at the top of the file before the actual declarations.
  64.      *    @param array $classes     Class names of interest.
  65.      *    @static
  66.      *    @access public
  67.      */
  68.     function ignoreParentsIfIgnored($classes) {
  69.         $registry = &SimpleTest::_getRegistry();
  70.         foreach ($classes as $class) {
  71.             if (SimpleTest::isIgnored($class)) {
  72.                 $reflection = new SimpleReflection($class);
  73.                 if ($parent = $reflection->getParent()) {
  74.                     SimpleTest::ignore($parent);
  75.                 }
  76.             }
  77.         }
  78.     }
  79.  
  80.     /**
  81.      *   Puts the object to the global pool of 'preferred' objects
  82.      *   which can be retrieved with SimpleTest :: preferred() method.
  83.      *   Instances of the same class are overwritten.
  84.      *   @param object $object      Preferred object
  85.      *   @static
  86.      *   @access public
  87.      *   @see preferred()
  88.      */
  89.     function prefer(&$object) {
  90.         $registry = &SimpleTest::_getRegistry();
  91.         $registry['Preferred'][] = &$object;
  92.     }
  93.  
  94.     /**
  95.      *   Retrieves 'preferred' objects from global pool. Class filter
  96.      *   can be applied in order to retrieve the object of the specific
  97.      *   class
  98.      *   @param array|string$classes       Allowed classes or interfaces.
  99.      *   @static
  100.      *   @access public
  101.      *   @return array|object|null
  102.      *   @see prefer()
  103.      */
  104.     function &preferred($classes) {
  105.         if (! is_array($classes)) {
  106.             $classes = array($classes);
  107.         }
  108.         $registry = &SimpleTest::_getRegistry();
  109.         for ($i = count($registry['Preferred']) - 1; $i >= 0; $i--) {
  110.             foreach ($classes as $class) {
  111.                 if (SimpleTestCompatibility::isA($registry['Preferred'][$i], $class)) {
  112.                     return $registry['Preferred'][$i];
  113.                 }
  114.             }
  115.         }
  116.         return null;
  117.     }
  118.  
  119.     /**
  120.      *    Test to see if a test case is in the ignore
  121.      *    list. Quite obviously the ignore list should
  122.      *    be a separate object and will be one day.
  123.      *    This method is internal to SimpleTest. Don't
  124.      *    use it.
  125.      *    @param string $class        Class name to test.
  126.      *    @return boolean             True if should not be run.
  127.      *    @access public
  128.      *    @static
  129.      */
  130.     function isIgnored($class) {
  131.         $registry = &SimpleTest::_getRegistry();
  132.         return isset($registry['IgnoreList'][strtolower($class)]);
  133.     }
  134.  
  135.     /**
  136.      *    @deprecated
  137.      */
  138.     function setMockBaseClass($mock_base) {
  139.         $registry = &SimpleTest::_getRegistry();
  140.         $registry['MockBaseClass'] = $mock_base;
  141.     }
  142.  
  143.     /**
  144.      *    @deprecated
  145.      */
  146.     function getMockBaseClass() {
  147.         $registry = &SimpleTest::_getRegistry();
  148.         return $registry['MockBaseClass'];
  149.     }
  150.  
  151.     /**
  152.      *    Sets proxy to use on all requests for when
  153.      *    testing from behind a firewall. Set host
  154.      *    to false to disable. This will take effect
  155.      *    if there are no other proxy settings.
  156.      *    @param string $proxy     Proxy host as URL.
  157.      *    @param string $username  Proxy username for authentication.
  158.      *    @param string $password  Proxy password for authentication.
  159.      *    @access public
  160.      */
  161.     function useProxy($proxy, $username = false, $password = false) {
  162.         $registry = &SimpleTest::_getRegistry();
  163.         $registry['DefaultProxy'] = $proxy;
  164.         $registry['DefaultProxyUsername'] = $username;
  165.         $registry['DefaultProxyPassword'] = $password;
  166.     }
  167.  
  168.     /**
  169.      *    Accessor for default proxy host.
  170.      *    @return string       Proxy URL.
  171.      *    @access public
  172.      */
  173.     function getDefaultProxy() {
  174.         $registry = &SimpleTest::_getRegistry();
  175.         return $registry['DefaultProxy'];
  176.     }
  177.  
  178.     /**
  179.      *    Accessor for default proxy username.
  180.      *    @return string    Proxy username for authentication.
  181.      *    @access public
  182.      */
  183.     function getDefaultProxyUsername() {
  184.         $registry = &SimpleTest::_getRegistry();
  185.         return $registry['DefaultProxyUsername'];
  186.     }
  187.  
  188.     /**
  189.      *    Accessor for default proxy password.
  190.      *    @return string    Proxy password for authentication.
  191.      *    @access public
  192.      */
  193.     function getDefaultProxyPassword() {
  194.         $registry = &SimpleTest::_getRegistry();
  195.         return $registry['DefaultProxyPassword'];
  196.     }
  197.  
  198.     /**
  199.      *    Accessor for global registry of options.
  200.      *    @return hash           All stored values.
  201.      *    @access private
  202.      *    @static
  203.      */
  204.     function &_getRegistry() {
  205.         static $registry = false;
  206.         if (! $registry) {
  207.             $registry = SimpleTest::_getDefaults();
  208.         }
  209.         return $registry;
  210.     }
  211.  
  212.     /**
  213.      *    Accessor for the context of the current
  214.      *    test run.
  215.      *    @return SimpleTestContext    Current test run.
  216.      *    @access public
  217.      *    @static
  218.      */
  219.     function &getContext() {
  220.         static $context = false;
  221.         if (! $context) {
  222.             $context = new SimpleTestContext();
  223.         }
  224.         return $context;
  225.     }
  226.  
  227.     /**
  228.      *    Constant default values.
  229.      *    @return hash       All registry defaults.
  230.      *    @access private
  231.      *    @static
  232.      */
  233.     function _getDefaults() {
  234.         return array(
  235.                 'StubBaseClass' => 'SimpleStub',
  236.                 'MockBaseClass' => 'SimpleMock',
  237.                 'IgnoreList' => array(),
  238.                 'DefaultProxy' => false,
  239.                 'DefaultProxyUsername' => false,
  240.                 'DefaultProxyPassword' => false,
  241.                 'Preferred' => array(new HtmlReporter(), new TextReporter(), new XmlReporter()));
  242.     }
  243. }
  244.  
  245. /**
  246.  *    Container for all components for a specific
  247.  *    test run. Makes things like error queues
  248.  *    available to PHP event handlers, and also
  249.  *    gets around some nasty reference issues in
  250.  *    the mocks.
  251.  *    @package  SimpleTest
  252.  */
  253. class SimpleTestContext {
  254.     var $_test;
  255.     var $_reporter;
  256.     var $_resources;
  257.  
  258.     /**
  259.      *    Clears down the current context.
  260.      *    @access public
  261.      */
  262.     function clear() {
  263.         $this->_resources = array();
  264.     }
  265.  
  266.     /**
  267.      *    Sets the current test case instance. This
  268.      *    global instance can be used by the mock objects
  269.      *    to send message to the test cases.
  270.      *    @param SimpleTestCase $test        Test case to register.
  271.      *    @access public
  272.      */
  273.     function setTest(&$test) {
  274.         $this->clear();
  275.         $this->_test = &$test;
  276.     }
  277.  
  278.     /**
  279.      *    Accessor for currently running test case.
  280.      *    @return SimpleTestCase    Current test.
  281.      *    @access public
  282.      */
  283.     function &getTest() {
  284.         return $this->_test;
  285.     }
  286.  
  287.     /**
  288.      *    Sets the current reporter. This
  289.      *    global instance can be used by the mock objects
  290.      *    to send messages.
  291.      *    @param SimpleReporter $reporter     Reporter to register.
  292.      *    @access public
  293.      */
  294.     function setReporter(&$reporter) {
  295.         $this->clear();
  296.         $this->_reporter = &$reporter;
  297.     }
  298.  
  299.     /**
  300.      *    Accessor for current reporter.
  301.      *    @return SimpleReporter    Current reporter.
  302.      *    @access public
  303.      */
  304.     function &getReporter() {
  305.         return $this->_reporter;
  306.     }
  307.  
  308.     /**
  309.      *    Accessor for the Singleton resource.
  310.      *    @return object       Global resource.
  311.      *    @access public
  312.      *    @static
  313.      */
  314.     function &get($resource) {
  315.         if (! isset($this->_resources[$resource])) {
  316.             $this->_resources[$resource] = &new $resource();
  317.         }
  318.         return $this->_resources[$resource];
  319.     }
  320. }
  321.  
  322. /**
  323.  *    Interrogates the stack trace to recover the
  324.  *    failure point.
  325.  *    @package SimpleTest
  326.  *    @subpackage UnitTester
  327.  */
  328. class SimpleStackTrace {
  329.     var $_prefixes;
  330.  
  331.     /**
  332.      *    Stashes the list of target prefixes.
  333.      *    @param array $prefixes      List of method prefixes
  334.      *                                 to search for.
  335.      */
  336.     function SimpleStackTrace($prefixes) {
  337.         $this->_prefixes = $prefixes;
  338.     }
  339.  
  340.     /**
  341.      *    Extracts the last method name that was not within
  342.      *    Simpletest itself. Captures a stack trace if none given.
  343.      *    @param array $stack      List of stack frames.
  344.      *    @return string           Snippet of test report with line
  345.      *                              number and file.
  346.      *    @access public
  347.      */
  348.     function traceMethod($stack = false) {
  349.         $stack = $stack ? $stack : $this->_captureTrace();
  350.         foreach ($stack as $frame) {
  351.             if ($this->_frameLiesWithinSimpleTestFolder($frame)) {
  352.                 continue;
  353.             }
  354.             if ($this->_frameMatchesPrefix($frame)) {
  355.                 return ' at [' . $frame['file'] . ' line ' . $frame['line'] . ']';
  356.             }
  357.         }
  358.         return '';
  359.     }
  360.  
  361.     /**
  362.      *    Test to see if error is generated by SimpleTest itself.
  363.      *    @param array $frame     PHP stack frame.
  364.      *    @return boolean         True if a SimpleTest file.
  365.      *    @access private
  366.      */
  367.     function _frameLiesWithinSimpleTestFolder($frame) {
  368.         if (isset($frame['file'])) {
  369.             $path = substr(SIMPLE_TEST, 0, -1);
  370.             if (strpos($frame['file'], $path) === 0) {
  371.                 if (dirname($frame['file']) == $path) {
  372.                     return true;
  373.                 }
  374.             }
  375.         }
  376.         return false;
  377.     }
  378.  
  379.     /**
  380.      *    Tries to determine if the method call is an assert, etc.
  381.      *    @param array $frame     PHP stack frame.
  382.      *    @return boolean         True if matches a target.
  383.      *    @access private
  384.      */
  385.     function _frameMatchesPrefix($frame) {
  386.         foreach ($this->_prefixes as $prefix) {
  387.             if (strncmp($frame['function'], $prefix, strlen($prefix)) == 0) {
  388.                 return true;
  389.             }
  390.         }
  391.         return false;
  392.     }
  393.  
  394.     /**
  395.      *    Grabs a current stack trace.
  396.      *    @return array        Fulle trace.
  397.      *    @access private
  398.      */
  399.     function _captureTrace() {
  400.         if (function_exists('debug_backtrace')) {
  401.             return array_reverse(debug_backtrace());
  402.         }
  403.         return array();
  404.     }
  405. }
  406.  
  407. /**
  408.  *    @package SimpleTest
  409.  *    @subpackage UnitTester
  410.  *    @deprecated
  411.  */
  412. class SimpleTestOptions extends SimpleTest {
  413.  
  414.     /**
  415.      *    @deprecated
  416.      */
  417.     function getVersion() {
  418.         return Simpletest::getVersion();
  419.     }
  420.  
  421.     /**
  422.      *    @deprecated
  423.      */
  424.     function ignore($class) {
  425.         return Simpletest::ignore($class);
  426.     }
  427.  
  428.     /**
  429.      *    @deprecated
  430.      */
  431.     function isIgnored($class) {
  432.         return Simpletest::isIgnored($class);
  433.     }
  434.  
  435.     /**
  436.      *    @deprecated
  437.      */
  438.     function setMockBaseClass($mock_base) {
  439.         return Simpletest::setMockBaseClass($mock_base);
  440.     }
  441.  
  442.     /**
  443.      *    @deprecated
  444.      */
  445.     function getMockBaseClass() {
  446.         return Simpletest::getMockBaseClass();
  447.     }
  448.  
  449.     /**
  450.      *    @deprecated
  451.      */
  452.     function useProxy($proxy, $username = false, $password = false) {
  453.         return Simpletest::useProxy($proxy, $username, $password);
  454.     }
  455.  
  456.     /**
  457.      *    @deprecated
  458.      */
  459.     function getDefaultProxy() {
  460.         return Simpletest::getDefaultProxy();
  461.     }
  462.  
  463.     /**
  464.      *    @deprecated
  465.      */
  466.     function getDefaultProxyUsername() {
  467.         return Simpletest::getDefaultProxyUsername();
  468.     }
  469.  
  470.     /**
  471.      *    @deprecated
  472.      */
  473.     function getDefaultProxyPassword() {
  474.         return Simpletest::getDefaultProxyPassword();
  475.     }
  476. }
  477. ?>

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