PHPUnit_Util_Test::getMissingRequirements PHP Method

    public static function getMissingRequirements($className, $methodName)
    {
        $required = static::getRequirements($className, $methodName);
        $missing = [];
        $operator = empty($required['PHP']['operator']) ? '>=' : $required['PHP']['operator'];
        if (!empty($required['PHP']) && !version_compare(PHP_VERSION, $required['PHP']['version'], $operator)) {
            $missing[] = sprintf('PHP %s %s is required.', $operator, $required['PHP']['version']);
        }
        if (!empty($required['PHPUnit'])) {
            $phpunitVersion = PHPUnit_Runner_Version::id();
            $operator = empty($required['PHPUnit']['operator']) ? '>=' : $required['PHPUnit']['operator'];
            if (!version_compare($phpunitVersion, $required['PHPUnit']['version'], $operator)) {
                $missing[] = sprintf('PHPUnit %s %s is required.', $operator, $required['PHPUnit']['version']);
            }
        }
        if (!empty($required['OS']) && !preg_match($required['OS'], PHP_OS)) {
            $missing[] = sprintf('Operating system matching %s is required.', $required['OS']);
        }
        if (!empty($required['functions'])) {
            foreach ($required['functions'] as $function) {
                $pieces = explode('::', $function);
                if (2 === count($pieces) && method_exists($pieces[0], $pieces[1])) {
                    continue;
                }
                if (function_exists($function)) {
                    continue;
                }
                $missing[] = sprintf('Function %s is required.', $function);
            }
        }
        if (!empty($required['extensions'])) {
            foreach ($required['extensions'] as $extension) {
                if (isset($required['extension_versions'][$extension])) {
                    continue;
                }
                if (!extension_loaded($extension)) {
                    $missing[] = sprintf('Extension %s is required.', $extension);
                }
            }
        }
        if (!empty($required['extension_versions'])) {
            foreach ($required['extension_versions'] as $extension => $required) {
                $actualVersion = phpversion($extension);
                $operator = empty($required['operator']) ? '>=' : $required['operator'];
                if (false === $actualVersion || !version_compare($actualVersion, $required['version'], $operator)) {
                    $missing[] = sprintf('Extension %s %s %s is required.', $extension, $operator, $required['version']);
                }
            }
        }
        return $missing;
    }

 /**
  * Runs the tests and collects their result in a TestResult.
  *
  * @param  PHPUnit_Framework_TestResult $result
  * @return PHPUnit_Framework_TestResult
  */
 public function run(PHPUnit_Framework_TestResult $result = null)
 {
     if ($result === null) {
         $result = $this->createResult();
     }
     if (count($this) == 0) {
         return $result;
     }
     $hookMethods = PHPUnit_Util_Test::getHookMethods($this->name);
     $result->startTestSuite($this);
     try {
         $this->setUp();
         foreach ($hookMethods['beforeClass'] as $beforeClassMethod) {
             if ($this->testCase === true && class_exists($this->name, false) && method_exists($this->name, $beforeClassMethod)) {
                 if ($missingRequirements = PHPUnit_Util_Test::getMissingRequirements($this->name, $beforeClassMethod)) {
                     $this->markTestSuiteSkipped(implode(PHP_EOL, $missingRequirements));
                 }
                 call_user_func([$this->name, $beforeClassMethod]);
             }
         }
     } catch (PHPUnit_Framework_SkippedTestSuiteError $e) {
         $numTests = count($this);
         for ($i = 0; $i < $numTests; $i++) {
             $result->startTest($this);
             $result->addFailure($this, $e, 0);
             $result->endTest($this, 0);
         }
         $this->tearDown();
         $result->endTestSuite($this);
         return $result;
     } catch (Throwable $_t) {
         $t = $_t;
     } catch (Exception $_t) {
         $t = $_t;
     }
     if (isset($t)) {
         $numTests = count($this);
         for ($i = 0; $i < $numTests; $i++) {
             $result->startTest($this);
             $result->addError($this, $t, 0);
             $result->endTest($this, 0);
         }
         $this->tearDown();
         $result->endTestSuite($this);
         return $result;
     }
     foreach ($this as $test) {
         if ($result->shouldStop()) {
             break;
         }
         if ($test instanceof PHPUnit_Framework_TestCase || $test instanceof self) {
             $test->setbeStrictAboutChangesToGlobalState($this->beStrictAboutChangesToGlobalState);
             $test->setBackupGlobals($this->backupGlobals);
             $test->setBackupStaticAttributes($this->backupStaticAttributes);
             $test->setRunTestInSeparateProcess($this->runTestInSeparateProcess);
         }
         $test->run($result);
     }
     foreach ($hookMethods['afterClass'] as $afterClassMethod) {
         if ($this->testCase === true && class_exists($this->name, false) && method_exists($this->name, $afterClassMethod)) {
             call_user_func([$this->name, $afterClassMethod]);
         }
     }
     $this->tearDown();
     $result->endTestSuite($this);
     return $result;
 }