PHP SimpleTest::getContext方法代码示例

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