function run($reporter) { $context = SimpleTest::getContext(); $context->setTest($this); $context->setReporter($reporter); $this->reporter = $reporter; $this->reporter->paintCaseStart($this->getLabel()); if ($this->needPDO) { $this->reporter->makeDry(!$this->assertTrue(class_exists('PDO', false), 'PDO does not exists ! You should install PDO because tests need it.')); } $this->setUpRun(); foreach ($this->getTests() as $method) { if ($this->reporter->shouldInvoke($this->getLabel(), $method)) { $this->skip(); if ($this->shouldSkip()) { break; } $invoker = $this->reporter->createInvoker($this->createInvoker()); $invoker->before($method); $invoker->invoke($method); $invoker->after($method); } } $this->tearDownRun(); $this->reporter->paintCaseEnd($this->getLabel()); unset($this->reporter); return $reporter->getStatus(); }
/** * Checks the current test context to see if a test has * ever been run. * @return boolean True if tests have run. */ function tests_have_run() { if ($context = SimpleTest::getContext()) { return (bool) $context->getTest(); } return false; }
/** * Wires up the error queue for a single test. * @return SimpleErrorQueue Queue connected to the test. * @access private */ protected function createErrorQueue() { $context = SimpleTest::getContext(); $test = $this->getTestCase(); $queue = $context->get('SimpleErrorQueue'); $queue->setTestCase($test); return $queue; }
/** * @param string $testName */ protected function shouldPaintMethod($testName) { $testCase = SimpleTest::getContext()->getTest(); if (!$testCase instanceof CakeTestCase) { return true; } return !in_array(strtolower($testName), $testCase->methods); }
/** * @param string $testCase * @param string $method * @return boolean */ public function shouldInvoke($testCase, $method) { $test = SimpleTest::getContext()->getTest(); if ($test instanceof CakeTestCase && in_array(strtolower($method), $test->methods)) { return true; } return parent::shouldInvoke($testCase, $method); }
/** * Wires up the error queue for a single test. * * @return SimpleErrorQueue Queue connected to the test. */ public function &_createErrorQueue() { $context =& SimpleTest::getContext(); $test =& $this->getTestCase(); $queue =& $context->get('SimpleErrorQueue'); $queue->setTestCase($test); return $queue; }
/** * Invokes a test method and dispatches any * untrapped errors. Called back from * the visiting runner. * @param string $method Test method to call. * @access public */ function invoke($method) { $context =& SimpleTest::getContext(); $queue =& $context->get('SimpleErrorQueue'); $queue->setTestCase($this->GetTestCase()); set_error_handler('SimpleTestErrorHandler'); parent::invoke($method); while (list($severity, $message, $file, $line) = $queue->extract()) { $severity = SimpleErrorQueue::getSeverityAsString($severity); $test =& $this->getTestCase(); $test->error($severity, $message, $file, $line); } restore_error_handler(); }
/** * Lists rather then invokes a test method. Consequently, * we do not invoke the setUp() and tearDown() calls either. * @param string $method Test method to call. * @access public */ function invoke($method) { $context = SimpleTest::getContext(); $test = $this->getTestCase(); // $context->getTest(); $reporter = $context->getReporter(); // use 'user signal' as the way to render the list entry: $case = get_class($test); if ($case != $test->getLabel()) { $case = sprintf("%s [%s]", $case, $test->getLabel()); } $show_breadcrumb = $reporter->includeBreadCrumb(false); $reporter->paintSignal("Test", sprintf("Case: %s | Method: %s", $case, $method)); $reporter->includeBreadCrumb($show_breadcrumb); }
/** * Invokes a test method whilst trapping expected * exceptions. Any left over unthrown exceptions * are then reported as failures. * @param string $method Test method to call. */ function invoke($method) { $trap = SimpleTest::getContext()->get('SimpleExceptionTrap'); $trap->clear(); try { parent::invoke($method); } catch (Exception $exception) { if (!$trap->isExpected($this->getTestCase(), $exception)) { $this->getTestCase()->exception($exception); } $trap->clear(); } if ($message = $trap->getOutstanding()) { $this->getTestCase()->fail($message); } }
public function send($v1, $v2) { // test for context $context = SimpleTest::getContext(); $test = $context->getTest(); $mock = $this->mock; foreach ($this->_expected_context as $key => $value) { $test->assertEqual($value, $this->_context->get($key)); } $step = $mock->getCallCount('send'); if (isset($this->_expected_context_at[$step])) { foreach ($this->_expected_context_at[$step] as $key => $value) { $test->assertEqual($value, $this->_context->get($key)); } } // boilerplate mock code, does not have return value or references $args = func_get_args(); $mock->invoke('send', $args); }
/** * Invokes a test method whilst trapping expected * exceptions. Any left over unthrown exceptions * are then reported as failures. * * @param string $method Test method to call. */ public function invoke($method) { $trap = SimpleTest::getContext()->get('SimpleExceptionTrap'); $trap->clear(); try { $has_thrown = false; parent::invoke($method); } catch (Exception $exception) { $has_thrown = true; if (!$trap->isExpected($this->getTestCase(), $exception)) { $this->getTestCase()->exception($exception); } $trap->clear(); } if ($message = $trap->getOutstanding()) { $this->getTestCase()->fail($message); } if ($has_thrown) { try { parent::getTestCase()->tearDown(); } catch (Exception $e) { } } }
public function testQueueStartsEmpty() { $context = SimpleTest::getContext(); $queue = $context->get('SimpleErrorQueue'); $this->assertFalse($queue->extract()); }
/** * Finds currently running test. * @return SimpeTestCase Current test case. * @access protected */ function _getCurrentTestCase() { $context =& SimpleTest::getContext(); return $context->getTest(); }
/** * Finds currently running test. * @return SimpeTestCase Current test case. */ protected function getCurrentTestCase() { return SimpleTest::getContext()->getTest(); }
/** * @param string $testName */ public function paintMethodStart($testName) { parent::paintMethodStart($testName); $this->xmlWriter->startTestCase($testName, SimpleTest::getContext()->getTest()); $this->methodStartTime = microtime(true); $this->assertionCount = 0; }
/** * Uses reflection to run every method within itself * starting with the string "test" unless a method * is specified. * @param SimpleReporter $reporter Current test reporter. * @return boolean True if all tests passed. * @access public */ function run(&$reporter) { $context = &SimpleTest::getContext(); $context->setTest($this); $context->setReporter($reporter); $this->_reporter = &$reporter; $started = false; foreach ($this->getTests() as $method) { if ($reporter->shouldInvoke($this->getLabel(), $method)) { $this->skip(); if ($this->_should_skip) { break; } if (! $started) { $reporter->paintCaseStart($this->getLabel()); $started = true; } //moodlefix begins if (defined('TIME_ALLOWED_PER_UNIT_TEST')) { set_time_limit(TIME_ALLOWED_PER_UNIT_TEST); } //moodlefix ends $invoker = &$this->_reporter->createInvoker($this->createInvoker()); $invoker->before($method); $invoker->invoke($method); $invoker->after($method); } } if ($started) { $reporter->paintCaseEnd($this->getLabel()); } unset($this->_reporter); //moodlefix begins $context->unsetTest(); //moodlefix ends return $reporter->getStatus(); }
/** * @param string $text * @param string $type * @param string $file * @param string $line * @param string $message * @param string $failureOrError * @since Method available since Release 2.17.0 */ protected function writeFailureOrError($text, $type, $file, $line, $message, $failureOrError) { $methodIsArtificial = false; if (!$this->methodStarted) { if (\SimpleTest::getContext()->getTest()->_should_skip) { $testName = 'skip'; } else { $testName = 'ARTIFICIAL'; } $this->paintMethodStart($testName); $methodIsArtificial = true; } $this->junitXMLWriter->{'write' . $failureOrError}($text, $type, $file, $line, $message); if ($methodIsArtificial) { $this->paintMethodEnd($testName); } }
public function run($reporter) { $context = SimpleTest::getContext(); $context->setTest($this); $context->setReporter($reporter); $this->reporter = $reporter; $started = false; foreach ($this->specs as $spec) { foreach ($spec["tests"] as $test) { $method = $test["method_name"]; if ($reporter->shouldInvoke($spec["name"], $method)) { if (!$started) { $reporter->paintCaseStart($this->getLabel()); $started = true; } $invoker = $this->reporter->createInvoker($this->createInvoker()); $invoker->before($method); $invoker->invoke($method); $invoker->after($method); } } } if ($started) { $reporter->paintCaseEnd($this->getLabel()); } unset($this->reporter); $context->setTest(null); return $reporter->getStatus(); }
function &_getCurrentTestCase() { $context =& SimpleTest::getContext(); $test =& $context->getTest(); return $test->test; }
/** * Uses reflection to run every method within itself * starting with the string "test" unless a method * is specified. * @param SimpleReporter $reporter Current test reporter. * @return boolean True if all tests passed. * @access public */ function run(&$reporter) { $context = &SimpleTest::getContext(); $context->setTest($this); $context->setReporter($reporter); $this->_reporter = &$reporter; $started = false; foreach ($this->getTests() as $method) { if(getenv('TEST_METHOD') !== false && $method != getenv('TEST_METHOD')) { continue; } else if (getenv('TEST_METHOD')!==false) { echo "Running Single Test: $method\n"; } if ($reporter->shouldInvoke($this->getLabel(), $method)) { $this->skip(); if ($this->_should_skip) { break; } if (! $started) { $reporter->paintCaseStart($this->getLabel()); $started = true; } $invoker = &$this->_reporter->createInvoker($this->createInvoker()); $invoker->before($method); $invoker->invoke($method); $invoker->after($method); } } if ($started) { $reporter->paintCaseEnd($this->getLabel()); } unset($this->_reporter); return $reporter->getStatus(); }
protected function _extractExceptionFileAndLine($e) { $context = SimpleTest::getContext(); if (!is_object($context)) { return '???:???'; } $ref = new ReflectionClass($context->getTest()); $test_file = $ref->getFileName(); if ($e->getFile() == $test_file) { return $e->getFile() . ':' . $e->getLine(); } foreach ($e->getTrace() as $item) { if ($item['file'] == $test_file) { return $item['file'] . ':' . $item['line']; } } return '???:???'; }
/** * Uses reflection to run every method within itself * starting with the string "test" unless a method * is specified. * @param SimpleReporter $reporter Current test reporter. * @return boolean True if all tests passed. * @access public */ function run(&$reporter) { $context =& SimpleTest::getContext(); $context->setTest($this); $context->setReporter($reporter); $this->_reporter =& $reporter; $reporter->paintCaseStart($this->getLabel()); $this->skip(); if (!$this->_should_skip) { foreach ($this->getTests() as $method) { if ($reporter->shouldInvoke($this->getLabel(), $method)) { $invoker =& $this->_reporter->createInvoker($this->createInvoker()); $invoker->before($method); $invoker->invoke($method); $invoker->after($method); } } } $reporter->paintCaseEnd($this->getLabel()); unset($this->_reporter); return $reporter->getStatus(); }
/** * Tells SimpleTest to ignore an upcoming exception as not relevant * to the current test. It doesn't affect the test, whether thrown or * not. * @param SimpleExpectation/Exception $ignored The error to ignore. * @access public */ public function ignoreException($ignored = false) { SimpleTest::getContext()->get('SimpleExceptionTrap')->ignoreException($ignored); }
function testContextHoldsCurrentTestCase() { $context =& SimpleTest::getContext(); $this->assertReference($this, $context->getTest()); }
/** * Uses reflection to run every method within itself * starting with the string "test" unless a method * is specified. * @param SimpleReporter $reporter Current test reporter. * @return bool True if all tests passed. */ public function run($reporter) { $context = SimpleTest::getContext(); $context->setTest($this); $context->setReporter($reporter); $this->reporter = $reporter; $started = false; foreach ($this->getTests() as $method) { if ($reporter->shouldInvoke($this->getLabel(), $method)) { $this->skip(); if ($this->should_skip) { break; } if (!$started) { $reporter->paintCaseStart($this->getLabel()); $started = true; } $invoker = $this->reporter->createInvoker($this->createInvoker()); $invoker->before($method); $invoker->invoke($method); $invoker->after($method); } } if ($started) { $reporter->paintCaseEnd($this->getLabel()); } unset($this->reporter); $context->setTest(null); return $reporter->getStatus(); }
/** * Prepares for an exception. If the error mismatches it * passes through, otherwise it is swallowed. Any * left over errors trigger failures. * @param SimpleExpectation/Exception $expected The error to match. * @param string $message Message on failure. * @access public */ function expectException($expected = false, $message = '%s') { $queue = SimpleTest::getContext()->get('SimpleExceptionTrap'); $line = $this->getAssertionLine(); $queue->expectException($expected, $message . $line); }
/** * Prepares for an exception. If the error mismatches it * passes through, otherwise it is swallowed. Any * left over errors trigger failures. * @param SimpleExpectation/Exception $expected The error to match. * @param string $message Message on failure. * @access public */ function expectException($expected = false, $message = '%s') { $context =& SimpleTest::getContext(); $queue =& $context->get('SimpleExceptionTrap'); // :HACK: Directly substituting in seems to cause a segfault with // Zend Optimizer on some systems $line = $this->getAssertionLine(); $queue->expectException($expected, $message . $line); }
public function testContextHoldsCurrentTestCase() { $context = SimpleTest::getContext(); $this->assertSame($this, $context->getTest()); }
function testTrappedErrorPlacedInQueue() { trigger_error('Ouch!'); $context =& SimpleTest::getContext(); $queue =& $context->get('SimpleErrorQueue'); list($severity, $message, $file, $line) = $queue->extract(); $this->assertEqual($message, 'Ouch!'); $this->assertEqual($file, __FILE__); $this->assertFalse($queue->extract()); }
/** * Dumps error queue, useful if there has been a fatal error. */ function htmlpurifier_dump_error_queue() { $context = SimpleTest::getContext(); $queue = $context->get('SimpleErrorQueue'); while (($error = $queue->extract()) !== false) { var_dump($error); } }