/** * Creates an empty test case. Should be subclassed * with test methods for a functional test case. * @param string $label Name of test case. Will use * the class name if none specified. * @access public */ function __construct($label = false) { parent::__construct($label); $this->current_shell = $this->createShell(); $this->last_status = false; $this->last_command = ''; }
/** * Creates an empty test case. Should be subclassed * with test methods for a functional test case. * @param string $label Name of test case. Will use * the class name if none specified. * @access public */ function __construct($label = false) { if (!$label) { $label = get_class($this); } parent::__construct($label); }
/** * @param SimpleTestCase $testCase * @return integer * @since Method available since Release 2.11.1 */ public function countTestsInTestCase(SimpleTestCase $testCase) { $tests = $testCase->getTests(); $testCount = 0; if ($this->config->testsOnlySpecified()) { if ($this->config->testsOnlySpecifiedMethods) { foreach ($tests as $method) { if ($this->config->inMethodsToBeTested(get_class($testCase), $method)) { ++$testCount; } } } elseif ($this->config->testsOnlySpecifiedClasses) { if ($this->config->inClassesToBeTested(get_class($testCase))) { $testCount = count($tests); } } } else { $testCount = count($tests); } return $testCount; }
/** * Sends an error which we interpret as a fail * with a different message for compatibility. * @param $message Message to display. * @public */ function error($message) { parent::fail("Error triggered [{$message}]"); }
public function doLog($message, $severity) { $this->test->dump(NULL, $message); }
/** * Receives event from unit test that the current * test method has finished. Totals up the call * counts and triggers a test assertion if a test * is present for expected call counts. * @param string $test_method Current method name. * @param SimpleTestCase $test Test to send message to. * @access public */ function atTestEnd($test_method, &$test) { foreach ($this->_expected_counts as $method => $expectation) { $test->assert($expectation, $this->getCallCount($method)); } foreach ($this->_max_counts as $method => $expectation) { if ($expectation->test($this->getCallCount($method))) { $test->assert($expectation, $this->getCallCount($method)); } } }
/** * Tests the type of a value. * @param $value Value to take type of. * @param $type Hoped for type. * @param $message Message to display. * @public */ function assertType($value, $type, $message = "%s") { parent::assertTrue(gettype($value) == strtolower($type), $message); }
/** * Compares the expected exception with any * in the queue. Issues a pass or fail and * returns the state of the test. * @param SimpleTestCase $test Test case to send messages to. * @param Exception $exception Exception to compare. * @return boolean False on no match. */ function isExpected($test, $exception) { if ($this->expected) { return $test->assert($this->expected, $exception, $this->message); } return false; }
public function runTestInvokesAfterClass() { SimpleTestCase::$dispose = 0; $this->suite->runTest(new SimpleTestCase('succeeds')); $this->assertEquals(1, SimpleTestCase::$dispose); }
protected function tearDown() { parent::tearDown(); }
/** * Sets the invoker to one that restarts the browser on * each request. * @return SimpleInvoker Invoker for each method. * @access public */ function &createInvoker() { return new WebTestCaseInvoker(parent::createInvoker()); }
/** * Invokes a single test method on the test case. * This call back allows the reporter to decide if * it actually wants to run the test. * @param SimpleTestCase $test_case Test case to run test on. * @param string $method Name of test method. * @access public */ function invoke(&$test_case, $method) { if (!$this->_is_dry_run) { $test_case->invoke($method); } }
/** * Run a test case (usually a group/suite) with the inferred reporter. * * @param SimpleTestCase $test_case * @return void This method does not return a value. * Use hasFailures() to query status after running this. * @todo Stop creating an individual reporter for each run, in case a client * calls this method multiple times. */ function runCase($test_case) { $reporter = $this->createReporter(); $test_case->run($reporter); $all_tests_passed = $reporter->getStatus(); if (!$all_tests_passed) { $this->_failed_runs++; } }
public function __construct() { parent::__construct(); $this->_curl = curl_init(); curl_setopt($this->_curl, CURLOPT_FOLLOWLOCATION, true); curl_setopt($this->_curl, CURLOPT_MAXREDIRS, 5); curl_setopt($this->_curl, CURLOPT_RETURNTRANSFER, true); $this->_jar = tempnam(sys_get_temp_dir(), 'COOKIEJAR'); curl_setopt($this->_curl, CURLOPT_COOKIEJAR, $this->_jar); }
/** * Compares the expected exception with any * in the queue. Issues a pass or fail and * returns the state of the test. * @param SimpleTestCase $test Test case to send messages to. * @param Exception $exception Exception to compare. * @return boolean False on no match. */ function isExpected($test, $exception) { if ($this->expected) { return $test->assert($this->expected, $exception, $this->message); } foreach ($this->ignored as $ignored) { if ($ignored->test($exception)) { return true; } } return false; }
/** * Sends an error which we interpret as a fail * with a different message for compatibility. * @param $message Message to display. * @public */ function error($message) { parent::assertTrue(false, "Error triggered [{$message}]"); }
public function __construct($path) { $this->_path = $path; parent::__construct($path); }
/** * Sets up a browser for the start of each * test method. * @access public */ function before() { $this->_browser =& $this->createBrowser(); parent::before(); }
/** * @param SimpleTestCase $testCase * @return integer * @since Method available since Release 2.14.0 */ protected function getTestsInTestCase(SimpleTestCase $testCase) { return $testCase->getTests(); }
/** * Sets up a browser for the start of each * test method. * @param string $method Name of test method. * @access protected */ function invoke($method) { $this->_browser =& $this->createBrowser(); parent::invoke($method); }
/** * Announces the end of the test. Includes private clean up. * @param string $method Test method just finished. * @access public */ function after($method) { $this->unsetBrowser(); parent::after($method); }
/** * Triggers an assertion on the held test case. * Should be overridden when using another test * framework other than the SimpleTest one if the * assertion method has a different name. * @param boolean $assertion True will pass. * @param string $message Message that will go with * the test event. * @param SimpleTestCase $test Unit test case to send * assertion to. * @access protected */ function _assertTrue($assertion, $message , &$test) { if ($test) { $test->assertTrue($assertion, $message); } }
/** * Tests the type of a value. * @param $value Value to take type of. * @param $type Hoped for type. * @param $message Message to display. * @public */ function assertType($value, $type, $message = "%s") { parent::assert(new TrueExpectation(), gettype($value) == strtolower($type), $message); }
/** * Calculates the incoming test cases. Skips abstract * and ignored classes. * @param array $candidates Candidate classes. * @return array New classes which are test * cases that shouldn't be ignored. * @access public */ function selectRunnableTests($candidates) { $classes = array(); foreach ($candidates as $class) { if (TestSuite::getBaseTestCase($class)) { $reflection = new SimpleReflection($class); if ($reflection->isAbstract()) { SimpleTest::ignore($class); } else { // only pick classes which do have test methods we can run: $methods = $reflection->getMethods(); foreach ($methods as $method) { if (SimpleTestCase::isTest($class, $method)) { $classes[] = $class; break; } } } } } return $classes; }