Source for file errors.php

Documentation is available at errors.php

  1. <?php
  2. /**
  3.  *  base include file for SimpleTest
  4.  *  @package    SimpleTest
  5.  *  @subpackage UnitTester
  6.  *  @version    $Id: errors.php 1672 2008-03-02 04:47:34Z edwardzyang $
  7.  */
  8.  
  9. /**
  10.  * @ignore - PHP5 compatibility fix.
  11.  */
  12. if (! defined('E_STRICT')) {
  13.     define('E_STRICT', 2048);
  14. }
  15.  
  16. /**#@+
  17.  * Includes SimpleTest files.
  18.  */
  19. require_once dirname(__FILE__) . '/invoker.php';
  20. require_once dirname(__FILE__) . '/test_case.php';
  21. require_once dirname(__FILE__) . '/expectation.php';
  22. /**#@-*/
  23.  
  24.  *    Extension that traps errors into an error queue.
  25.  *    @package SimpleTest
  26.  *    @subpackage UnitTester
  27.  */
  28. class SimpleErrorTrappingInvoker extends SimpleInvokerDecorator {
  29.  
  30.     /**
  31.      *    Stores the invoker to wrap.
  32.      *    @param SimpleInvoker $invoker  Test method runner.
  33.      */
  34.     function SimpleErrorTrappingInvoker(&$invoker) {
  35.         $this->SimpleInvokerDecorator($invoker);
  36.     }
  37.  
  38.     /**
  39.      *    Invokes a test method and dispatches any
  40.      *    untrapped errors. Called back from
  41.      *    the visiting runner.
  42.      *    @param string $method    Test method to call.
  43.      *    @access public
  44.      */
  45.     function invoke($method) {
  46.         $queue = &$this->_createErrorQueue();
  47.         set_error_handler('SimpleTestErrorHandler');
  48.         parent::invoke($method);
  49.         restore_error_handler();
  50.         $queue->tally();
  51.     }
  52.     
  53.     /**
  54.      *    Wires up the error queue for a single test.
  55.      *    @return SimpleErrorQueue    Queue connected to the test.
  56.      *    @access private
  57.      */
  58.     function &_createErrorQueue() {
  59.         $context = &SimpleTest::getContext();
  60.         $test = &$this->getTestCase();
  61.         $queue = &$context->get('SimpleErrorQueue');
  62.         $queue->setTestCase($test);
  63.         return $queue;
  64.     }
  65. }
  66.  
  67. /**
  68.  *    Error queue used to record trapped
  69.  *    errors.
  70.  *    @package  SimpleTest
  71.  *    @subpackage   UnitTester
  72.  */
  73. class SimpleErrorQueue {
  74.     var $_queue;
  75.     var $_expectation_queue;
  76.     var $_test;
  77.     var $_using_expect_style = false;
  78.  
  79.     /**
  80.      *    Starts with an empty queue.
  81.      */
  82.     function SimpleErrorQueue() {
  83.         $this->clear();
  84.     }
  85.  
  86.     /**
  87.      *    Discards the contents of the error queue.
  88.      *    @access public
  89.      */
  90.     function clear() {
  91.         $this->_queue = array();
  92.         $this->_expectation_queue = array();
  93.     }
  94.  
  95.     /**
  96.      *    Sets the currently running test case.
  97.      *    @param SimpleTestCase $test    Test case to send messages to.
  98.      *    @access public
  99.      */
  100.     function setTestCase(&$test) {
  101.         $this->_test = &$test;
  102.     }
  103.  
  104.     /**
  105.      *    Sets up an expectation of an error. If this is
  106.      *    not fulfilled at the end of the test, a failure
  107.      *    will occour. If the error does happen, then this
  108.      *    will cancel it out and send a pass message.
  109.      *    @param SimpleExpectation $expected    Expected error match.
  110.      *    @param string $message                Message to display.
  111.      *    @access public
  112.      */
  113.     function expectError($expected, $message) {
  114.         $this->_using_expect_style = true;
  115.         array_push($this->_expectation_queue, array($expected, $message));
  116.     }
  117.  
  118.     /**
  119.      *    Adds an error to the front of the queue.
  120.      *    @param integer $severity       PHP error code.
  121.      *    @param string $content         Text of error.
  122.      *    @param string $filename        File error occoured in.
  123.      *    @param integer $line           Line number of error.
  124.      *    @access public
  125.      */
  126.     function add($severity, $content, $filename, $line) {
  127.         $content = str_replace('%', '%%', $content);
  128.         if ($this->_using_expect_style) {
  129.             $this->_testLatestError($severity, $content, $filename, $line);
  130.         } else {
  131.             array_push(
  132.                     $this->_queue,
  133.                     array($severity, $content, $filename, $line));
  134.         }
  135.     }
  136.     
  137.     /**
  138.      *    Any errors still in the queue are sent to the test
  139.      *    case. Any unfulfilled expectations trigger failures.
  140.      *    @access public
  141.      */
  142.     function tally() {
  143.         while (list($severity, $message, $file, $line) = $this->extract()) {
  144.             $severity = $this->getSeverityAsString($severity);
  145.             $this->_test->error($severity, $message, $file, $line);
  146.         }
  147.         while (list($expected, $message) = $this->_extractExpectation()) {
  148.             $this->_test->assert($expected, false, "%s -> Expected error not caught");
  149.         }
  150.     }
  151.  
  152.     /**
  153.      *    Tests the error against the most recent expected
  154.      *    error.
  155.      *    @param integer $severity       PHP error code.
  156.      *    @param string $content         Text of error.
  157.      *    @param string $filename        File error occoured in.
  158.      *    @param integer $line           Line number of error.
  159.      *    @access private
  160.      */
  161.     function _testLatestError($severity, $content, $filename, $line) {
  162.         if ($expectation = $this->_extractExpectation()) {
  163.             list($expected, $message) = $expectation;
  164.             $this->_test->assert($expected, $content, sprintf(
  165.                     $message,
  166.                     "%s -> PHP error [$content] severity [" .
  167.                             $this->getSeverityAsString($severity) .
  168.                             "] in [$filename] line [$line]"));
  169.         } else {
  170.             $this->_test->error($severity, $content, $filename, $line);
  171.         }
  172.     }
  173.  
  174.     /**
  175.      *    Pulls the earliest error from the queue.
  176.      *    @return  mixed    False if none, or a list of error
  177.      *                       information. Elements are: severity
  178.      *                       as the PHP error code, the error message,
  179.      *                       the file with the error, the line number
  180.      *                       and a list of PHP super global arrays.
  181.      *    @access public
  182.      */
  183.     function extract() {
  184.         if (count($this->_queue)) {
  185.             return array_shift($this->_queue);
  186.         }
  187.         return false;
  188.     }
  189.  
  190.     /**
  191.      *    Pulls the earliest expectation from the queue.
  192.      *    @return     SimpleExpectation    False if none.
  193.      *    @access private
  194.      */
  195.     function _extractExpectation() {
  196.         if (count($this->_expectation_queue)) {
  197.             return array_shift($this->_expectation_queue);
  198.         }
  199.         return false;
  200.     }
  201.  
  202.     /**
  203.      *    @deprecated
  204.      */
  205.     function assertNoErrors($message) {
  206.         return $this->_test->assert(
  207.                 new TrueExpectation(),
  208.                 count($this->_queue) == 0,
  209.                 sprintf($message, 'Should be no errors'));
  210.     }
  211.  
  212.     /**
  213.      *    @deprecated
  214.      */
  215.     function assertError($expected, $message) {
  216.         if (count($this->_queue) == 0) {
  217.             $this->_test->fail(sprintf($message, 'Expected error not found'));
  218.             return false;
  219.         }
  220.         list($severity, $content, $file, $line) = $this->extract();
  221.         $severity = $this->getSeverityAsString($severity);
  222.         return $this->_test->assert(
  223.                 $expected,
  224.                 $content,
  225.                 sprintf($message, "Expected PHP error [$content] severity [$severity] in [$file] line [$line]"));
  226.     }
  227.  
  228.     /**
  229.      *    Converts an error code into it's string
  230.      *    representation.
  231.      *    @param $severity  PHP integer error code.
  232.      *    @return           String version of error code.
  233.      *    @access public
  234.      *    @static
  235.      */
  236.     function getSeverityAsString($severity) {
  237.         static $map = array(
  238.                 E_STRICT => 'E_STRICT',
  239.                 E_ERROR => 'E_ERROR',
  240.                 E_WARNING => 'E_WARNING',
  241.                 E_PARSE => 'E_PARSE',
  242.                 E_NOTICE => 'E_NOTICE',
  243.                 E_CORE_ERROR => 'E_CORE_ERROR',
  244.                 E_CORE_WARNING => 'E_CORE_WARNING',
  245.                 E_COMPILE_ERROR => 'E_COMPILE_ERROR',
  246.                 E_COMPILE_WARNING => 'E_COMPILE_WARNING',
  247.                 E_USER_ERROR => 'E_USER_ERROR',
  248.                 E_USER_WARNING => 'E_USER_WARNING',
  249.                 E_USER_NOTICE => 'E_USER_NOTICE');
  250.         if (defined('E_RECOVERABLE_ERROR')) {
  251.             $map[E_RECOVERABLE_ERROR] = 'E_RECOVERABLE_ERROR';
  252.         }
  253.         if (defined('E_DEPRECATED')) {
  254.             $map[E_DEPRECATED] = 'E_DEPRECATED';
  255.         }
  256.         return $map[$severity];
  257.     }
  258. }
  259.  
  260. /**
  261.  *    Error handler that simply stashes any errors into the global
  262.  *    error queue. Simulates the existing behaviour with respect to
  263.  *    logging errors, but this feature may be removed in future.
  264.  *    @param $severity        PHP error code.
  265.  *    @param $message         Text of error.
  266.  *    @param $filename        File error occoured in.
  267.  *    @param $line            Line number of error.
  268.  *    @param $super_globals   Hash of PHP super global arrays.
  269.  *    @static
  270.  *    @access public
  271.  */
  272. function SimpleTestErrorHandler($severity, $message, $filename = null, $line = null, $super_globals = null, $mask = null) {
  273.     $severity = $severity & error_reporting();
  274.     if ($severity) {
  275.         restore_error_handler();
  276.         if (ini_get('log_errors')) {
  277.             $label = SimpleErrorQueue::getSeverityAsString($severity);
  278.             error_log("$label: $message in $filename on line $line");
  279.         }
  280.         $context = &SimpleTest::getContext();
  281.         $queue = &$context->get('SimpleErrorQueue');
  282.         $queue->add($severity, $message, $filename, $line);
  283.         set_error_handler('SimpleTestErrorHandler');
  284.     }
  285.     return true;
  286. }
  287. ?>

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