public function __construct()
 {
     parent::__construct();
     $paths = [];
     // Autodiscover extension unit tests
     $registry = ExtensionRegistry::getInstance();
     foreach ($registry->getAllThings() as $info) {
         $paths[] = dirname($info['path']) . '/tests/phpunit';
     }
     // Extensions can return a list of files or directories
     Hooks::run('UnitTestsList', [&$paths]);
     foreach (array_unique($paths) as $path) {
         if (is_dir($path)) {
             // If the path is a directory, search for test cases.
             // @since 1.24
             $suffixes = ['Test.php'];
             $fileIterator = new File_Iterator_Facade();
             $matchingFiles = $fileIterator->getFilesAsArray($path, $suffixes);
             $this->addTestFiles($matchingFiles);
         } elseif (file_exists($path)) {
             // Add a single test case or suite class
             $this->addTestFile($path);
         }
     }
     if (!$paths) {
         $this->addTest(new DummyExtensionsTest('testNothing'));
     }
 }

 /**
  * Removes a directory from the whitelist (recursively).
  *
  * @param string $directory
  * @param string $suffix
  * @param string $prefix
  */
 public function removeDirectoryFromWhitelist($directory, $suffix = '.php', $prefix = '')
 {
     $facade = new File_Iterator_Facade();
     $files = $facade->getFilesAsArray($directory, $suffix, $prefix);
     foreach ($files as $file) {
         $this->removeFileFromWhitelist($file);
     }
 }

 function __construct()
 {
     parent::__construct('DonationInterface test suite');
     $suffixes = array('Test.php');
     $fileIterator = new File_Iterator_Facade();
     $files = $fileIterator->getFilesAsArray(__DIR__, $suffixes);
     $this->addTestFiles($files);
 }

 /**
  * @covers PHP_CodeCoverage_Filter::addFilesToWhitelist
  * @covers PHP_CodeCoverage_Filter::getWhitelist
  */
 public function testAddingFilesToTheWhitelistWorks()
 {
     $facade = new File_Iterator_Facade();
     $files = $facade->getFilesAsArray(TEST_FILES_PATH, $suffixes = '.php');
     $this->filter->addFilesToWhitelist($files);
     $whitelist = $this->filter->getWhitelist();
     sort($whitelist);
     $this->assertEquals($this->files, $whitelist);
 }

 /**
  * Returns the Test corresponding to the given suite.
  * This is a template method, subclasses override
  * the runFailed() and clearStatus() methods.
  *
  * @param  string  $suiteClassName
  * @param  string  $suiteClassFile
  * @param  mixed   $suffixes
  * @return PHPUnit_Framework_Test
  */
 public function getTest($suiteClassName, $suiteClassFile = '', $suffixes = '')
 {
     if (is_dir($suiteClassName) && !is_file($suiteClassName . '.php') && empty($suiteClassFile)) {
         $facade = new File_Iterator_Facade();
         $files = $facade->getFilesAsArray($suiteClassName, $suffixes);
         $suite = new PHPUnit_Framework_TestSuite($suiteClassName);
         $suite->addTestFiles($files);
         return $suite;
     }
     $testClass = $this->loadSuiteClass($suiteClassName, $suiteClassFile);
 }

 /**
  * Run the task.
  *
  * @param array &$options Additional options.
  *
  * @return integer Number of errors.
  */
 public function run(&$options)
 {
     require 'PHPDCD/Autoload.php';
     $facade = new File_Iterator_Facade();
     $result = $facade->getFilesAsArray(array(realpath($this->_config->getPath())), array('php'), array(), array(), true);
     $files = $result['files'];
     $commonPath = $result['commonPath'];
     $detector = new PHPDCD_Detector(new \ezcConsoleOutput());
     $result = $detector->detectDeadCode($files, true);
     $printer = new PHPDCD_TextUI_ResultPrinter();
     $printer->printResult($result, $commonPath);
 }

 /**
  * Constructs a new TestSuite for .phpt test cases.
  *
  * @param  string                      $directory
  * @throws PHPUnit_Framework_Exception
  */
 public function __construct(string $directory)
 {
     if (!is_dir($directory)) {
         throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'directory name');
     }
     $this->setName($directory);
     $facade = new File_Iterator_Facade();
     $files = $facade->getFilesAsArray($directory, '.phpt');
     foreach ($files as $file) {
         $this->addTestFile($file);
     }
 }

 /**
  * Checks the extension with php copy and paste detector
  */
 protected function _checkWithPhpCopyPasteDetector()
 {
     $facade = new \File_Iterator_Facade();
     $files = $facade->getFilesAsArray($this->_extensionPath);
     $strategy = new \PHPCPD_Detector_Strategy_Default();
     $detector = new \PHPCPD_Detector($strategy, null);
     try {
         $clones = $detector->copyPasteDetection($files, self::PHP_CPD_MIN_LINES, self::PHP_CPD_MIN_TOKENS);
     } catch (\Exception $e) {
         return;
     }
     $this->_addIssue(array('type' => 'duplicated_code', 'files' => $clones->getFilesWithClones(), 'comment' => round((double) $clones->getPercentage(), 2), 'occurrences' => $clones->count()));
 }

 /**
  * Constructs a new TestSuite for .zept test cases.
  *
  * @param  string                      $directory
  * @throws PHPUnit_Framework_Exception
  */
 public function __construct($directory, $silent)
 {
     if (is_string($directory) && is_dir($directory)) {
         $this->setName($directory);
         $facade = new \File_Iterator_Facade();
         $files = $facade->getFilesAsArray($directory, '.zept');
         foreach ($files as $file) {
             $this->addTest(new \ZephirTestCase\ZeptTestCase($file, $silent));
         }
     } else {
         throw \PHPUnit_Util_InvalidArgumentHelper::factory(1, 'directory name');
     }
 }

 public static function suite()
 {
     if (empty($_ENV)) {
         if (isset($_SERVER['PATH'])) {
             $_ENV['PATH'] = $_SERVER['PATH'];
         } else {
             $_ENV['PATH'] = getenv('PATH');
         }
     }
     $directory = __DIR__ . '/../../ext/tests/';
     $facade = new File_Iterator_Facade();
     $files = $facade->getFilesAsArray($directory, '.phpt');
     $suite = new PHPUnit_Framework_TestSuite();
     foreach ($files as $file) {
         $c = file_get_contents($file);
         if (!preg_match('/^--(?:PUT|(?:GZIP|DEFLATE)_POST|CGI)--$/m', $c)) {
             $suite->addTestFile($file);
         }
     }
     return $suite;
 }

 /**
  * Returns the Test corresponding to the given suite.
  * This is a template method, subclasses override
  * the runFailed() and clearStatus() methods.
  *
  * @param string $suiteClassName
  * @param string $suiteClassFile
  * @param mixed  $suffixes
  *
  * @return PHPUnit_Framework_Test
  */
 public function getTest($suiteClassName, $suiteClassFile = '', $suffixes = '')
 {
     if (is_dir($suiteClassName) && !is_file($suiteClassName . '.php') && empty($suiteClassFile)) {
         $facade = new File_Iterator_Facade();
         $files = $facade->getFilesAsArray($suiteClassName, $suffixes);
         $suite = new PHPUnit_Framework_TestSuite($suiteClassName);
         $suite->addTestFiles($files);
         return $suite;
     }
     try {
         $testClass = $this->loadSuiteClass($suiteClassName, $suiteClassFile);
     } catch (PHPUnit_Framework_Exception $e) {
         $this->runFailed($e->getMessage());
         return;
     }
     try {
         $suiteMethod = $testClass->getMethod(self::SUITE_METHODNAME);
         if (!$suiteMethod->isStatic()) {
             $this->runFailed('suite() method must be static.');
             return;
         }
         try {
             $test = $suiteMethod->invoke(null, $testClass->getName());
         } catch (ReflectionException $e) {
             $this->runFailed(sprintf("Failed to invoke suite() method.\n%s", $e->getMessage()));
             return;
         }
     } catch (ReflectionException $e) {
         try {
             $test = new PHPUnit_Framework_TestSuite($testClass);
         } catch (PHPUnit_Framework_Exception $e) {
             $test = new PHPUnit_Framework_TestSuite();
             $test->setName($suiteClassName);
         }
     }
     $this->clearStatus();
     return $test;
 }

 public function __construct()
 {
     parent::__construct();
     $paths = array();
     // Extensions can return a list of files or directories
     Hooks::run('UnitTestsList', array(&$paths));
     foreach ($paths as $path) {
         if (is_dir($path)) {
             // If the path is a directory, search for test cases.
             // @since 1.24
             $suffixes = array('Test.php');
             $fileIterator = new File_Iterator_Facade();
             $matchingFiles = $fileIterator->getFilesAsArray($path, $suffixes);
             $this->addTestFiles($matchingFiles);
         } else {
             // Add a single test case or suite class
             $this->addTestFile($path);
         }
     }
     if (!count($paths)) {
         $this->addTest(new DummyExtensionsTest('testNothing'));
     }
 }

 /**
  * Get all test helper class names
  * @return array
  */
 public function getTestHelperClassNames()
 {
     if (!empty($this->_testHelperClassNames)) {
         return $this->_testHelperClassNames;
     }
     //Get initial path to test helpers
     $frameworkConfig = $this->_configHelper->getConfigFramework();
     $initialPath = SELENIUM_TESTS_BASEDIR . DIRECTORY_SEPARATOR . $frameworkConfig['testsuite_base_path'];
     //Get test helpers sequence
     $fallbackOrderHelper = $this->_configHelper->getHelpersFallbackOrder();
     $facade = new File_Iterator_Facade();
     foreach ($fallbackOrderHelper as $codePoolName) {
         $projectPath = $initialPath . DIRECTORY_SEPARATOR . $codePoolName;
         if (!is_dir($projectPath)) {
             continue;
         }
         $files = $facade->getFilesAsArray($projectPath, 'Helper.php');
         foreach ($files as $file) {
             $className = str_replace($initialPath . DIRECTORY_SEPARATOR, '', $file);
             $className = str_replace(DIRECTORY_SEPARATOR, '_', str_replace('.php', '', $className));
             $array = explode('_', str_replace('_Helper', '', $className));
             $helperName = end($array);
             $this->_testHelperClassNames[$helperName] = $className;
         }
     }
     return $this->_testHelperClassNames;
 }

 /**
  * Runs a suite of unit tests
  *
  * @param string $directory Directory with tests.
  * @param string $suffix    Test file suffix.
  * @throws \Exception When invalid test found.
  * @return boolean
  */
 public function run($directory, $suffix)
 {
     $this->resultPrinter->suiteHeader($this, $directory . '/*' . $suffix);
     $passed = true;
     $facade = new \File_Iterator_Facade();
     $old_handler = set_error_handler(array($this, 'handlePHPErrors'));
     foreach ($facade->getFilesAsArray($directory, $suffix) as $path) {
         $test = (require $path);
         if (!$test instanceof xTest) {
             throw new \Exception("'{$path}' is not a valid unit test");
         }
         $test->setResultPrinter($this->resultPrinter);
         $passed = $passed && $test->run($this);
     }
     if ($old_handler) {
         set_error_handler($old_handler);
     } else {
         restore_error_handler();
     }
     $this->resultPrinter->createCodeCoverageReport($this->coverage);
     $this->resultPrinter->suiteFooter($this);
     return $passed;
 }

 /**
  * Returns the Phantom test files from a folder as an array.
  * 
  * @param  string $directory
  * @param  string $suffix
  * @return array
  */
 private static function getTestFilesFromFolder($directory, $suffix)
 {
     $facade = new File_Iterator_Facade();
     return $facade->getFilesAsArray($directory, $suffix);
 }

 /**
  * Main method.
  */
 public static function main()
 {
     $input = new ezcConsoleInput();
     $output = new ezcConsoleOutput();
     $input->registerOption(new ezcConsoleOption('', 'exclude', ezcConsoleInput::TYPE_STRING, array(), TRUE));
     $input->registerOption(new ezcConsoleOption('h', 'help', ezcConsoleInput::TYPE_NONE, NULL, FALSE, '', '', array(), array(), FALSE, FALSE, TRUE));
     $input->registerOption(new ezcConsoleOption('', 'log-pmd', ezcConsoleInput::TYPE_STRING));
     $input->registerOption(new ezcConsoleOption('', 'min-lines', ezcConsoleInput::TYPE_INT, 5));
     $input->registerOption(new ezcConsoleOption('', 'min-tokens', ezcConsoleInput::TYPE_INT, 70));
     $input->registerOption(new ezcConsoleOption('', 'save-memory', ezcConsoleInput::TYPE_NONE, NULL, FALSE));
     $input->registerOption(new ezcConsoleOption('', 'suffixes', ezcConsoleInput::TYPE_STRING, 'php', FALSE));
     $input->registerOption(new ezcConsoleOption('', 'quiet', ezcConsoleInput::TYPE_NONE, NULL, FALSE));
     $input->registerOption(new ezcConsoleOption('v', 'version', ezcConsoleInput::TYPE_NONE, NULL, FALSE, '', '', array(), array(), FALSE, FALSE, TRUE));
     $input->registerOption(new ezcConsoleOption('', 'verbose', ezcConsoleInput::TYPE_NONE));
     try {
         $input->process();
     } catch (ezcConsoleOptionException $e) {
         print $e->getMessage() . PHP_EOL;
         exit(1);
     }
     if ($input->getOption('help')->value) {
         self::showHelp();
         exit(0);
     } else {
         if ($input->getOption('version')->value) {
             self::printVersionString();
             exit(0);
         }
     }
     $arguments = $input->getArguments();
     $exclude = $input->getOption('exclude')->value;
     if (is_array($exclude) && count($exclude) == 1) {
         array_map('trim', explode(',', array_pop($exclude)));
     }
     $logPmd = $input->getOption('log-pmd')->value;
     $minLines = $input->getOption('min-lines')->value;
     $minTokens = $input->getOption('min-tokens')->value;
     $saveMemory = $input->getOption('save-memory')->value;
     $suffixes = array_map('trim', explode(',', $input->getOption('suffixes')->value));
     $quiet = $input->getOption('quiet')->value;
     if ($input->getOption('verbose')->value !== FALSE) {
         $verbose = $output;
     } else {
         $verbose = NULL;
     }
     if (!empty($arguments)) {
         $facade = new File_Iterator_Facade();
         $result = $facade->getFilesAsArray($arguments, $suffixes, array(), $exclude, TRUE);
         $files = $result['files'];
         $commonPath = $result['commonPath'];
         unset($result);
     } else {
         self::showHelp();
         exit(1);
     }
     if (empty($files)) {
         self::showError('No files found to scan.' . PHP_EOL);
     }
     self::printVersionString();
     if (!$saveMemory) {
         $strategy = new PHPCPD_Detector_Strategy_Default();
     } else {
         $strategy = new PHPCPD_Detector_Strategy_SaveMemory();
     }
     $detector = new PHPCPD_Detector($strategy, $verbose);
     $clones = $detector->copyPasteDetection($files, $minLines, $minTokens);
     $printer = new PHPCPD_TextUI_ResultPrinter();
     $printer->printResult($clones, $commonPath, !$quiet);
     unset($printer);
     if ($logPmd) {
         $pmd = new PHPCPD_Log_XML_PMD($logPmd);
         $pmd->processClones($clones);
         unset($pmd);
     }
     if (count($clones) > 0) {
         exit(1);
     }
 }

