diff options
author | Greg Beaver <cellog@php.net> | 2004-03-19 00:48:39 +0000 |
---|---|---|
committer | Greg Beaver <cellog@php.net> | 2004-03-19 00:48:39 +0000 |
commit | 4180b972ae0e93b6f25734510a7050485c2b4e0c (patch) | |
tree | 80dea26171192153e46a96674dc0196a0871e42c /pear | |
parent | 0ba63371ed8b018f09a59475bddf1412d1cabdca (diff) | |
download | php-git-4180b972ae0e93b6f25734510a7050485c2b4e0c.tar.gz |
phpunit tests for PEAR_ErrorStack
Diffstat (limited to 'pear')
13 files changed, 2583 insertions, 0 deletions
diff --git a/pear/tests/PEAR_ErrorStack/Error_Stack_TestCase_getErrorMessage.php b/pear/tests/PEAR_ErrorStack/Error_Stack_TestCase_getErrorMessage.php new file mode 100644 index 0000000000..2f46b19bc9 --- /dev/null +++ b/pear/tests/PEAR_ErrorStack/Error_Stack_TestCase_getErrorMessage.php @@ -0,0 +1,142 @@ +<?php + +/** + * API Unit tests for PEAR_ErrorStack package. + * + * @version $Id$ + * @author Laurent Laville <pear@laurent-laville.org> portions from HTML_CSS + * @author Greg Beaver + * @package PEAR_ErrorStack + */ + +class testgemessage +{ + function __toString() + { + return '__toString() called'; + } +} +class testgemessage1 {} +/** + * @package PEAR_ErrorStack + */ + +class PEAR_ErrorStack_TestCase_getErrorMessage extends PHPUnit_TestCase +{ + + function PEAR_ErrorStack_TestCase_getErrorMessage($name) + { + $this->PHPUnit_TestCase($name); + } + + function setUp() + { + error_reporting(E_ALL); + $this->errorOccured = false; + set_error_handler(array(&$this, 'errorHandler')); + $this->stack = new PEAR_ErrorStack('test'); + $s = &PEAR_ErrorStack::singleton('PEAR_ErrorStack'); + $s->pushCallback(array('PEAR_ErrorStack', '_handleError')); + } + + function tearDown() + { + unset($this->stack); + unset($GLOBALS['_PEAR_ERRORSTACK_SINGLETON']); + } + + + function _stripWhitespace($str) + { + return preg_replace('/\\s+/', '', $str); + } + + function _methodExists($name) + { + if (in_array(strtolower($name), get_class_methods($this->stack))) { + return true; + } + $this->assertTrue(false, 'method '. $name . ' not implemented in ' . get_class($this->stack)); + return false; + } + + function errorHandler($errno, $errstr, $errfile, $errline) { + //die("$errstr in $errfile at line $errline: $errstr"); + $this->errorOccured = true; + $this->assertTrue(false, "$errstr at line $errline, $errfile"); + } + + function returnsignore($err) + { + $this->wasCalled = true; + return PEAR_ERRORSTACK_IGNORE; + } + + function test_basic() + { + if (!$this->_methodExists('getErrorMessage')) { + return; + } + $msg = PEAR_ErrorStack::getErrorMessage($this->stack, + array('message' => 'boo', 'params' => array(), 'code' => 6)); + $this->assertEquals('boo', $msg); + } + + function test_basic_template() + { + if (!$this->_methodExists('getErrorMessage')) { + return; + } + $msg = PEAR_ErrorStack::getErrorMessage($this->stack, + array('message' => 'boo', 'params' => array()), 'far%__msg%'); + $this->assertEquals('farboo', $msg); + } + + function test_basic_params() + { + if (!$this->_methodExists('getErrorMessage')) { + return; + } + $msg = PEAR_ErrorStack::getErrorMessage($this->stack, array('message' => '', + 'params' => array('bar' => 'hello')), '%bar% foo'); + $this->assertEquals('hello foo', $msg, 'string'); + $msg = PEAR_ErrorStack::getErrorMessage($this->stack, array('message' => '', + 'params' => array('bar' => array('hello', 'there'))), '%bar% foo'); + $this->assertEquals('hello, there foo', $msg, 'array'); + $msg = PEAR_ErrorStack::getErrorMessage($this->stack, array('message' => '', + 'params' => array('bar' => new testgemessage)), '%bar% foo'); + $this->assertEquals('__toString() called foo', $msg, 'first object, __toString()'); + $msg = PEAR_ErrorStack::getErrorMessage($this->stack, array('message' => '', + 'params' => array('bar' => new testgemessage1)), '%bar% foo'); + $this->assertEquals('Object foo', $msg, 'second object, no __toString()'); + $errs = PEAR_ErrorStack::staticGetErrors(); + unset($errs['PEAR_ErrorStack'][0]['context']); + unset($errs['PEAR_ErrorStack'][0]['time']); + $this->assertEquals( + array('PEAR_ErrorStack' => + array( + array( + 'code' => PEAR_ERRORSTACK_ERR_OBJTOSTRING, + 'params' => array('obj' => 'testgemessage1'), + 'package' => 'PEAR_ErrorStack', + 'level' => 'warning', + 'message' => 'object testgemessage1 passed into getErrorMessage, but has no __toString() method', + ))), $errs, 'warning not raised'); + } + + function test_basic_params_with_template() + { + if (!$this->_methodExists('getErrorMessage')) { + return; + } + $this->stack->setErrorMessageTemplate(array(6 => '%bar% foo')); + $msg = PEAR_ErrorStack::getErrorMessage($this->stack, array('message' => '', + 'params' => array('bar' => 'hello'), 'code' => 6)); + $this->assertEquals('hello foo', $msg, 'string'); + $msg = PEAR_ErrorStack::getErrorMessage($this->stack, array('message' => '', + 'params' => array('bar' => 'hello'), 'code' => 7)); + $this->assertEquals('', $msg, 'string'); + } +} + +?> diff --git a/pear/tests/PEAR_ErrorStack/Error_Stack_TestCase_getErrorMessageTemplate.php b/pear/tests/PEAR_ErrorStack/Error_Stack_TestCase_getErrorMessageTemplate.php new file mode 100644 index 0000000000..36270d6e9f --- /dev/null +++ b/pear/tests/PEAR_ErrorStack/Error_Stack_TestCase_getErrorMessageTemplate.php @@ -0,0 +1,88 @@ +<?php + +/** + * API Unit tests for PEAR_ErrorStack package. + * + * @version $Id$ + * @author Laurent Laville <pear@laurent-laville.org> portions from HTML_CSS + * @author Greg Beaver + * @package PEAR_ErrorStack + */ + +/** + * @package PEAR_ErrorStack + */ + +class PEAR_ErrorStack_TestCase_getErrorMessageTemplate extends PHPUnit_TestCase +{ + + function PEAR_ErrorStack_TestCase_getErrorMessageTemplate($name) + { + $this->PHPUnit_TestCase($name); + } + + function setUp() + { + error_reporting(E_ALL); + $this->errorOccured = false; + set_error_handler(array(&$this, 'errorHandler')); + $this->stack = new PEAR_ErrorStack('test'); + $s = &PEAR_ErrorStack::singleton('PEAR_ErrorStack'); + $s->pushCallback(array('PEAR_ErrorStack', '_handleError')); + } + + function tearDown() + { + unset($this->stack); + unset($GLOBALS['_PEAR_ERRORSTACK_SINGLETON']); + } + + + function _stripWhitespace($str) + { + return preg_replace('/\\s+/', '', $str); + } + + function _methodExists($name) + { + if (in_array(strtolower($name), get_class_methods($this->stack))) { + return true; + } + $this->assertTrue(false, 'method '. $name . ' not implemented in ' . get_class($this->stack)); + return false; + } + + function errorHandler($errno, $errstr, $errfile, $errline) { + //die("$errstr in $errfile at line $errline: $errstr"); + $this->errorOccured = true; + $this->assertTrue(false, "$errstr at line $errline, $errfile"); + } + + function returnsignore($err) + { + $this->wasCalled = true; + return PEAR_ERRORSTACK_IGNORE; + } + + function test_normal() + { + if (!$this->_methodExists('getErrorMessageTemplate')) { + return; + } + $this->assertEquals('%__msg%', $this->stack->getErrorMessageTemplate(23)); + } + + function test_normal_hascode() + { + if (!$this->_methodExists('getErrorMessageTemplate')) { + return; + } + if (!$this->_methodExists('setErrorMessageTemplate')) { + return; + } + $this->stack->setErrorMessageTemplate(array(23 => '%foo% has %__msg%')); + $this->assertEquals('%foo% has %__msg%', $this->stack->getErrorMessageTemplate(23)); + } +} + +?> diff --git a/pear/tests/PEAR_ErrorStack/Error_Stack_TestCase_getErrors.php b/pear/tests/PEAR_ErrorStack/Error_Stack_TestCase_getErrors.php new file mode 100644 index 0000000000..e2a986e679 --- /dev/null +++ b/pear/tests/PEAR_ErrorStack/Error_Stack_TestCase_getErrors.php @@ -0,0 +1,135 @@ +<?php + +/** + * API Unit tests for PEAR_ErrorStack package. + * + * @version $Id$ + * @author Laurent Laville <pear@laurent-laville.org> portions from HTML_CSS + * @author Greg Beaver + * @package PEAR_ErrorStack + */ + +/** + * @package PEAR_ErrorStack + */ + +class PEAR_ErrorStack_TestCase_getErrors extends PHPUnit_TestCase +{ + + function PEAR_ErrorStack_TestCase_getErrors($name) + { + $this->PHPUnit_TestCase($name); + } + + function setUp() + { + error_reporting(E_ALL); + $this->errorOccured = false; + set_error_handler(array(&$this, 'errorHandler')); + $this->stack = new PEAR_ErrorStack('test'); + $s = &PEAR_ErrorStack::singleton('PEAR_ErrorStack'); + $s->pushCallback(array('PEAR_ErrorStack', '_handleError')); + } + + function tearDown() + { + unset($this->stack); + unset($GLOBALS['_PEAR_ERRORSTACK_SINGLETON']); + } + + + function _stripWhitespace($str) + { + return preg_replace('/\\s+/', '', $str); + } + + function _methodExists($name) + { + if (in_array(strtolower($name), get_class_methods($this->stack))) { + return true; + } + $this->assertTrue(false, 'method '. $name . ' not implemented in ' . get_class($this->stack)); + return false; + } + + function errorHandler($errno, $errstr, $errfile, $errline) { + //die("$errstr in $errfile at line $errline: $errstr"); + $this->errorOccured = true; + $this->assertTrue(false, "$errstr at line $errline, $errfile"); + } + + function returnsignore($err) + { + $this->wasCalled = true; + return PEAR_ERRORSTACK_IGNORE; + } + + function test_none() + { + if (!$this->_methodExists('getErrors')) { + return; + } + $this->assertEquals(array(), $this->stack->getErrors()); + $this->assertEquals(array(), $this->stack->getErrors(true)); + } + + function test_normal() + { + if (!$this->_methodExists('getErrors')) { + return; + } + $this->assertEquals(array(), $this->stack->getErrors()); + $this->stack->push(1); + $this->stack->push(2, 'warning'); + $this->stack->push(3, 'foo'); + $ret = $this->stack->getErrors(); + for ($i= 0; $i < 3; $i++) { + unset($ret[$i]['time']); + unset($ret[$i]['context']); + } + $this->assertEquals( + array( + array('code' => 3, + 'params' => array(), + 'package' => 'test', + 'level' => 'foo', + 'message' => ''), + array('code' => 2, + 'params' => array(), + 'package' => 'test', + 'level' => 'warning', + 'message' => ''), + array('code' => 1, + 'params' => array(), + 'package' => 'test', + 'level' => 'error', + 'message' => ''), + ), $ret, 'incorrect errors, non-purge'); + $ret = $this->stack->getErrors(true); + for ($i= 0; $i < 3; $i++) { + unset($ret[$i]['time']); + unset($ret[$i]['context']); + } + $this->assertEquals( + array( + array('code' => 3, + 'params' => array(), + 'package' => 'test', + 'level' => 'foo', + 'message' => ''), + array('code' => 2, + 'params' => array(), + 'package' => 'test', + 'level' => 'warning', + 'message' => ''), + array('code' => 1, + 'params' => array(), + 'package' => 'test', + 'level' => 'error', + 'message' => ''), + ), $ret, 'incorrect errors, purge'); + $this->assertEquals(array(), $this->stack->getErrors()); + } +} + +?> diff --git a/pear/tests/PEAR_ErrorStack/Error_Stack_TestCase_pushpop.php b/pear/tests/PEAR_ErrorStack/Error_Stack_TestCase_pushpop.php new file mode 100644 index 0000000000..ec7eb8399a --- /dev/null +++ b/pear/tests/PEAR_ErrorStack/Error_Stack_TestCase_pushpop.php @@ -0,0 +1,367 @@ +<?php + +/** + * API Unit tests for PEAR_ErrorStack package. + * + * @version $Id$ + * @author Laurent Laville <pear@laurent-laville.org> portions from HTML_CSS + * @author Greg Beaver + * @package PEAR_ErrorStack + */ + +/** + * @package PEAR_ErrorStack + */ + +class PEAR_ErrorStack_TestCase_pushpop extends PHPUnit_TestCase +{ + /** + * A PEAR_PackageFileManager object + * @var object + */ + var $packagexml; + + function PEAR_ErrorStack_TestCase_pushpop($name) + { + $this->PHPUnit_TestCase($name); + } + + function setUp() + { + error_reporting(E_ALL); + $this->errorOccured = false; + set_error_handler(array(&$this, 'errorHandler')); + $this->stack = new PEAR_ErrorStack('test'); + $s = &PEAR_ErrorStack::singleton('PEAR_ErrorStack'); + $s->pushCallback(array('PEAR_ErrorStack', '_handleError')); + } + + function tearDown() + { + unset($this->stack); + unset($GLOBALS['_PEAR_ERRORSTACK_SINGLETON']); + } + + + function _stripWhitespace($str) + { + return preg_replace('/\\s+/', '', $str); + } + + function _methodExists($name) + { + if (in_array(strtolower($name), get_class_methods($this->stack))) { + return true; + } + $this->assertTrue(false, 'method '. $name . ' not implemented in ' . get_class($this->stack)); + return false; + } + + function errorHandler($errno, $errstr, $errfile, $errline) { + //die("$errstr in $errfile at line $errline: $errstr"); + $this->errorOccured = true; + $this->assertTrue(false, "$errstr at line $errline, $errfile"); + } + + function test_valid_basic() + { + if (!$this->_methodExists('push')) { + return; + } + if (!$this->_methodExists('pop')) { + return; + } + $this->stack->push(1); + $err = $this->stack->pop(); + unset($err['context']); + unset($err['time']); + $this->assertEquals( + array( + 'code' => 1, + 'params' => array(), + 'package' => 'test', + 'message' => '', + 'level' => 'error', + ), + $err, 'popped something else' + ); + $err = $this->stack->pop(); + $this->assertFalse($err, 'stack not empty!'); + } + + function test_valid_params() + { + if (!$this->_methodExists('push')) { + return; + } + if (!$this->_methodExists('pop')) { + return; + } + $z = $this->stack->push(2, 'exception', array('my' => 'param'), 'hello', + array('test'), array(array('file' => 'boof', 'line' => 34))); + $err = $this->stack->pop('exception'); + $this->assertEquals($z, $err, 'popped different error'); + unset($err['time']); + $this->assertEquals( + array( + 'code' => 2, + 'params' => array('my' => 'param'), + 'package' => 'test', + 'message' => 'hello', + 'level' => 'exception', + 'context' => + array( + 'file' => 'boof', + 'line' => 34, + ), + 'repackage' => array('test'), + ), + $err, 'popped something else' + ); + $err = $this->stack->pop(); + $this->assertFalse($err, 'stack not empty!'); + } + + function test_valid_paramscompat() + { + if (!$this->_methodExists('push')) { + return; + } + if (!$this->_methodExists('pop')) { + return; + } + $this->stack = new PEAR_ErrorStack('test', false, null, true); + $z = $this->stack->push(2, 'exception', array('my' => 'param'), 'hello', + array('test'), array(array('file' => 'boof', 'line' => 34))); + $this->assertEquals('pear_error', strtolower(get_class($z)), 'not pear_error'); + $err = $this->stack->pop('exception'); + if (is_a($z, 'PEAR_Error')) { + $this->assertEquals($err, $z->getUserInfo(), 'userinfo wrong'); + } + unset($err['time']); + $this->assertEquals( + array( + 'code' => 2, + 'params' => array('my' => 'param'), + 'package' => 'test', + 'message' => 'hello', + 'level' => 'exception', + 'context' => + array( + 'file' => 'boof', + 'line' => 34, + ), + 'repackage' => array('test'), + ), + $err, 'popped something else' + ); + $err = $this->stack->pop(); + $this->assertFalse($err, 'stack not empty!'); + } + + function contextcallback($code, $params, $trace) + { + $this->assertEquals(4, $code, 'wrong context code'); + $this->assertEquals(array('hello' => 6), $params, 'wrong context params'); + $this->wasCalled = true; + return array('hi' => 'there', 'you' => 'fool'); + } + + function test_valid_contextconstructor() + { + if (!$this->_methodExists('push')) { + return; + } + if (!$this->_methodExists('pop')) { + return; + } + $this->stack = new PEAR_ErrorStack('test', false, array(&$this, 'contextcallback')); + $this->wasCalled = false; + $this->stack->push(4, 'error', array('hello' => 6)); + $this->assertTrue($this->wasCalled, 'context callback was not called!'); + $err = $this->stack->pop(); + unset($err['time']); + $this->assertEquals( + array( + 'code' => 4, + 'params' => array('hello' => 6), + 'package' => 'test', + 'message' => '', + 'level' => 'error', + 'context' => array('hi' => 'there', 'you' => 'fool'), + ), + $err, 'popped something else' + ); + $err = $this->stack->pop(); + $this->assertFalse($err, 'stack not empty!'); + } + + function test_valid_contextsingleton() + { + if (!$this->_methodExists('push')) { + return; + } + if (!$this->_methodExists('pop')) { + return; + } + if (!$this->_methodExists('singleton')) { + return; + } + $this->stack = &PEAR_ErrorStack::singleton('test', false, array(&$this, 'contextcallback')); + $this->wasCalled = false; + $this->stack->push(4, 'error', array('hello' => 6)); + $this->assertTrue($this->wasCalled, 'context callback was not called!'); + $err = $this->stack->pop(); + unset($err['time']); + $this->assertEquals( + array( + 'code' => 4, + 'params' => array('hello' => 6), + 'package' => 'test', + 'message' => '', + 'level' => 'error', + 'context' => array('hi' => 'there', 'you' => 'fool'), + ), + $err, 'popped something else' + ); + $err = $this->stack->pop(); + $this->assertFalse($err, 'stack not empty!'); + } + + function test_valid_context_setcontext() + { + if (!$this->_methodExists('push')) { + return; + } + if (!$this->_methodExists('pop')) { + return; + } + if (!$this->_methodExists('setContextCallback')) { + return; + } + $this->stack->setContextCallback(array(&$this, 'contextcallback')); + $this->wasCalled = false; + $this->stack->push(4, 'error', array('hello' => 6)); + $this->assertTrue($this->wasCalled, 'context callback was not called!'); + $err = $this->stack->pop(); + unset($err['time']); + $this->assertEquals( + array( + 'code' => 4, + 'params' => array('hello' => 6), + 'package' => 'test', + 'message' => '', + 'level' => 'error', + 'context' => array('hi' => 'there', 'you' => 'fool'), + ), + $err, 'popped something else' + ); + $err = $this->stack->pop(); + $this->assertFalse($err, 'stack not empty!'); + } + + function messagecallback(&$stack, $err) + { + $this->assertEquals(4, $err['code'], 'wrong message code'); + $this->assertEquals(array('hello' => 6), $err['params'], 'wrong message params'); + $this->assertEquals('test1', $err['package'], 'wrong error stack'); + $this->wasCalled = true; + return 'my silly message'; + } + + function test_valid_msgcallbackconstructor() + { + if (!$this->_methodExists('push')) { + return; + } + if (!$this->_methodExists('pop')) { + return; + } + $this->stack = new PEAR_ErrorStack('test1', array(&$this, 'messagecallback')); + $this->wasCalled = false; + $this->stack->push(4, 'error', array('hello' => 6)); + $this->assertTrue($this->wasCalled, 'message callback was not called!'); + $err = $this->stack->pop(); + unset($err['time']); + unset($err['context']); + $this->assertEquals( + array( + 'code' => 4, + 'params' => array('hello' => 6), + 'package' => 'test1', + 'message' => 'my silly message', + 'level' => 'error', + ), + $err, 'popped something else' + ); + $err = $this->stack->pop(); + $this->assertFalse($err, 'stack not empty!'); + } + + function test_valid_msgcallbacksingleton() + { + if (!$this->_methodExists('push')) { + return; + } + if (!$this->_methodExists('pop')) { + return; + } + if (!$this->_methodExists('singleton')) { + return; + } + $this->stack = &PEAR_ErrorStack::singleton('test1', array(&$this, 'messagecallback')); + $this->wasCalled = false; + $this->stack->push(4, 'error', array('hello' => 6)); + $this->assertTrue($this->wasCalled, 'message callback was not called!'); + $err = $this->stack->pop(); + unset($err['time']); + unset($err['context']); + $this->assertEquals( + array( + 'code' => 4, + 'params' => array('hello' => 6), + 'package' => 'test1', + 'message' => 'my silly message', + 'level' => 'error', + ), + $err, 'popped something else' + ); + $err = $this->stack->pop(); + $this->assertFalse($err, 'stack not empty!'); + } + + function test_valid_msgcallback_setmsgcallback() + { + if (!$this->_methodExists('push')) { + return; + } + if (!$this->_methodExists('pop')) { + return; + } + if (!$this->_methodExists('setContextCallback')) { + return; + } + $this->stack = new PEAR_ErrorStack('test1'); + $this->stack->setMessageCallback(array(&$this, 'messagecallback')); + $this->wasCalled = false; + $this->stack->push(4, 'error', array('hello' => 6)); + $this->assertTrue($this->wasCalled, 'message callback was not called!'); + $err = $this->stack->pop(); + unset($err['time']); + unset($err['context']); + $this->assertEquals( + array( + 'code' => 4, + 'params' => array('hello' => 6), + 'package' => 'test1', + 'message' => 'my silly message', + 'level' => 'error', + ), + $err, 'popped something else' + ); + $err = $this->stack->pop(); + $this->assertFalse($err, 'stack not empty!'); + } +} + +?> diff --git a/pear/tests/PEAR_ErrorStack/Error_Stack_TestCase_pushpopcallback.php b/pear/tests/PEAR_ErrorStack/Error_Stack_TestCase_pushpopcallback.php new file mode 100644 index 0000000000..3838ae309d --- /dev/null +++ b/pear/tests/PEAR_ErrorStack/Error_Stack_TestCase_pushpopcallback.php @@ -0,0 +1,320 @@ +<?php + +/** + * API Unit tests for PEAR_ErrorStack package. + * + * @version $Id$ + * @author Laurent Laville <pear@laurent-laville.org> portions from HTML_CSS + * @author Greg Beaver + * @package PEAR_ErrorStack + */ + +/** + * @package PEAR_ErrorStack + */ + +class PEAR_ErrorStack_TestCase_pushpopcallback extends PHPUnit_TestCase +{ + /** + * A PEAR_PackageFileManager object + * @var object + */ + var $packagexml; + + function PEAR_ErrorStack_TestCase_pushpopcallback($name) + { + $this->PHPUnit_TestCase($name); + } + + function setUp() + { + error_reporting(E_ALL); + $this->errorOccured = false; + set_error_handler(array(&$this, 'errorHandler')); + $this->stack = new PEAR_ErrorStack('test'); + } + + function tearDown() + { + unset($this->stack); + unset($GLOBALS['_PEAR_ERRORSTACK_SINGLETON']); + } + + + function _stripWhitespace($str) + { + return preg_replace('/\\s+/', '', $str); + } + + function _methodExists($name) + { + if (in_array(strtolower($name), get_class_methods($this->stack))) { + return true; + } + $this->assertTrue(false, 'method '. $name . ' not implemented in ' . get_class($this->stack)); + return false; + } + + function errorHandler($errno, $errstr, $errfile, $errline) { + //die("$errstr in $errfile at line $errline: $errstr"); + $this->errorOccured = true; + $this->assertTrue(false, "$errstr at line $errline, $errfile"); + } + + function returnsignore($err) + { + $this->wasCalled = true; + return PEAR_ERRORSTACK_IGNORE; + } + + function test_return_ignore() + { + if (!$this->_methodExists('push')) { + return; + } + if (!$this->_methodExists('pop')) { + return; + } + if (!$this->_methodExists('pushCallback')) { + return; + } + if (!$this->_methodExists('popCallback')) { + return; + } + $this->stack->pushCallback(array(&$this, 'returnsignore')); + $this->wasCalled = false; + $this->stack->push(1); + $this->assertTrue($this->wasCalled, 'returnsignore not called'); + $err = $this->stack->pop(); + $this->assertFalse($err, 'error was not ignored!'); + $this->stack->popCallback(); + $this->wasCalled = false; + $this->stack->push(1); + $this->assertFalse($this->wasCalled, 'returnsignore called'); + $err = $this->stack->pop(); + unset($err['context']); + unset($err['time']); + $this->assertEquals( + array( + 'code' => 1, + 'params' => array(), + 'package' => 'test', + 'message' => '', + 'level' => 'error', + ), + $err, 'popped something else' + ); + + $err = $this->stack->pop(); + $this->assertFalse($err, 'stack not empty!'); + } + + function returnsnothing($err) + { + $this->wasCalled = true; + } + + function test_return_nothing() + { + if (!$this->_methodExists('push')) { + return; + } + if (!$this->_methodExists('pop')) { + return; + } + if (!$this->_methodExists('pushCallback')) { + return; + } + if (!$this->_methodExists('popCallback')) { + return; + } + $this->stack->pushCallback(array(&$this, 'returnsnothing')); + $this->wasCalled = false; + $this->stack->push(1); + $this->assertTrue($this->wasCalled, 'returnsnothing not called'); + $err = $this->stack->pop(); + unset($err['context']); + unset($err['time']); + $this->assertEquals( + array( + 'code' => 1, + 'params' => array(), + 'package' => 'test', + 'message' => '', + 'level' => 'error', + ), + $err, 'popped something else' + ); + $this->stack->popCallback(); + $this->wasCalled = false; + $this->stack->push(1); + $this->assertFalse($this->wasCalled, 'returnsnothing called'); + $err = $this->stack->pop(); + unset($err['context']); + unset($err['time']); + $this->assertEquals( + array( + 'code' => 1, + 'params' => array(), + 'package' => 'test', + 'message' => '', + 'level' => 'error', + ), + $err, 'popped something else' + ); + + $err = $this->stack->pop(); + $this->assertFalse($err, 'stack not empty!'); + } + + function returnspush($err) + { + $this->wasCalled = true; + return PEAR_ERRORSTACK_PUSH; + } + + function test_return_push() + { + if (!$this->_methodExists('push')) { + return; + } + if (!$this->_methodExists('pop')) { + return; + } + if (!$this->_methodExists('pushCallback')) { + return; + } + if (!$this->_methodExists('popCallback')) { + return; + } + if (!$this->_methodExists('setLogger')) { + return; + } + $this->stack->pushCallback(array(&$this, 'returnspush')); + $log = new BurfLog; + $log->setTestCase($this); + $log->curMethod(__FUNCTION__); + $this->stack->setLogger($log); + $this->wasCalled = false; + $this->stack->push(1); + $this->assertTrue($this->wasCalled, 'returnspush not called'); + $err = $this->stack->pop(); + unset($err['context']); + unset($err['time']); + $this->assertEquals( + array( + 'code' => 1, + 'params' => array(), + 'package' => 'test', + 'message' => '', + 'level' => 'error', + ), + $err, 'popped something else 1' + ); + $this->stack->popCallback(); + $log->pushExpect('', PEAR_LOG_ERR, array( + 'code' => 1, + 'params' => array(), + 'package' => 'test', + 'message' => '', + 'level' => 'error', + )); + $this->wasCalled = false; + $this->wasLogged = false; + $this->stack->push(1); + $this->assertFalse($this->wasCalled, 'returnspush called'); + $this->assertTrue($this->wasLogged, 'was not logged!'); + $err = $this->stack->pop(); + unset($err['context']); + unset($err['time']); + $this->assertEquals( + array( + 'code' => 1, + 'params' => array(), + 'package' => 'test', + 'message' => '', + 'level' => 'error', + ), + $err, 'popped something else 2' + ); + + $err = $this->stack->pop(); + $this->assertFalse($err, 'stack not empty!'); + } + + function returnslog($err) + { + $this->wasCalled = true; + return PEAR_ERRORSTACK_LOG; + } + + function test_return_log() + { + if (!$this->_methodExists('push')) { + return; + } + if (!$this->_methodExists('pop')) { + return; + } + if (!$this->_methodExists('pushCallback')) { + return; + } + if (!$this->_methodExists('popCallback')) { + return; + } + if (!$this->_methodExists('setLogger')) { + return; + } + $this->stack->pushCallback(array(&$this, 'returnslog')); + $log = new BurfLog; + $log->setTestCase($this); + $log->curMethod(__FUNCTION__); + $this->stack->setLogger($log); + $this->wasCalled = false; + $this->wasLogged = false; + $log->pushExpect('', PEAR_LOG_ERR, array( + 'code' => 1, + 'params' => array(), + 'package' => 'test', + 'message' => '', + 'level' => 'error', + )); + $this->stack->push(1); + $this->assertTrue($this->wasCalled, 'returnslog not called'); + $this->assertTrue($this->wasLogged, 'was not logged!'); + $err = $this->stack->pop(); + $this->assertFalse($err, 'an error was pushed!'); + $this->stack->popCallback(); + $log->clearExpect(); + $log->pushExpect('', PEAR_LOG_ERR, array( + 'code' => 1, + 'params' => array(), + 'package' => 'test', + 'message' => '', + 'level' => 'error', + )); + $this->wasCalled = false; + $this->wasLogged = false; + $this->stack->push(1); + $this->assertFalse($this->wasCalled, 'returnspush called'); + $this->assertTrue($this->wasLogged, 'was not logged!'); + $err = $this->stack->pop(); + unset($err['context']); + unset($err['time']); + $this->assertEquals( + array( + 'code' => 1, + 'params' => array(), + 'package' => 'test', + 'message' => '', + 'level' => 'error', + ), + $err, 'popped something else 2' + ); + + $err = $this->stack->pop(); + $this->assertFalse($err, 'stack not empty!'); + } +} + +?> diff --git a/pear/tests/PEAR_ErrorStack/Error_Stack_TestCase_pushpopstatic.php b/pear/tests/PEAR_ErrorStack/Error_Stack_TestCase_pushpopstatic.php new file mode 100644 index 0000000000..1af66d7bef --- /dev/null +++ b/pear/tests/PEAR_ErrorStack/Error_Stack_TestCase_pushpopstatic.php @@ -0,0 +1,327 @@ +<?php + +/** + * API Unit tests for PEAR_ErrorStack package. + * + * @version $Id$ + * @author Laurent Laville <pear@laurent-laville.org> portions from HTML_CSS + * @author Greg Beaver + * @package PEAR_ErrorStack + */ + +/** + * @package PEAR_ErrorStack + */ + +class PEAR_ErrorStack_TestCase_pushpopstatic extends PHPUnit_TestCase +{ + /** + * A PEAR_PackageFileManager object + * @var object + */ + var $packagexml; + + function PEAR_ErrorStack_TestCase_pushpopstatic($name) + { + $this->PHPUnit_TestCase($name); + } + + function setUp() + { + error_reporting(E_ALL); + $this->errorOccured = false; + set_error_handler(array(&$this, 'errorHandler')); + $this->stack = new PEAR_ErrorStack(''); + $s = &PEAR_ErrorStack::singleton('PEAR_ErrorStack'); + $s->pushCallback(array('PEAR_ErrorStack', '_handleError')); + } + + function tearDown() + { + unset($this->stack); + unset($GLOBALS['_PEAR_ERRORSTACK_SINGLETON']); + } + + + function _stripWhitespace($str) + { + return preg_replace('/\\s+/', '', $str); + } + + function _methodExists($name) + { + if (in_array(strtolower($name), get_class_methods($this->stack))) { + return true; + } + $this->assertTrue(false, 'method '. $name . ' not implemented in ' . get_class($this->stack)); + return false; + } + + function errorHandler($errno, $errstr, $errfile, $errline) { + //die("$errstr in $errfile at line $errline: $errstr"); + $this->errorOccured = true; + $this->assertTrue(false, "$errstr at line $errline, $errfile"); + } + + function test_valid_basic() + { + if (!$this->_methodExists('staticPush')) { + return; + } + if (!$this->_methodExists('singleton')) { + return; + } + if (!$this->_methodExists('pop')) { + return; + } + $this->stack = &PEAR_ErrorStack::singleton('test'); + PEAR_ErrorStack::staticPush('test', 1); + $err = $this->stack->pop(); + unset($err['context']); + unset($err['time']); + $this->assertEquals( + array( + 'code' => 1, + 'params' => array(), + 'package' => 'test', + 'message' => '', + 'level' => 'error', + ), + $err, 'popped something else' + ); + $err = $this->stack->pop(); + $this->assertFalse($err, 'stack not empty!'); + } + + function test_valid_params() + { + if (!$this->_methodExists('staticPush')) { + return; + } + if (!$this->_methodExists('singleton')) { + return; + } + if (!$this->_methodExists('pop')) { + return; + } + $this->stack = &PEAR_ErrorStack::singleton('test'); + $z = PEAR_ErrorStack::staticPush('test', 2, 'exception', array('my' => 'param'), 'hello', + array('test'), array(array('file' => 'boof', 'line' => 34))); + $err = $this->stack->pop('exception'); + $this->assertEquals($z, $err, 'popped different error'); + unset($err['time']); + $this->assertEquals( + array( + 'code' => 2, + 'params' => array('my' => 'param'), + 'package' => 'test', + 'message' => 'hello', + 'level' => 'exception', + 'context' => + array( + 'file' => 'boof', + 'line' => 34, + ), + 'repackage' => array('test'), + ), + $err, 'popped something else' + ); + $err = $this->stack->pop(); + $this->assertFalse($err, 'stack not empty!'); + } + + function test_valid_paramscompat() + { + if (!$this->_methodExists('staticPush')) { + return; + } + if (!$this->_methodExists('singleton')) { + return; + } + if (!$this->_methodExists('pop')) { + return; + } + $this->stack = &PEAR_ErrorStack::singleton('test', false, null, 'PEAR_ErrorStack', true); + $z = PEAR_ErrorStack::staticPush('test', 2, 'exception', array('my' => 'param'), 'hello', + array('test'), array(array('file' => 'boof', 'line' => 34))); + $this->assertEquals('pear_error', strtolower(get_class($z)), 'not pear_error'); + $err = $this->stack->pop('exception'); + if (is_a($z, 'PEAR_Error')) { + $this->assertEquals($err, $z->getUserInfo(), 'userinfo wrong'); + } + unset($err['time']); + $this->assertEquals( + array( + 'code' => 2, + 'params' => array('my' => 'param'), + 'package' => 'test', + 'message' => 'hello', + 'level' => 'exception', + 'context' => + array( + 'file' => 'boof', + 'line' => 34, + ), + 'repackage' => array('test'), + ), + $err, 'popped something else' + ); + $err = $this->stack->pop(); + $this->assertFalse($err, 'stack not empty!'); + } + + function contextcallback($code, $params, $trace) + { + $this->assertEquals(4, $code, 'wrong context code'); + $this->assertEquals(array('hello' => 6), $params, 'wrong context params'); + $this->wasCalled = true; + return array('hi' => 'there', 'you' => 'fool'); + } + + function test_valid_contextsingleton() + { + if (!$this->_methodExists('staticPush')) { + return; + } + if (!$this->_methodExists('singleton')) { + return; + } + if (!$this->_methodExists('pop')) { + return; + } + $this->stack = &PEAR_ErrorStack::singleton('test', false, array(&$this, 'contextcallback')); + $this->wasCalled = false; + PEAR_ErrorStack::staticPush('test', 4, 'error', array('hello' => 6)); + $this->assertTrue($this->wasCalled, 'context callback was not called!'); + $err = $this->stack->pop(); + unset($err['time']); + $this->assertEquals( + array( + 'code' => 4, + 'params' => array('hello' => 6), + 'package' => 'test', + 'message' => '', + 'level' => 'error', + 'context' => array('hi' => 'there', 'you' => 'fool'), + ), + $err, 'popped something else' + ); + $err = $this->stack->pop(); + $this->assertFalse($err, 'stack not empty!'); + } + + function test_valid_context_setcontext() + { + if (!$this->_methodExists('staticPush')) { + return; + } + if (!$this->_methodExists('singleton')) { + return; + } + if (!$this->_methodExists('pop')) { + return; + } + if (!$this->_methodExists('setContextCallback')) { + return; + } + $this->stack = &PEAR_ErrorStack::singleton('test'); + $this->stack->setContextCallback(array(&$this, 'contextcallback')); + $this->wasCalled = false; + PEAR_ErrorStack::staticPush('test', 4, 'error', array('hello' => 6)); + $this->assertTrue($this->wasCalled, 'context callback was not called!'); + $err = $this->stack->pop(); + unset($err['time']); + $this->assertEquals( + array( + 'code' => 4, + 'params' => array('hello' => 6), + 'package' => 'test', + 'message' => '', + 'level' => 'error', + 'context' => array('hi' => 'there', 'you' => 'fool'), + ), + $err, 'popped something else' + ); + $err = $this->stack->pop(); + $this->assertFalse($err, 'stack not empty!'); + } + + function messagecallback(&$stack, $err) + { + $this->assertEquals(4, $err['code'], 'wrong message code'); + $this->assertEquals(array('hello' => 6), $err['params'], 'wrong message params'); + $this->assertEquals('test1', $err['package'], 'wrong error stack'); + $this->wasCalled = true; + return 'my silly message'; + } + + function test_valid_msgcallbacksingleton() + { + if (!$this->_methodExists('staticPush')) { + return; + } + if (!$this->_methodExists('singleton')) { + return; + } + if (!$this->_methodExists('pop')) { + return; + } + $this->stack = &PEAR_ErrorStack::singleton('test1', array(&$this, 'messagecallback')); + $this->wasCalled = false; + PEAR_ErrorStack::staticPush('test1', 4, 'error', array('hello' => 6)); + $this->assertTrue($this->wasCalled, 'message callback was not called!'); + $err = $this->stack->pop(); + unset($err['time']); + unset($err['context']); + $this->assertEquals( + array( + 'code' => 4, + 'params' => array('hello' => 6), + 'package' => 'test1', + 'message' => 'my silly message', + 'level' => 'error', + ), + $err, 'popped something else' + ); + $err = $this->stack->pop(); + $this->assertFalse($err, 'stack not empty!'); + } + + function test_valid_msgcallback_setmsgcallback() + { + if (!$this->_methodExists('staticPush')) { + return; + } + if (!$this->_methodExists('singleton')) { + return; + } + if (!$this->_methodExists('pop')) { + return; + } + if (!$this->_methodExists('setContextCallback')) { + return; + } + $this->stack = &PEAR_ErrorStack::singleton('test1'); + $this->stack->setMessageCallback(array(&$this, 'messagecallback')); + $this->wasCalled = false; + PEAR_ErrorStack::staticPush('test1', 4, 'error', array('hello' => 6)); + $this->assertTrue($this->wasCalled, 'message callback was not called!'); + $err = $this->stack->pop(); + unset($err['time']); + unset($err['context']); + $this->assertEquals( + array( + 'code' => 4, + 'params' => array('hello' => 6), + 'package' => 'test1', + 'message' => 'my silly message', + 'level' => 'error', + ), + $err, 'popped something else' + ); + $err = $this->stack->pop(); + $this->assertFalse($err, 'stack not empty!'); + } +} + +?> diff --git a/pear/tests/PEAR_ErrorStack/Error_Stack_TestCase_singleton.php b/pear/tests/PEAR_ErrorStack/Error_Stack_TestCase_singleton.php new file mode 100644 index 0000000000..0a052f17f1 --- /dev/null +++ b/pear/tests/PEAR_ErrorStack/Error_Stack_TestCase_singleton.php @@ -0,0 +1,93 @@ +<?php + +/** + * API Unit tests for PEAR_ErrorStack package. + * + * @version $Id$ + * @author Laurent Laville <pear@laurent-laville.org> portions from HTML_CSS + * @author Greg Beaver + * @package PEAR_ErrorStack + */ + +/** + * @package PEAR_ErrorStack + */ + +class PEAR_ErrorStack_TestCase_singleton extends PHPUnit_TestCase +{ + /** + * A PEAR_PackageFileManager object + * @var object + */ + var $packagexml; + + function PEAR_ErrorStack_TestCase_singleton($name) + { + $this->PHPUnit_TestCase($name); + } + + function setUp() + { + error_reporting(E_ALL); + $this->errorOccured = false; + set_error_handler(array(&$this, 'errorHandler')); + $this->stack = new PEAR_ErrorStack(''); + $s = &PEAR_ErrorStack::singleton('PEAR_ErrorStack'); + $s->pushCallback(array('PEAR_ErrorStack', '_handleError')); + } + + function tearDown() + { + } + + + function _stripWhitespace($str) + { + return preg_replace('/\\s+/', '', $str); + } + + function _methodExists($name) + { + if (in_array(strtolower($name), get_class_methods($this->stack))) { + return true; + } + $this->assertTrue(false, 'method '. $name . ' not implemented in ' . get_class($this->stack)); + return false; + } + + function errorHandler($errno, $errstr, $errfile, $errline) { + //die("$errstr in $errfile at line $errline: $errstr"); + $this->errorOccured = true; + $this->assertTrue(false, "$errstr at line $errline, $errfile"); + } + + function test_valid_singleton() + { + if (!$this->_methodExists('singleton')) { + return; + } + $one = &PEAR_ErrorStack::singleton('first'); + $two = &PEAR_ErrorStack::singleton('first'); + $two->testme = 2; + $this->assertEquals(2, $two->testme, 'duh test'); + $one->testme = 4; + $this->assertEquals(4, $one->testme, 'duh test 2'); + $this->assertEquals(4, $two->testme, 'same object test'); + } + + function test_invalid_singleton() + { + if (!$this->_methodExists('singleton')) { + return; + } + $one = &PEAR_ErrorStack::singleton('first'); + $two = &PEAR_ErrorStack::singleton('second'); + $two->testme = 2; + $this->assertEquals(2, $two->testme, 'duh test'); + $one->testme = 4; + $this->assertEquals(4, $one->testme, 'duh test 2'); + $this->assertEquals(2, $two->testme, 'not same object test'); + } +} + +?> diff --git a/pear/tests/PEAR_ErrorStack/Error_Stack_TestCase_staticGetErrors.php b/pear/tests/PEAR_ErrorStack/Error_Stack_TestCase_staticGetErrors.php new file mode 100644 index 0000000000..d96480d442 --- /dev/null +++ b/pear/tests/PEAR_ErrorStack/Error_Stack_TestCase_staticGetErrors.php @@ -0,0 +1,225 @@ +<?php + +/** + * API Unit tests for PEAR_ErrorStack package. + * + * @version $Id$ + * @author Laurent Laville <pear@laurent-laville.org> portions from HTML_CSS + * @author Greg Beaver + * @package PEAR_ErrorStack + */ + +/** + * @package PEAR_ErrorStack + */ + +class PEAR_ErrorStack_TestCase_staticGetErrors extends PHPUnit_TestCase +{ + + function PEAR_ErrorStack_TestCase_staticGetErrors($name) + { + $this->PHPUnit_TestCase($name); + } + + function setUp() + { + error_reporting(E_ALL); + $this->errorOccured = false; + set_error_handler(array(&$this, 'errorHandler')); + $this->stack = &PEAR_ErrorStack::singleton('test'); + $s = &PEAR_ErrorStack::singleton('PEAR_ErrorStack'); + $s->pushCallback(array('PEAR_ErrorStack', '_handleError')); + } + + function tearDown() + { + unset($this->stack); + unset($GLOBALS['_PEAR_ERRORSTACK_SINGLETON']); + } + + + function _stripWhitespace($str) + { + return preg_replace('/\\s+/', '', $str); + } + + function _methodExists($name) + { + if (in_array(strtolower($name), get_class_methods($this->stack))) { + return true; + } + $this->assertTrue(false, 'method '. $name . ' not implemented in ' . get_class($this->stack)); + return false; + } + + function errorHandler($errno, $errstr, $errfile, $errline) { + //die("$errstr in $errfile at line $errline: $errstr"); + $this->errorOccured = true; + $this->assertTrue(false, "$errstr at line $errline, $errfile"); + } + + function returnsignore($err) + { + $this->wasCalled = true; + return PEAR_ERRORSTACK_IGNORE; + } + + function test_none() + { + if (!$this->_methodExists('staticGetErrors')) { + return; + } + $this->assertEquals(array(), PEAR_ErrorStack::staticGetErrors()); + $this->assertEquals(array(), PEAR_ErrorStack::staticGetErrors(true)); + } + + function test_normal() + { + if (!$this->_methodExists('staticGetErrors')) { + return; + } + $this->assertEquals(array(), PEAR_ErrorStack::staticGetErrors()); + $this->stack->push(1); + $this->stack->push(2, 'warning'); + $this->stack->push(3, 'foo'); + $ret = PEAR_ErrorStack::staticGetErrors(); + for ($i= 0; $i < 3; $i++) { + unset($ret['test'][$i]['time']); + unset($ret['test'][$i]['context']); + } + $this->assertEquals( + array( 'test' => array( + array('code' => 3, + 'params' => array(), + 'package' => 'test', + 'level' => 'foo', + 'message' => ''), + array('code' => 2, + 'params' => array(), + 'package' => 'test', + 'level' => 'warning', + 'message' => ''), + array('code' => 1, + 'params' => array(), + 'package' => 'test', + 'level' => 'error', + 'message' => ''), + )), $ret, 'incorrect errors, non-purge'); + $ret = PEAR_ErrorStack::staticGetErrors(true); + for ($i= 0; $i < 3; $i++) { + unset($ret['test'][$i]['time']); + unset($ret['test'][$i]['context']); + } + $this->assertEquals( + array( 'test' => array( + array('code' => 3, + 'params' => array(), + 'package' => 'test', + 'level' => 'foo', + 'message' => ''), + array('code' => 2, + 'params' => array(), + 'package' => 'test', + 'level' => 'warning', + 'message' => ''), + array('code' => 1, + 'params' => array(), + 'package' => 'test', + 'level' => 'error', + 'message' => ''), + )), $ret, 'incorrect errors, purge'); + $this->assertEquals(array(), PEAR_ErrorStack::staticGetErrors()); + } + + function test_merge() + { + if (!$this->_methodExists('staticGetErrors')) { + return; + } + $this->assertEquals(array(), PEAR_ErrorStack::staticGetErrors()); + $this->stack->push(1); + for($i=0;$i<10000;$i++); + $this->stack->push(2, 'warning'); + for($i=0;$i<10000;$i++); + PEAR_ErrorStack::staticPush('fronk', 3, 'foo'); + $ret = PEAR_ErrorStack::staticGetErrors(true, true); + for ($i= 0; $i < 3; $i++) { + unset($ret[$i]['time']); + unset($ret[$i]['context']); + } + $this->assertEquals( + array( + array('code' => 3, + 'params' => array(), + 'package' => 'fronk', + 'level' => 'foo', + 'message' => ''), + array('code' => 2, + 'params' => array(), + 'package' => 'test', + 'level' => 'warning', + 'message' => ''), + array('code' => 1, + 'params' => array(), + 'package' => 'test', + 'level' => 'error', + 'message' => ''), + ), $ret, 'incorrect errors, non-purge'); + $test = PEAR_ErrorStack::staticGetErrors(); + $this->assertEquals(array(), $test, 'normal array'); + } + + function _sortErrorsRev($a, $b) + { + $this->wasCalled = true; + if ($a['time'] == $b['time']) { + return 0; + } + if ($a['time'] < $b['time']) { + return -1; + } + return 1; + } + + function test_merge_sortfunc() + { + if (!$this->_methodExists('staticGetErrors')) { + return; + } + $this->assertEquals(array(), PEAR_ErrorStack::staticGetErrors()); + $this->stack->push(1); + for($i=0;$i<10000;$i++); + $this->stack->push(2, 'warning'); + for($i=0;$i<10000;$i++); + PEAR_ErrorStack::staticPush('fronk', 3, 'foo'); + $this->wasCalled = false; + $ret = PEAR_ErrorStack::staticGetErrors(true, true, array(&$this, '_sortErrorsRev')); + $this->assertTrue($this->wasCalled, '_sortErrorsRev not called!'); + for ($i= 0; $i < 3; $i++) { + unset($ret[$i]['time']); + unset($ret[$i]['context']); + } + $this->assertEquals( + array( + array('code' => 1, + 'params' => array(), + 'package' => 'test', + 'level' => 'error', + 'message' => ''), + array('code' => 2, + 'params' => array(), + 'package' => 'test', + 'level' => 'warning', + 'message' => ''), + array('code' => 3, + 'params' => array(), + 'package' => 'fronk', + 'level' => 'foo', + 'message' => ''), + ), $ret, 'incorrect errors, non-purge'); + $test = PEAR_ErrorStack::staticGetErrors(); + $this->assertEquals(array(), $test, 'normal array'); + } +} + +?> diff --git a/pear/tests/PEAR_ErrorStack/HTML_TestListener.php b/pear/tests/PEAR_ErrorStack/HTML_TestListener.php new file mode 100644 index 0000000000..a6b3ca6588 --- /dev/null +++ b/pear/tests/PEAR_ErrorStack/HTML_TestListener.php @@ -0,0 +1,64 @@ +<?php + +/** + * Provides a nice HTML output for PHPUnit suite tests. + * + * @version $Id$ + * @author Laurent Laville <pear@laurent-laville.org> + * @package HTML_CSS + */ + +class HTML_TestListener extends PHPUnit_TestListener { + + function HTML_TestListener() { + +$report = <<<EOS +<table cellspacing="1" cellpadding="1" border="0" width="90%" align="center" class="details"> +<tr><th>Class</th><th>Function</th><th>Success</th><th>Meta-result</th></tr> +EOS; + echo $report; + } + + function addError(&$test, &$t) { + $this->_errors += 1; + } + + function addFailure(&$test, &$t) { + $this->_fails += 1; + } + + function endTest(&$test) { + /* Report both the test result and, for this special situation + where some tests are expected to fail, a "meta" test result + which indicates whether the test result matches the + expected result. + */ + $expect_failure = preg_match('/fail/i', $test->getName()); + $test_passed = ($this->_fails == 0 && $this->_errors == 0); + + if ($this->_errors > 0) { + $outcome = "<span class=\"Error\">ERROR</span>"; + } else if ($this->_fails > 0) { + $outcome = "<span class=\"Failure\">FAIL</span>"; + } else { + $outcome = "<span class=\"Pass\">OK</span>"; + } + if ($this->_errors > 0) { + $meta_outcome = '<span class="Unknown">unknown</span>'; + } else { + $meta_outcome = ($expect_failure xor $test_passed) + ? '<span class="Expected">as expected</span>' + : '<span class="Unexpected">UNEXPECTED</span>'; + } + printf("<td>$outcome</td><td>$meta_outcome</td></tr>"); + } + + function startTest(&$test) { + $this->_fails = 0; + $this->_errors = 0; + printf("<tr><td>%s </td><td>%s </td>", get_class($test), $test->getName()); + } + + +} +?>
\ No newline at end of file diff --git a/pear/tests/PEAR_ErrorStack/TestUnit.php b/pear/tests/PEAR_ErrorStack/TestUnit.php new file mode 100644 index 0000000000..1fe703f664 --- /dev/null +++ b/pear/tests/PEAR_ErrorStack/TestUnit.php @@ -0,0 +1,55 @@ +<?php + +/** + * TestUnit runs a TestSuite and returns a TestResult object. + * And more than PHPUnit attach a listener to TestResult. + * + * @version $Id$ + * @author Laurent Laville <pear@laurent-laville.org> + * @package HTML_CSS + */ + +require_once 'PHPUnit.php'; + +class TestUnit extends PHPUnit { + + function &run(&$suite, $listener) { + $result = new TestResult(); + $result->addListener($listener); + $suite->run($result); + + return $result; + } +} + +class TestResult extends PHPUnit_TestResult { + + /* report result of test run */ + function report() { + echo "</TABLE>"; + + $nRun = $this->runCount(); + $nErrors = $this->errorCount(); + $nFailures = $this->failureCount(); + echo "<h2>Summary</h2>"; + + printf("<p>%s test%s run.<br>", $nRun, ($nRun > 1) ? 's' : ''); + printf("%s error%s.<br>\n", $nErrors, ($nErrors > 1) ? 's' : ''); + printf("%s failure%s.<br>\n", $nFailures, ($nFailures > 1) ? 's' : ''); + if ($nFailures > 0) { + echo "<h2>Failure Details</h2>"; + print("<ol>\n"); + $failures = $this->failures(); + while (list($i, $failure) = each($failures)) { + $failedTest = $failure->failedTest(); + printf("<li>%s\n", $failedTest->getName() ); + print("<ul>"); + printf("<li>%s\n", $failure->thrownException() ); + print("</ul>"); + } + print("</ol>\n"); + } + } + +} +?> diff --git a/pear/tests/PEAR_ErrorStack/base_regression.php b/pear/tests/PEAR_ErrorStack/base_regression.php new file mode 100644 index 0000000000..16e9eeb302 --- /dev/null +++ b/pear/tests/PEAR_ErrorStack/base_regression.php @@ -0,0 +1,550 @@ +<?php +// $Revision$ +/** + * Basic regression test for PEAR_ErrorStack::getFileLine() + * + * phpUnit can't test global code properly because of its design, so I designed + * this instead + * @package PEAR_ErrorStack + * @subpackage tests + * @author Greg Beaver <cellog@php.net> + */ +require_once 'PEAR/ErrorStack.php'; +$result = array( +'passed' => array(), +'failed' => array() +); +$stack = &PEAR_ErrorStack::singleton('test'); +$testNumber = 1; +// test basic global file/line +$stack->push(3); +$testline = __LINE__ - 1; + +$ret = $stack->pop(); +$diff = array_diff_assoc($ret['context'], +array('file' => __FILE__, + 'function' => 'include_once', + 'line' => $testline)); + +if ($diff !== array()) { + $result['failed'][$testNumber] = $diff; +} else { + $result['passed'][$testNumber] = true; +} + +$testNumber++; +// test basic in-function file/line #2 +function testfunc() { global $stack, $testline; +$stack->push(3); +$testline = __LINE__ - 1; +} +testfunc(); + +$ret = $stack->pop(); +$diff = array_diff_assoc($ret['context'], +array('file' => __FILE__, + 'line' => $testline, + 'function' => 'testfunc')); + +if ($diff !== array()) { + $result['failed'][$testNumber] = $diff; +} else { + $result['passed'][$testNumber] = true; +} + +$testNumber++; +// test basic in-static method file/line #3 +class stclass { +function stfunc() { global $stack, $testline; +$stack->push(3); +$testline = __LINE__ - 1; +} +} +stclass::stfunc(); + +$ret = $stack->pop(); +$diff = array_diff_assoc($ret['context'], +array('file' => __FILE__, + 'line' => $testline, + 'function' => 'stfunc', + 'class' => 'stclass')); + +if ($diff !== array()) { + $result['failed'][$testNumber] = $diff; +} else { + $result['passed'][$testNumber] = true; +} + +$testNumber++; +// test basic in-method file/line #4 +class normalclass { +function normalfunc() { global $stack, $testline; +$stack->push(3); +$testline = __LINE__ - 1; +} +} +$z = new normalclass; +$z->normalfunc(); + +$ret = $stack->pop(); +$diff = array_diff_assoc($ret['context'], +array('file' => __FILE__, + 'line' => $testline, + 'function' => 'normalfunc', + 'class' => 'normalclass')); + +if ($diff !== array()) { + $result['failed'][$testNumber] = $diff; +} else { + $result['passed'][$testNumber] = true; +} + +$testNumber++; +// test global eval file/line #5 +eval('$stack->push(3);'); +$testline = __LINE__ - 1; + +$ret = $stack->pop(); +$diff = array_diff_assoc($ret['context'], +array('file' => __FILE__, + 'function' => 'include_once', + 'line' => $testline)); + +if ($diff !== array()) { + $result['failed'][$testNumber] = $diff; +} else { + $result['passed'][$testNumber] = true; +} + +$testNumber++; +// test in-function eval file/line #6 +function test2() { + global $testline, $stack; +eval('$stack->push(3);'); +$testline = __LINE__ - 1; +} +test2(); + +$ret = $stack->pop(); +$diff = array_diff_assoc($ret['context'], +array('file' => __FILE__, + 'line' => $testline, + 'function' => 'test2')); + +if ($diff !== array()) { + $result['failed'][$testNumber] = $diff; +} else { + $result['passed'][$testNumber] = true; +} + +$testNumber++; +// test in-static method eval file/line #7 +class test3 { +function test3() { + global $testline, $stack; +eval('$stack->push(3);'); +$testline = __LINE__ - 1; +} +} +test3::test3(); + +$ret = $stack->pop(); +$diff = array_diff_assoc($ret['context'], +array('file' => __FILE__, + 'line' => $testline, + 'function' => 'test3', + 'class' => 'test3')); + +if ($diff !== array()) { + $result['failed'][$testNumber] = $diff; +} else { + $result['passed'][$testNumber] = true; +} + +$testNumber++; +// test in-method eval file/line #8 +class test4 { +function test4() { + global $testline, $stack; +eval('$stack->push(3);'); +$testline = __LINE__ - 1; +} +} +$z = new test4; +$z->test4(); + +$ret = $stack->pop(); +$diff = array_diff_assoc($ret['context'], +array('file' => __FILE__, + 'line' => $testline, + 'function' => 'test4', + 'class' => 'test4')); + +if ($diff !== array()) { + $result['failed'][$testNumber] = $diff; +} else { + $result['passed'][$testNumber] = true; +} + +$testNumber++; +// test global create_function file/line #9 +$a = create_function('', '$GLOBALS["stack"]->push(3);'); +$testline = __LINE__ - 1; +$a(); + +$ret = $stack->pop(); +$diff = array_diff_assoc($ret['context'], +array('file' => __FILE__, + 'line' => $testline, + 'function' => 'create_function() code')); + +if ($diff !== array()) { + $result['failed'][$testNumber] = $diff; +} else { + $result['passed'][$testNumber] = true; +} + +$testNumber++; +// test in-function create_function file/line #10 +function test7() { global $a; +$a(); +} +test7(); + +$ret = $stack->pop(); +$diff = array_diff_assoc($ret['context'], +array('file' => __FILE__, + 'line' => $testline, + 'function' => 'create_function() code')); + +if ($diff !== array()) { + $result['failed'][$testNumber] = $diff; +} else { + $result['passed'][$testNumber] = true; +} + +$testNumber++; +// test in-static method create_function file/line #11 +class test8 { +function test8() { global $a; +$a(); +} +} +test8::test8(); + +$ret = $stack->pop(); +$diff = array_diff_assoc($ret['context'], +array('file' => __FILE__, + 'line' => $testline, + 'function' => 'create_function() code')); + +if ($diff !== array()) { + $result['failed'][$testNumber] = $diff; +} else { + $result['passed'][$testNumber] = true; +} + +$testNumber++; +// test in-method create_function file/line #12 +class test9 { +function test9() { global $a; +$a(); +} +} +$z = new test9; +$z->test9(); + +$ret = $stack->pop(); +$diff = array_diff_assoc($ret['context'], +array('file' => __FILE__, + 'line' => $testline, + 'function' => 'create_function() code')); + +if ($diff !== array()) { + $result['failed'][$testNumber] = $diff; +} else { + $result['passed'][$testNumber] = true; +} + +$result['number'] = $testNumber; + +$testNumber++; +// test static basic global file/line #13 +PEAR_ErrorStack::staticPush('test', 3); +$testline = __LINE__ - 1; + +$ret = $stack->pop(); +$diff = array_diff_assoc($ret['context'], +array('file' => __FILE__, + 'function' => 'include_once', + 'line' => $testline)); + +if ($diff !== array()) { + $result['failed'][$testNumber] = $diff; +} else { + $result['passed'][$testNumber] = true; +} + +$testNumber++; +// test static basic in-function file/line #14 +function testfunc2() { global $stack, $testline; +PEAR_ErrorStack::staticPush('test', 3); +$testline = __LINE__ - 1; +} +testfunc2(); + +$ret = $stack->pop(); +$diff = array_diff_assoc($ret['context'], +array('file' => __FILE__, + 'line' => $testline, + 'function' => 'testfunc2')); + +if ($diff !== array()) { + $result['failed'][$testNumber] = $diff; +} else { + $result['passed'][$testNumber] = true; +} + +$testNumber++; +// test static basic in-static method file/line #15 +class stclass2 { +function stfunc() { global $stack, $testline; +PEAR_ErrorStack::staticPush('test', 3); +$testline = __LINE__ - 1; +} +} +stclass2::stfunc(); + +$ret = $stack->pop(); +$diff = array_diff_assoc($ret['context'], +array('file' => __FILE__, + 'line' => $testline, + 'function' => 'stfunc', + 'class' => 'stclass2')); + +if ($diff !== array()) { + $result['failed'][$testNumber] = $diff; +} else { + $result['passed'][$testNumber] = true; +} + +$testNumber++; +// test static basic in-method file/line #16 +class normalclass2 { +function normalfunc() { global $stack, $testline; +PEAR_ErrorStack::staticPush('test', 3); +$testline = __LINE__ - 1; +} +} +$z = new normalclass2; +$z->normalfunc(); + +$ret = $stack->pop(); +$diff = array_diff_assoc($ret['context'], +array('file' => __FILE__, + 'line' => $testline, + 'function' => 'normalfunc', + 'class' => 'normalclass2')); + +if ($diff !== array()) { + $result['failed'][$testNumber] = $diff; +} else { + $result['passed'][$testNumber] = true; +} + +$testNumber++; +// test static global eval file/line #17 +eval('PEAR_ErrorStack::staticPush(\'test\', 3);'); +$testline = __LINE__ - 1; + +$ret = $stack->pop(); +$diff = array_diff_assoc($ret['context'], +array('file' => __FILE__, + 'function' => 'include_once', + 'line' => $testline)); + +if ($diff !== array()) { + $result['failed'][$testNumber] = $diff; +} else { + $result['passed'][$testNumber] = true; +} + +$testNumber++; +// test static in-function eval file/line #18 +function test22() { + global $testline, $stack; +eval('PEAR_ErrorStack::staticPush("test", 3);'); +$testline = __LINE__ - 1; +} +test22(); + +$ret = $stack->pop(); +$diff = array_diff_assoc($ret['context'], +array('file' => __FILE__, + 'line' => $testline, + 'function' => 'test22')); + +if ($diff !== array()) { + $result['failed'][$testNumber] = $diff; +} else { + $result['passed'][$testNumber] = true; +} + +$testNumber++; +// test static in-static method eval file/line #19 +class test32 { +function test3() { + global $testline, $stack; +eval('PEAR_ErrorStack::staticPush(\'test\',3);'); +$testline = __LINE__ - 1; +} +} +test32::test3(); + +$ret = $stack->pop(); +$diff = array_diff_assoc($ret['context'], +array('file' => __FILE__, + 'line' => $testline, + 'function' => 'test3', + 'class' => 'test32')); + +if ($diff !== array()) { + $result['failed'][$testNumber] = $diff; +} else { + $result['passed'][$testNumber] = true; +} + +$testNumber++; +// test static in-method eval file/line #20 +class test42 { +function test4() { + global $testline, $stack; +eval('PEAR_ErrorStack::staticPush(\'test\',3);'); +$testline = __LINE__ - 1; +} +} +$z = new test42; +$z->test4(); + +$ret = $stack->pop(); +$diff = array_diff_assoc($ret['context'], +array('file' => __FILE__, + 'line' => $testline, + 'function' => 'test4', + 'class' => 'test42')); + +if ($diff !== array()) { + $result['failed'][$testNumber] = $diff; +} else { + $result['passed'][$testNumber] = true; +} + +$testNumber++; +// test static global create_function file/line #21 +$a = create_function('', 'PEAR_ErrorStack::staticPush("test",3);'); +$testline = __LINE__ - 1; +$a(); + +$ret = $stack->pop(); +$diff = array_diff_assoc($ret['context'], +array('file' => __FILE__, + 'line' => $testline, + 'function' => 'create_function() code')); + +if ($diff !== array()) { + $result['failed'][$testNumber] = $diff; +} else { + $result['passed'][$testNumber] = true; +} + +$testNumber++; +// test static in-function create_function file/line #22 +function test72() { global $a; +$a(); +} +test72(); + +$ret = $stack->pop(); +$diff = array_diff_assoc($ret['context'], +array('file' => __FILE__, + 'line' => $testline, + 'function' => 'create_function() code')); + +if ($diff !== array()) { + $result['failed'][$testNumber] = $diff; +} else { + $result['passed'][$testNumber] = true; +} + +$testNumber++; +// test static in-static method create_function file/line #23 +class test82 { +function test8() { global $a; +$a(); +} +} +test82::test8(); + +$ret = $stack->pop(); +$diff = array_diff_assoc($ret['context'], +array('file' => __FILE__, + 'line' => $testline, + 'function' => 'create_function() code')); + +if ($diff !== array()) { + $result['failed'][$testNumber] = $diff; +} else { + $result['passed'][$testNumber] = true; +} + +$testNumber++; +// test static in-method create_function file/line #24 +class test92 { +function test9() { global $a; +$a(); +} +} +$z = new test92; +$z->test9(); + +$ret = $stack->pop(); +$diff = array_diff_assoc($ret['context'], +array('file' => __FILE__, + 'line' => $testline, + 'function' => 'create_function() code')); + +if ($diff !== array()) { + $result['failed'][$testNumber] = $diff; +} else { + $result['passed'][$testNumber] = true; +} + +$result['number'] = $testNumber; + +return $result; +/** + * Utility function + */ +function isIncludeable($path) +{ + if (file_exists(realpath($path)) && is_readable(realpath($path))) { + return true; + } + foreach (explode(PATH_SEPARATOR, get_include_path()) as $prepend) { + $test = realpath($prepend . DIRECTORY_SEPARATOR . $path); + if (file_exists($test) && is_readable($test)) { + return true; + } + } +} +/** + * Mock PHPUnit object + */ +class Mock_PHPUnit { + var $name; + function getName() + { + return 'base regression test ' . $this->name; + } +} +?>
\ No newline at end of file diff --git a/pear/tests/PEAR_ErrorStack/stylesheet.css b/pear/tests/PEAR_ErrorStack/stylesheet.css new file mode 100644 index 0000000000..47b9f92b2a --- /dev/null +++ b/pear/tests/PEAR_ErrorStack/stylesheet.css @@ -0,0 +1,65 @@ +/* $Id$ */ + +body { + font:normal 68% verdana,arial,helvetica; + color:#000000; +} +table tr td, table tr th { + font-size: 68%; +} +table.details tr th{ + font-weight: bold; + text-align:left; + background:#a6caf0; +} +table.details tr{ + background:#eeeee0; +} + +p { + line-height:1.5em; + margin-top:0.5em; margin-bottom:1.0em; +} +h1 { + margin: 0px 0px 5px; font: 165% verdana,arial,helvetica +} +h2 { + margin-top: 1em; margin-bottom: 0.5em; font: bold 125% verdana,arial,helvetica +} +h3 { + margin-bottom: 0.5em; font: bold 115% verdana,arial,helvetica +} +h4 { + margin-bottom: 0.5em; font: bold 100% verdana,arial,helvetica +} +h5 { + margin-bottom: 0.5em; font: bold 100% verdana,arial,helvetica +} +h6 { + margin-bottom: 0.5em; font: bold 100% verdana,arial,helvetica +} +.Error { + font-weight:bold; color:red; +} +.Failure, .Unexpected { + background:#ff0000; font-weight:bold; color:black; +} +.Unknown { + background:#ffff00; font-weight:bold; color:black; +} +.Pass, .Expected { + background:#00ff00; font-weight:bold; color:black; +} +.Properties { + text-align:right; +} + +CODE.expected { + color: green; background: none; font-weight: normal; +} +CODE.actual { + color: red; background: none; font-weight: normal; +} +.typeinfo { + color: gray; +} diff --git a/pear/tests/PEAR_ErrorStack/testsuite.php b/pear/tests/PEAR_ErrorStack/testsuite.php new file mode 100644 index 0000000000..1899142746 --- /dev/null +++ b/pear/tests/PEAR_ErrorStack/testsuite.php @@ -0,0 +1,152 @@ +<?php + +/** + * HTML output for PHPUnit suite tests. + * + * Copied for PEAR_PackageFileManager from HTML_CSS + * @version $Id$ + * @author Laurent Laville <pear@laurent-laville.org> + * @package HTML_CSS + */ + +require_once 'TestUnit.php'; +require_once 'HTML_TestListener.php'; +require_once 'PEAR/ErrorStack.php'; + +$title = 'PhpUnit test run, PEAR_ErrorStack package'; +?> +<html> +<head> +<title><?php echo $title; ?></title> +<link rel="stylesheet" href="stylesheet.css" type="text/css" /> +</head> +<body> +<h1><?php echo $title; ?></h1> + <p> + This page runs all the phpUnit self-tests, and produces nice HTML output. + </p> + <p> + Unlike typical test run, <strong>expect many test cases to + fail</strong>. Exactly those with <code>pass</code> in their name + should succeed. + </p> + <p> + For each test we display both the test result -- <span + class="Pass">ok</span>, <span class="Failure">FAIL</span>, or + <span class="Error">ERROR</span> -- and also a meta-result -- + <span class="Expected">as expected</span>, <span + class="Unexpected">UNEXPECTED</span>, or <span + class="Unknown">unknown</span> -- that indicates whether the + expected test result occurred. Although many test results will + be 'FAIL' here, all meta-results should be 'as expected', except + for a few 'unknown' meta-results (because of errors) when running + in PHP3. + </p> + +<h2>Tests</h2> + <?php + $testcases = array( + 'PEAR_ErrorStack_TestCase_singleton', + 'PEAR_ErrorStack_TestCase_pushpop', + 'PEAR_ErrorStack_TestCase_pushpopstatic', + 'PEAR_ErrorStack_TestCase_pushpopcallback', + 'PEAR_ErrorStack_TestCase_getErrorMessage', + 'PEAR_ErrorStack_TestCase_getErrorMessageTemplate', + 'PEAR_ErrorStack_TestCase_getErrors', + 'PEAR_ErrorStack_TestCase_staticGetErrors', + ); +define('PEAR_LOG_EMERG', 0); /** System is unusable */ +define('PEAR_LOG_ALERT', 1); /** Immediate action required */ +define('PEAR_LOG_CRIT', 2); /** Critical conditions */ +define('PEAR_LOG_ERR', 3); /** Error conditions */ +define('PEAR_LOG_WARNING', 4); /** Warning conditions */ +define('PEAR_LOG_NOTICE', 5); /** Normal but significant */ +define('PEAR_LOG_INFO', 6); /** Informational */ +define('PEAR_LOG_DEBUG', 7); /** Debug-level messages */ +/** +* Mock Log object +*/ +class BurfLog { + var $testcase; + var $method; + var $expect = array(); + function setTestCase(&$testcase) + { + $this->testcase = &$testcase; + } + + function curMethod($method) + { + $this->method = $method; + } + + function pushExpect($message, $priority, $errarray) + { + unset($errarray['time']); + unset($errarray['context']); + array_push($this->expect, array($message, $priority, $errarray)); + } + + function clearExpect() + { + $this->expect = array(); + } + + function log($message, $priority, $errarray) + { + $this->testcase->wasLogged = true; + if (!is_a($this->testcase, 'PHPUnit_TestCase')) { + trigger_error('ERROR: burflog never set up', E_USER_ERROR); + return; + } + if (!isset($this->method)) { + $this->testcase->assertFalse(true, 'ERROR: burflog never set up'); + return; + } + if (!count($this->expect)) { + $this->testcase->assertFalse(true, "method $this->method: logged, but no log expected"); + $this->testcase->assertFalse(true, "method $this->method: log message = $message"); + $this->testcase->assertFalse(true, "method $this->method: log priority = $priority"); + return; + } + unset($errarray['time']); + unset($errarray['context']); + $expect = array_pop($this->expect); + $this->testcase->assertEquals($expect[0], $message, "method $this->method: wrong message"); + $this->testcase->assertEquals($expect[1], $priority, "method $this->method: wrong priority"); + $this->testcase->assertEquals($expect[2], $errarray, "method $this->method: wrong errarray"); + } +} + + $suite = new PHPUnit_TestSuite(); + + foreach ($testcases as $testcase) { + include_once $testcase . '.php'; + $suite->addTestSuite($testcase); + } + + $listener = new HTML_TestListener(); + $finalresult = TestUnit::run($suite, $listener); + $results = include_once dirname(__FILE__) . '/base_regression.php'; + $num = $results['number']; + $failed = $results['failed']; + $passed = $results['passed']; + for ($i = 1; $i <= $num; $i++) { + $bla = new Mock_PHPUnit; + $bla->name = $i; + $listener->startTest($bla); + if (isset($failed[$i])) { + $listener->addFailure($bla, $failed[$i]); + $finalresult->addFailure($bla, $a = 'context had additional ' . serialize($failed[$i])); + } + $listener->endTest($bla); + } + + $finalresult->removeListener($listener); + // hack in the base regression test count + $finalresult->_runTests += count($results['failed']) + count($results['passed']); + $finalresult->report(); + + ?> +</body> +</html> |