XMLDB/simpletest/errors.php
Chouchen 69b9eb42e2 More SQL command (drop table, drop database)
delete, select & insert upgraded 
More utility function (node to array, arrayToNode)
XMLDB special move command
PHP Unit Test
2010-10-11 14:03:38 +00:00

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;
}
?>