288 lines
9.2 KiB
PHP
288 lines
9.2 KiB
PHP
<?php
|
|
/**
|
|
* base include file for SimpleTest
|
|
* @package SimpleTest
|
|
* @subpackage UnitTester
|
|
* @version $Id: errors.php 1672 2008-03-02 04:47:34Z edwardzyang $
|
|
*/
|
|
|
|
/**
|
|
* @ignore - PHP5 compatibility fix.
|
|
*/
|
|
if (! defined('E_STRICT')) {
|
|
define('E_STRICT', 2048);
|
|
}
|
|
|
|
/**#@+
|
|
* Includes SimpleTest files.
|
|
*/
|
|
require_once dirname(__FILE__) . '/invoker.php';
|
|
require_once dirname(__FILE__) . '/test_case.php';
|
|
require_once dirname(__FILE__) . '/expectation.php';
|
|
/**#@-*/
|
|
|
|
/**
|
|
* Extension that traps errors into an error queue.
|
|
* @package SimpleTest
|
|
* @subpackage UnitTester
|
|
*/
|
|
class SimpleErrorTrappingInvoker extends SimpleInvokerDecorator {
|
|
|
|
/**
|
|
* Stores the invoker to wrap.
|
|
* @param SimpleInvoker $invoker Test method runner.
|
|
*/
|
|
function SimpleErrorTrappingInvoker(&$invoker) {
|
|
$this->SimpleInvokerDecorator($invoker);
|
|
}
|
|
|
|
/**
|
|
* Invokes a test method and dispatches any
|
|
* untrapped errors. Called back from
|
|
* the visiting runner.
|
|
* @param string $method Test method to call.
|
|
* @access public
|
|
*/
|
|
function invoke($method) {
|
|
$queue = &$this->_createErrorQueue();
|
|
set_error_handler('SimpleTestErrorHandler');
|
|
parent::invoke($method);
|
|
restore_error_handler();
|
|
$queue->tally();
|
|
}
|
|
|
|
/**
|
|
* Wires up the error queue for a single test.
|
|
* @return SimpleErrorQueue Queue connected to the test.
|
|
* @access private
|
|
*/
|
|
function &_createErrorQueue() {
|
|
$context = &SimpleTest::getContext();
|
|
$test = &$this->getTestCase();
|
|
$queue = &$context->get('SimpleErrorQueue');
|
|
$queue->setTestCase($test);
|
|
return $queue;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Error queue used to record trapped
|
|
* errors.
|
|
* @package SimpleTest
|
|
* @subpackage UnitTester
|
|
*/
|
|
class SimpleErrorQueue {
|
|
var $_queue;
|
|
var $_expectation_queue;
|
|
var $_test;
|
|
var $_using_expect_style = false;
|
|
|
|
/**
|
|
* Starts with an empty queue.
|
|
*/
|
|
function SimpleErrorQueue() {
|
|
$this->clear();
|
|
}
|
|
|
|
/**
|
|
* Discards the contents of the error queue.
|
|
* @access public
|
|
*/
|
|
function clear() {
|
|
$this->_queue = array();
|
|
$this->_expectation_queue = array();
|
|
}
|
|
|
|
/**
|
|
* Sets the currently running test case.
|
|
* @param SimpleTestCase $test Test case to send messages to.
|
|
* @access public
|
|
*/
|
|
function setTestCase(&$test) {
|
|
$this->_test = &$test;
|
|
}
|
|
|
|
/**
|
|
* Sets up an expectation of an error. If this is
|
|
* not fulfilled at the end of the test, a failure
|
|
* will occour. If the error does happen, then this
|
|
* will cancel it out and send a pass message.
|
|
* @param SimpleExpectation $expected Expected error match.
|
|
* @param string $message Message to display.
|
|
* @access public
|
|
*/
|
|
function expectError($expected, $message) {
|
|
$this->_using_expect_style = true;
|
|
array_push($this->_expectation_queue, array($expected, $message));
|
|
}
|
|
|
|
/**
|
|
* Adds an error to the front of the queue.
|
|
* @param integer $severity PHP error code.
|
|
* @param string $content Text of error.
|
|
* @param string $filename File error occoured in.
|
|
* @param integer $line Line number of error.
|
|
* @access public
|
|
*/
|
|
function add($severity, $content, $filename, $line) {
|
|
$content = str_replace('%', '%%', $content);
|
|
if ($this->_using_expect_style) {
|
|
$this->_testLatestError($severity, $content, $filename, $line);
|
|
} else {
|
|
array_push(
|
|
$this->_queue,
|
|
array($severity, $content, $filename, $line));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Any errors still in the queue are sent to the test
|
|
* case. Any unfulfilled expectations trigger failures.
|
|
* @access public
|
|
*/
|
|
function tally() {
|
|
while (list($severity, $message, $file, $line) = $this->extract()) {
|
|
$severity = $this->getSeverityAsString($severity);
|
|
$this->_test->error($severity, $message, $file, $line);
|
|
}
|
|
while (list($expected, $message) = $this->_extractExpectation()) {
|
|
$this->_test->assert($expected, false, "%s -> Expected error not caught");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests the error against the most recent expected
|
|
* error.
|
|
* @param integer $severity PHP error code.
|
|
* @param string $content Text of error.
|
|
* @param string $filename File error occoured in.
|
|
* @param integer $line Line number of error.
|
|
* @access private
|
|
*/
|
|
function _testLatestError($severity, $content, $filename, $line) {
|
|
if ($expectation = $this->_extractExpectation()) {
|
|
list($expected, $message) = $expectation;
|
|
$this->_test->assert($expected, $content, sprintf(
|
|
$message,
|
|
"%s -> PHP error [$content] severity [" .
|
|
$this->getSeverityAsString($severity) .
|
|
"] in [$filename] line [$line]"));
|
|
} else {
|
|
$this->_test->error($severity, $content, $filename, $line);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Pulls the earliest error from the queue.
|
|
* @return mixed False if none, or a list of error
|
|
* information. Elements are: severity
|
|
* as the PHP error code, the error message,
|
|
* the file with the error, the line number
|
|
* and a list of PHP super global arrays.
|
|
* @access public
|
|
*/
|
|
function extract() {
|
|
if (count($this->_queue)) {
|
|
return array_shift($this->_queue);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Pulls the earliest expectation from the queue.
|
|
* @return SimpleExpectation False if none.
|
|
* @access private
|
|
*/
|
|
function _extractExpectation() {
|
|
if (count($this->_expectation_queue)) {
|
|
return array_shift($this->_expectation_queue);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* @deprecated
|
|
*/
|
|
function assertNoErrors($message) {
|
|
return $this->_test->assert(
|
|
new TrueExpectation(),
|
|
count($this->_queue) == 0,
|
|
sprintf($message, 'Should be no errors'));
|
|
}
|
|
|
|
/**
|
|
* @deprecated
|
|
*/
|
|
function assertError($expected, $message) {
|
|
if (count($this->_queue) == 0) {
|
|
$this->_test->fail(sprintf($message, 'Expected error not found'));
|
|
return false;
|
|
}
|
|
list($severity, $content, $file, $line) = $this->extract();
|
|
$severity = $this->getSeverityAsString($severity);
|
|
return $this->_test->assert(
|
|
$expected,
|
|
$content,
|
|
sprintf($message, "Expected PHP error [$content] severity [$severity] in [$file] line [$line]"));
|
|
}
|
|
|
|
/**
|
|
* Converts an error code into it's string
|
|
* representation.
|
|
* @param $severity PHP integer error code.
|
|
* @return String version of error code.
|
|
* @access public
|
|
* @static
|
|
*/
|
|
function getSeverityAsString($severity) {
|
|
static $map = array(
|
|
E_STRICT => 'E_STRICT',
|
|
E_ERROR => 'E_ERROR',
|
|
E_WARNING => 'E_WARNING',
|
|
E_PARSE => 'E_PARSE',
|
|
E_NOTICE => 'E_NOTICE',
|
|
E_CORE_ERROR => 'E_CORE_ERROR',
|
|
E_CORE_WARNING => 'E_CORE_WARNING',
|
|
E_COMPILE_ERROR => 'E_COMPILE_ERROR',
|
|
E_COMPILE_WARNING => 'E_COMPILE_WARNING',
|
|
E_USER_ERROR => 'E_USER_ERROR',
|
|
E_USER_WARNING => 'E_USER_WARNING',
|
|
E_USER_NOTICE => 'E_USER_NOTICE');
|
|
if (defined('E_RECOVERABLE_ERROR')) {
|
|
$map[E_RECOVERABLE_ERROR] = 'E_RECOVERABLE_ERROR';
|
|
}
|
|
if (defined('E_DEPRECATED')) {
|
|
$map[E_DEPRECATED] = 'E_DEPRECATED';
|
|
}
|
|
return $map[$severity];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Error handler that simply stashes any errors into the global
|
|
* error queue. Simulates the existing behaviour with respect to
|
|
* logging errors, but this feature may be removed in future.
|
|
* @param $severity PHP error code.
|
|
* @param $message Text of error.
|
|
* @param $filename File error occoured in.
|
|
* @param $line Line number of error.
|
|
* @param $super_globals Hash of PHP super global arrays.
|
|
* @static
|
|
* @access public
|
|
*/
|
|
function SimpleTestErrorHandler($severity, $message, $filename = null, $line = null, $super_globals = null, $mask = null) {
|
|
$severity = $severity & error_reporting();
|
|
if ($severity) {
|
|
restore_error_handler();
|
|
if (ini_get('log_errors')) {
|
|
$label = SimpleErrorQueue::getSeverityAsString($severity);
|
|
error_log("$label: $message in $filename on line $line");
|
|
}
|
|
$context = &SimpleTest::getContext();
|
|
$queue = &$context->get('SimpleErrorQueue');
|
|
$queue->add($severity, $message, $filename, $line);
|
|
set_error_handler('SimpleTestErrorHandler');
|
|
}
|
|
return true;
|
|
}
|
|
?>
|