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

Documentation generated on Thu, 01 Oct 2009 20:54:44 -0500 by phpDocumentor 1.4.2