--- /dev/null
+<?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');
+ }
+}
+
+?>
--- /dev/null
+<?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));
+ }
+}
+
+?>
--- /dev/null
+<?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());
+ }
+}
+
+?>
--- /dev/null
+<?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!');
+ }
+}
+
+?>
--- /dev/null
+<?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!');
+ }
+}
+
+?>
--- /dev/null
+<?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!');
+ }
+}
+
+?>
--- /dev/null
+<?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');
+ }
+}
+
+?>
--- /dev/null
+<?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');
+ }
+}
+
+?>
--- /dev/null
+<?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
--- /dev/null
+<?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");
+ }
+ }
+
+}
+?>
--- /dev/null
+<?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
--- /dev/null
+/* $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;
+}
--- /dev/null
+<?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>
projects / php / commitdiff