PHP PHPUnit_Framework_TestSuite::isTestMethod方法代码示例

 protected static function makeSuite($className, $group = null)
 {
     $suite = new PHPUnit_Framework_TestSuite();
     $suite->setName($className);
     $class = new ReflectionClass($className);
     foreach (self::$engineConfigurations as $engineName => $opts) {
         if ($group !== null && $group !== $engineName) {
             continue;
         }
         try {
             $parser = new Parser();
             $parser->startExternalParse(Title::newMainPage(), new ParserOptions(), Parser::OT_HTML, true);
             $engineClass = "Scribunto_{$engineName}Engine";
             $engine = new $engineClass(self::$engineConfigurations[$engineName] + array('parser' => $parser));
             $parser->scribunto_engine = $engine;
             $engine->setTitle($parser->getTitle());
             $engine->getInterpreter();
         } catch (Scribunto_LuaInterpreterNotFoundError $e) {
             $suite->addTest(new Scribunto_LuaEngineTestSkip($className, "interpreter for {$engineName} is not available"), array('Lua', $engineName));
             continue;
         }
         // Work around PHPUnit breakage: the only straightforward way to
         // get the data provider is to call
         // PHPUnit_Util_Test::getProvidedData, but that instantiates the
         // class without passing any parameters to the constructor. But we
         // *need* that engine name.
         self::$staticEngineName = $engineName;
         $engineSuite = new PHPUnit_Framework_TestSuite();
         $engineSuite->setName("{$engineName}: {$className}");
         foreach ($class->getMethods() as $method) {
             if (PHPUnit_Framework_TestSuite::isTestMethod($method) && $method->isPublic()) {
                 $name = $method->getName();
                 $groups = PHPUnit_Util_Test::getGroups($className, $name);
                 $groups[] = 'Lua';
                 $groups[] = $engineName;
                 $groups = array_unique($groups);
                 $data = PHPUnit_Util_Test::getProvidedData($className, $name);
                 if (is_array($data) || $data instanceof Iterator) {
                     // with @dataProvider
                     $dataSuite = new PHPUnit_Framework_TestSuite_DataProvider($className . '::' . $name);
                     foreach ($data as $k => $v) {
                         $dataSuite->addTest(new $className($name, $v, $k, $engineName), $groups);
                     }
                     $engineSuite->addTest($dataSuite);
                 } elseif ($data === false) {
                     // invalid @dataProvider
                     $engineSuite->addTest(new PHPUnit_Framework_Warning("The data provider specified for {$className}::{$name} is invalid."));
                 } else {
                     // no @dataProvider
                     $engineSuite->addTest(new $className($name, array(), '', $engineName), $groups);
                 }
             }
         }
         $suite->addTest($engineSuite);
     }
     return $suite;
 }

 protected function createTestFromPhpUnitMethod(\ReflectionClass $class, \ReflectionMethod $method)
 {
     if (!\PHPUnit_Framework_TestSuite::isTestMethod($method)) {
         return;
     }
     $test = \PHPUnit_Framework_TestSuite::createTest($class, $method->name);
     if ($test instanceof \PHPUnit_Framework_TestSuite_DataProvider) {
         foreach ($test->tests() as $t) {
             $this->enhancePhpunitTest($t);
         }
         return $test;
     }
     $this->enhancePhpunitTest($test);
     return $test;
 }

 public static function suite($className)
 {
     /** @var KmsCi_PHPUnit_TestCase_PhpWebdriverBrowsers $className */
     $suite = new PHPUnit_Framework_TestSuite();
     foreach ($className::$browsers as $browser) {
         $bsuite = new PHPUnit_Framework_TestSuite();
         $class = new ReflectionClass($className);
         $bsuite->setName($class->getName() . '_' . $className::getBrowserTestName($browser));
         foreach ($class->getMethods() as $method) {
             if (strpos($method->getDeclaringClass()->getName(), 'PHPUnit_') !== 0) {
                 if ($method->isPublic() && $bsuite->isTestMethod($method)) {
                     $name = $method->getName();
                     $test = new $className($name);
                     $test->browser = $browser;
                     $bsuite->addTest($test);
                 }
             }
         }
         $suite->addTest($bsuite);
     }
     return $suite;
 }

 protected function createTestFromPhpUnitMethod(\ReflectionClass $class, \ReflectionMethod $method)
 {
     if (!\PHPUnit_Framework_TestSuite::isTestMethod($method) and strpos($method->name, 'should') !== 0) {
         return;
     }
     $test = \PHPUnit_Framework_TestSuite::createTest($class, $method->name);
     if ($test instanceof TestCase\Test) {
         $test->setBootstrap($this->settings['bootstrap']);
         $test->setDispatcher($this->dispatcher);
         $test->setGuyClass($this->settings['class_name']);
         $groups = \PHPUnit_Util_Test::getGroups($class->name, $method->name);
         $test->getScenario()->groups($groups);
     } else {
         if ($this->settings['bootstrap']) {
             require_once $this->settings['bootstrap'];
         }
     }
     return $test;
 }

 /**
  * Creates test from PHPUnit method.
  *
  * @since 1.0.0
  *
  * @access protected
  * @param \ReflectionClass $class The class object.
  * @param \ReflectionMethod $method The method object.
  * @return \PHPUnit_Framework_Test The test object.
  */
 protected function createTestFromPhpUnitMethod(\ReflectionClass $class, \ReflectionMethod $method)
 {
     if (!\PHPUnit_Framework_TestSuite::isTestMethod($method)) {
         return;
     }
     $test = \PHPUnit_Framework_TestSuite::createTest($class, $method->name);
     if ($test instanceof \PHPUnit_Framework_TestSuite_DataProvider) {
         foreach ($test->tests() as $t) {
             $this->enhancePhpunitTest($t);
         }
     } else {
         $this->enhancePhpunitTest($test);
     }
     $test->setBackupGlobals(false);
     $test->setBackupStaticAttributes(false);
     $test->setRunTestInSeparateProcess(false);
     $test->setInIsolation(false);
     $test->setPreserveGlobalState(false);
     return $test;
 }