<?php

include __DIR__ . '/../vendor/autoload.php';
use Liuggio\Spawn\Spawn;
$testRunner = new Spawn();
$iterator = new \File_Iterator_Facade();
$files = $iterator->getFilesAsArray([__DIR__], ['Test.php']);
$exit = $testRunner->processes($files, __DIR__ . '/../bin/phpunit {}')->onCompleted(function (\Liuggio\Spawn\Process\Process $process) {
    echo $process->getCommandLine();
    if ($process->getExitCode() == 0) {
        echo '  yes' . PHP_EOL;
        return;
    }
    echo '  ops' . PHP_EOL;
    echo $process->getErrorOutput() . PHP_EOL;
    echo $process->getOutput() . PHP_EOL;
    echo '=====' . PHP_EOL;
})->onLoopCompleted(function ($exitCode, \Symfony\Component\Stopwatch\StopwatchEvent $event) {
    echo PHP_EOL . PHP_EOL . ($exitCode == 0 ? 'successful' : 'failed') . PHP_EOL;
    echo 'memory used: ' . $event->getMemory() . PHP_EOL;
    echo 'Duration:   ' . $event->getDuration() . PHP_EOL;
})->start();
exit($exit);
// if you want more fun please have a look to the fastest project // https://github.com/liuggio/fastest

 /**
  * @param  DOMElement                  $testSuiteNode
  * @return PHPUnit_Framework_TestSuite
  * @since  Method available since Release 3.4.0
  */
 protected function getTestSuite(DOMElement $testSuiteNode, $testSuiteFilter = null)
 {
     if ($testSuiteNode->hasAttribute('name')) {
         $suite = new PHPUnit_Framework_TestSuite((string) $testSuiteNode->getAttribute('name'));
     } else {
         $suite = new PHPUnit_Framework_TestSuite();
     }
     $exclude = array();
     foreach ($testSuiteNode->getElementsByTagName('exclude') as $excludeNode) {
         $exclude[] = $this->toAbsolutePath((string) $excludeNode->nodeValue);
     }
     $fileIteratorFacade = new File_Iterator_Facade();
     foreach ($testSuiteNode->getElementsByTagName('directory') as $directoryNode) {
         if ($testSuiteFilter && $directoryNode->parentNode->getAttribute('name') != $testSuiteFilter) {
             continue;
         }
         $directory = (string) $directoryNode->nodeValue;
         if (empty($directory)) {
             continue;
         }
         if ($directoryNode->hasAttribute('phpVersion')) {
             $phpVersion = (string) $directoryNode->getAttribute('phpVersion');
         } else {
             $phpVersion = PHP_VERSION;
         }
         if ($directoryNode->hasAttribute('phpVersionOperator')) {
             $phpVersionOperator = (string) $directoryNode->getAttribute('phpVersionOperator');
         } else {
             $phpVersionOperator = '>=';
         }
         if (!version_compare(PHP_VERSION, $phpVersion, $phpVersionOperator)) {
             continue;
         }
         if ($directoryNode->hasAttribute('prefix')) {
             $prefix = (string) $directoryNode->getAttribute('prefix');
         } else {
             $prefix = '';
         }
         if ($directoryNode->hasAttribute('suffix')) {
             $suffix = (string) $directoryNode->getAttribute('suffix');
         } else {
             $suffix = 'Test.php';
         }
         $files = $fileIteratorFacade->getFilesAsArray($this->toAbsolutePath($directory), $suffix, $prefix, $exclude);
         $suite->addTestFiles($files);
     }
     foreach ($testSuiteNode->getElementsByTagName('file') as $fileNode) {
         if ($testSuiteFilter && $fileNode->parentNode->getAttribute('name') != $testSuiteFilter) {
             continue;
         }
         $file = (string) $fileNode->nodeValue;
         if (empty($file)) {
             continue;
         }
         // Get the absolute path to the file
         $file = $fileIteratorFacade->getFilesAsArray($this->toAbsolutePath($file));
         if (!isset($file[0])) {
             continue;
         }
         $file = $file[0];
         if ($fileNode->hasAttribute('phpVersion')) {
             $phpVersion = (string) $fileNode->getAttribute('phpVersion');
         } else {
             $phpVersion = PHP_VERSION;
         }
         if ($fileNode->hasAttribute('phpVersionOperator')) {
             $phpVersionOperator = (string) $fileNode->getAttribute('phpVersionOperator');
         } else {
             $phpVersionOperator = '>=';
         }
         if (!version_compare(PHP_VERSION, $phpVersion, $phpVersionOperator)) {
             continue;
         }
         $suite->addTestFile($file);
     }
     return $suite;
 }

 protected function getModuleTestSuite($module, $testFile = '')
 {
     $moduleList = $this->epInfo->getModulesList();
     $topsuite = new PHPUnit_Framework_TestSuite();
     if (isset($moduleList[$module])) {
         $type = ($this->testType ? '.' . $this->testType : '') . '.pu.php';
         $suite = new JelixTestSuite($module);
         if ($this->version36) {
             if ($testFile) {
                 $suite->addTestFile($moduleList[$module] . 'tests/' . $testFile);
             } else {
                 $fileIteratorFacade = new File_Iterator_Facade();
                 $files = $fileIteratorFacade->getFilesAsArray($moduleList[$module], $type);
                 $suite->addTestFiles($files);
             }
         } else {
             $testCollector = new PHPUnit_Runner_IncludePathTestCollector(array($moduleList[$module]), $type);
             $suite->addTestFiles($testCollector->collectTests());
         }
         if (count($suite->tests()) > 0) {
             $topsuite->addTestSuite($suite);
         }
     }
     return $topsuite;
 }

 /**
  * @param  DOMElement $testSuiteNode
  * @return PHPUnit_Framework_TestSuite
  * @since  Method available since Release 3.4.0
  */
 protected function getTestSuite(DOMElement $testSuiteNode)
 {
     if ($testSuiteNode->hasAttribute('name')) {
         $suite = new PHPUnit_Framework_TestSuite((string) $testSuiteNode->getAttribute('name'));
     } else {
         $suite = new PHPUnit_Framework_TestSuite();
     }
     foreach ($testSuiteNode->getElementsByTagName('directory') as $directoryNode) {
         $directory = (string) $directoryNode->nodeValue;
         if (empty($directory)) {
             continue;
         }
         if ($directoryNode->hasAttribute('phpVersion')) {
             $phpVersion = (string) $directoryNode->getAttribute('phpVersion');
         } else {
             $phpVersion = PHP_VERSION;
         }
         if ($directoryNode->hasAttribute('phpVersionOperator')) {
             $phpVersionOperator = (string) $directoryNode->getAttribute('phpVersionOperator');
         } else {
             $phpVersionOperator = '>=';
         }
         if (!version_compare(PHP_VERSION, $phpVersion, $phpVersionOperator)) {
             continue;
         }
         if ($directoryNode->hasAttribute('prefix')) {
             $prefix = (string) $directoryNode->getAttribute('prefix');
         } else {
             $prefix = '';
         }
         if ($directoryNode->hasAttribute('suffix')) {
             $suffix = (string) $directoryNode->getAttribute('suffix');
         } else {
             $suffix = 'Test.php';
         }
         $facade = new File_Iterator_Facade();
         $files = $facade->getFilesAsArray($this->toAbsolutePath($directory), $suffix, $prefix, array());
         $suite->addTestFiles($files);
     }
     foreach ($testSuiteNode->getElementsByTagName('file') as $fileNode) {
         $file = (string) $fileNode->nodeValue;
         if (empty($file)) {
             continue;
         }
         if ($fileNode->hasAttribute('phpVersion')) {
             $phpVersion = (string) $fileNode->getAttribute('phpVersion');
         } else {
             $phpVersion = PHP_VERSION;
         }
         if ($fileNode->hasAttribute('phpVersionOperator')) {
             $phpVersionOperator = (string) $fileNode->getAttribute('phpVersionOperator');
         } else {
             $phpVersionOperator = '>=';
         }
         if (!version_compare(PHP_VERSION, $phpVersion, $phpVersionOperator)) {
             continue;
         }
         $suite->addTestFile($file);
     }
     return $suite;
 }