PHPUnit_Framework_TestSuite::createTest PHP Method

    public static function createTest(ReflectionClass $theClass, $name)
    {
        $className = $theClass->getName();
        if (!$theClass->isInstantiable()) {
            return self::warning(sprintf('Cannot instantiate class "%s".', $className));
        }
        $backupSettings = PHPUnit_Util_Test::getBackupSettings($className, $name);
        $preserveGlobalState = PHPUnit_Util_Test::getPreserveGlobalStateSettings($className, $name);
        $runTestInSeparateProcess = PHPUnit_Util_Test::getProcessIsolationSettings($className, $name);
        $constructor = $theClass->getConstructor();
        if ($constructor !== null) {
            $parameters = $constructor->getParameters();
            // TestCase() or TestCase($name)
            if (count($parameters) < 2) {
                $test = new $className();
            } else {
                try {
                    $data = PHPUnit_Util_Test::getProvidedData($className, $name);
                } catch (PHPUnit_Framework_IncompleteTestError $e) {
                    $message = sprintf('Test for %s::%s marked incomplete by data provider', $className, $name);
                    $_message = $e->getMessage();
                    if (!empty($_message)) {
                        $message .= "\n" . $_message;
                    }
                    $data = self::incompleteTest($className, $name, $message);
                } catch (PHPUnit_Framework_SkippedTestError $e) {
                    $message = sprintf('Test for %s::%s skipped by data provider', $className, $name);
                    $_message = $e->getMessage();
                    if (!empty($_message)) {
                        $message .= "\n" . $_message;
                    }
                    $data = self::skipTest($className, $name, $message);
                } catch (Throwable $_t) {
                    $t = $_t;
                } catch (Exception $_t) {
                    $t = $_t;
                }
                if (isset($t)) {
                    $message = sprintf('The data provider specified for %s::%s is invalid.', $className, $name);
                    $_message = $t->getMessage();
                    if (!empty($_message)) {
                        $message .= "\n" . $_message;
                    }
                    $data = self::warning($message);
                }
                // Test method with @dataProvider.
                if (isset($data)) {
                    $test = new PHPUnit_Framework_TestSuite_DataProvider($className . '::' . $name);
                    if (empty($data)) {
                        $data = self::warning(sprintf('No tests found in suite "%s".', $test->getName()));
                    }
                    $groups = PHPUnit_Util_Test::getGroups($className, $name);
                    if ($data instanceof PHPUnit_Framework_WarningTestCase || $data instanceof PHPUnit_Framework_SkippedTestCase || $data instanceof PHPUnit_Framework_IncompleteTestCase) {
                        $test->addTest($data, $groups);
                    } else {
                        foreach ($data as $_dataName => $_data) {
                            $_test = new $className($name, $_data, $_dataName);
                            if ($runTestInSeparateProcess) {
                                $_test->setRunTestInSeparateProcess(true);
                                if ($preserveGlobalState !== null) {
                                    $_test->setPreserveGlobalState($preserveGlobalState);
                                }
                            }
                            if ($backupSettings['backupGlobals'] !== null) {
                                $_test->setBackupGlobals($backupSettings['backupGlobals']);
                            }
                            if ($backupSettings['backupStaticAttributes'] !== null) {
                                $_test->setBackupStaticAttributes($backupSettings['backupStaticAttributes']);
                            }
                            $test->addTest($_test, $groups);
                        }
                    }
                } else {
                    $test = new $className();
                }
            }
        }
        if (!isset($test)) {
            throw new PHPUnit_Framework_Exception('No valid test provided.');
        }
        if ($test instanceof PHPUnit_Framework_TestCase) {
            $test->setName($name);
            if ($runTestInSeparateProcess) {
                $test->setRunTestInSeparateProcess(true);
                if ($preserveGlobalState !== null) {
                    $test->setPreserveGlobalState($preserveGlobalState);
                }
            }
            if ($backupSettings['backupGlobals'] !== null) {
                $test->setBackupGlobals($backupSettings['backupGlobals']);
            }
            if ($backupSettings['backupStaticAttributes'] !== null) {
                $test->setBackupStaticAttributes($backupSettings['backupStaticAttributes']);
            }
        }
        return $test;
    }

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