| public setBackupGlobals ( boolean $backupGlobals ) | ||
| $backupGlobals | boolean | |
private function createAndPerform($filename, $test_suite_function, array $args = array())
{
$suite = new PHPUnit_Framework_TestSuite();
$suite->addTestFile($filename);
$suite->setBackupGlobals($this->backupGlobals);
$suite->setBackupStaticAttributes($this->backupStaticAttributes);
$result = call_user_func_array(array($suite, $test_suite_function), $args);
unset($suite);
return $result;
}
public function run(rex_test_locator $locator, $colors = false)
{
$suite = new PHPUnit_Framework_TestSuite();
// disable backup of globals, since we have some rex_sql objectes referenced from variables in global space.
// PDOStatements are not allowed to be serialized
$suite->setBackupGlobals(false);
$suite->addTestFiles($locator->getIterator());
rex_error_handler::unregister();
$runner = new PHPUnit_TextUI_TestRunner();
$backtrace = debug_backtrace(false);
array_unshift($backtrace, ['file' => __FILE__, 'line' => __LINE__ + 3]);
$runner->setPrinter(new rex_tests_result_printer($backtrace, $colors));
$result = $runner->doRun($suite);
rex_error_handler::register();
return $result;
}
private function _run_tests($classes, $classname = '')
{
$suite = new PHPUnit_Framework_TestSuite();
// Turn off BackUpGlobal until https://github.com/sebastianbergmann/phpunit/issues/451 is fixed
$suite->setBackupGlobals(false);
foreach ($classes as $testcase) {
if (!$classname or strtolower($testcase) === strtolower($classname)) {
$suite->addTestSuite($testcase);
}
}
$result = new PHPUnit_Framework_TestResult();
require_once 'PHPUnit/TextUI/ResultPrinter.php';
$this->printer = new WPUnitCommandResultsPrinter();
$result->addListener($this->printer);
return array($suite->run($result), $this->printer);
}
public function run()
{
$result = "";
foreach($this->files as $oneDirectory => $testCollection)
{
$suite = new PHPUnit_Framework_TestSuite();
$suite->setBackupGlobals(false);
$suite->setName($oneDirectory);
$this->includeCases($testCollection, $suite);
$this->suite->addTestSuite($suite);
}
if($this->includeCoverage)
{
$this->importCodeCoverage();
$this->setCodeCoverageIgnores();
}
$this->suite->run($this->result);
$xml = new SimpleXMLElement($this->listener->getXML());
$casesReport = new HTMLReport();
$result .= $casesReport->report($xml);
if($this->includeCoverage)
{
$CodeCoverage = $this->result->getCodeCoverage();
$coverageReport = new CodeCoverageReport();
$result .= $coverageReport->report($CodeCoverage);
//$writer = new PHP_CodeCoverage_Report_HTML;
//$writer->process($CodeCoverage, dirname(__FILE__).'/tmp/');
}
$this->report = $result;
}
/**
* The main entry point
*
* @throws BuildException
*/
public function main()
{
if ($this->codecoverage && !extension_loaded('xdebug')) {
throw new Exception("PHPUnitTask depends on Xdebug being installed to gather code coverage information.");
}
$this->loadPHPUnit();
$suite = new PHPUnit_Framework_TestSuite('AllTests');
if ($this->configuration) {
$arguments = $this->handlePHPUnitConfiguration($this->configuration);
if ($arguments['backupGlobals'] === false) {
$suite->setBackupGlobals(false);
}
if ($arguments['backupStaticAttributes'] === true) {
$suite->setBackupStaticAttributes(true);
}
}
if ($this->printsummary) {
$fe = new FormatterElement();
$fe->setParent($this);
$fe->setType("summary");
$fe->setUseFile(false);
$this->formatters[] = $fe;
}
$autoloadSave = spl_autoload_functions();
if ($this->bootstrap) {
require $this->bootstrap;
}
foreach ($this->batchtests as $batchTest) {
$this->appendBatchTestToTestSuite($batchTest, $suite);
}
$this->execute($suite);
if ($this->testfailed) {
throw new BuildException($this->testfailuremessage);
}
$autoloadNew = spl_autoload_functions();
foreach ($autoloadNew as $autoload) {
spl_autoload_unregister($autoload);
}
foreach ($autoloadSave as $autoload) {
spl_autoload_register($autoload);
}
}
public function doRun(PHPUnit_Framework_Test $suite, array $arguments = array())
{
$this->handleConfiguration($arguments);
$this->processSuiteFilters($suite, $arguments);
// -----------------------
// get the tests that failed last time this same command (without rerun) was used
// from file and rerun them
if (isset($arguments['rerun'])) {
$cache = new CacheUtil();
$key = $cache->generateKey($_SERVER['argv']);
if ($cache->fileExists($key)) {
$rerunnableTests = $cache->readCache($key);
$suite = new PHPUnit_Framework_TestSuite();
foreach ($rerunnableTests as $testName) {
$class = new ReflectionClass($testName['testClassName']);
$methodName = $testName['testMethodName'];
$test = $suite::createTest($class, $methodName);
$suite->addTest($test);
}
}
}
// ------------------------------
if (isset($arguments['bootstrap'])) {
$GLOBALS['__PHPUNIT_BOOTSTRAP'] = $arguments['bootstrap'];
}
if ($arguments['backupGlobals'] === false) {
$suite->setBackupGlobals(false);
}
if ($arguments['backupStaticAttributes'] === true) {
$suite->setBackupStaticAttributes(true);
}
if ($arguments['disallowChangesToGlobalState'] === true) {
$suite->setDisallowChangesToGlobalState(true);
}
if (is_integer($arguments['repeat'])) {
$test = new PHPUnit_Extensions_RepeatedTest($suite, $arguments['repeat'], $arguments['processIsolation']);
$suite = new PHPUnit_Framework_TestSuite();
$suite->addTest($test);
}
$result = $this->createTestResult();
if (!$arguments['convertErrorsToExceptions']) {
$result->convertErrorsToExceptions(false);
}
if (!$arguments['convertNoticesToExceptions']) {
PHPUnit_Framework_Error_Notice::$enabled = false;
}
if (!$arguments['convertWarningsToExceptions']) {
PHPUnit_Framework_Error_Warning::$enabled = false;
}
if ($arguments['stopOnError']) {
$result->stopOnError(true);
}
if ($arguments['stopOnFailure']) {
$result->stopOnFailure(true);
}
if ($arguments['stopOnIncomplete']) {
$result->stopOnIncomplete(true);
}
if ($arguments['stopOnRisky']) {
$result->stopOnRisky(true);
}
if ($arguments['stopOnSkipped']) {
$result->stopOnSkipped(true);
}
if ($this->printer === null) {
if (isset($arguments['printer']) && $arguments['printer'] instanceof PHPUnit_Util_Printer) {
$this->printer = $arguments['printer'];
} else {
$printerClass = 'PHPUnit_TextUI_ResultPrinter';
if (isset($arguments['printer']) && is_string($arguments['printer']) && class_exists($arguments['printer'], false)) {
$class = new ReflectionClass($arguments['printer']);
if ($class->isSubclassOf('PHPUnit_TextUI_ResultPrinter')) {
$printerClass = $arguments['printer'];
}
}
$this->printer = new $printerClass(isset($arguments['stderr']) ? 'php://stderr' : null, $arguments['verbose'], $arguments['colors'], $arguments['debug'], $arguments['columns']);
}
}
if (!$this->printer instanceof PHPUnit_Util_Log_TAP) {
$this->printer->write(PHPUnit_Runner_Version::getVersionString() . "\n");
self::$versionStringPrinted = true;
if ($arguments['verbose']) {
$this->printer->write(sprintf("\nRuntime:\t%s", $this->runtime->getNameWithVersion()));
if ($this->runtime->hasXdebug()) {
$this->printer->write(sprintf(' with Xdebug %s', phpversion('xdebug')));
}
if (isset($arguments['configuration'])) {
$this->printer->write(sprintf("\nConfiguration:\t%s", $arguments['configuration']->getFilename()));
}
$this->printer->write("\n");
}
if (isset($arguments['deprecatedStrictModeOption'])) {
print "Warning:\tDeprecated option \"--strict\" used\n";
} elseif (isset($arguments['deprecatedStrictModeSetting'])) {
print "Warning:\tDeprecated configuration setting \"strict\" used\n";
}
if (isset($arguments['deprecatedSeleniumConfiguration'])) {
print "Warning:\tDeprecated configuration setting \"selenium\" used\n";
}
}
foreach ($arguments['listeners'] as $listener) {
$result->addListener($listener);
}
$result->addListener($this->printer);
if (isset($arguments['testdoxHTMLFile'])) {
$result->addListener(new PHPUnit_Util_TestDox_ResultPrinter_HTML($arguments['testdoxHTMLFile']));
}
if (isset($arguments['testdoxTextFile'])) {
$result->addListener(new PHPUnit_Util_TestDox_ResultPrinter_Text($arguments['testdoxTextFile']));
}
$codeCoverageReports = 0;
if (isset($arguments['coverageClover'])) {
$codeCoverageReports++;
}
if (isset($arguments['coverageCrap4J'])) {
$codeCoverageReports++;
}
if (isset($arguments['coverageHtml'])) {
$codeCoverageReports++;
}
if (isset($arguments['coveragePHP'])) {
$codeCoverageReports++;
}
if (isset($arguments['coverageText'])) {
$codeCoverageReports++;
}
if (isset($arguments['coverageXml'])) {
$codeCoverageReports++;
}
if (!$this->printer instanceof PHPUnit_Util_Log_TAP) {
if ($codeCoverageReports > 0 && !$this->codeCoverageFilter->hasWhitelist()) {
$this->printer->write("Warning:\tNo whitelist configured for code coverage\n");
}
$this->printer->write("\n");
}
if ($codeCoverageReports > 0 && (!extension_loaded('tokenizer') || !$this->runtime->canCollectCodeCoverage())) {
if (!extension_loaded('tokenizer')) {
$this->showExtensionNotLoadedMessage('tokenizer', 'No code coverage will be generated.');
} elseif (!extension_loaded('Xdebug')) {
$this->showExtensionNotLoadedMessage('Xdebug', 'No code coverage will be generated.');
}
$codeCoverageReports = 0;
}
if ($codeCoverageReports > 0) {
$codeCoverage = new PHP_CodeCoverage(null, $this->codeCoverageFilter);
$codeCoverage->setAddUncoveredFilesFromWhitelist($arguments['addUncoveredFilesFromWhitelist']);
$codeCoverage->setCheckForUnintentionallyCoveredCode($arguments['strictCoverage']);
$codeCoverage->setProcessUncoveredFilesFromWhitelist($arguments['processUncoveredFilesFromWhitelist']);
if (isset($arguments['forceCoversAnnotation'])) {
$codeCoverage->setForceCoversAnnotation($arguments['forceCoversAnnotation']);
}
if (isset($arguments['mapTestClassNameToCoveredClassName'])) {
$codeCoverage->setMapTestClassNameToCoveredClassName($arguments['mapTestClassNameToCoveredClassName']);
}
$result->setCodeCoverage($codeCoverage);
}
if ($codeCoverageReports > 1) {
if (isset($arguments['cacheTokens'])) {
$codeCoverage->setCacheTokens($arguments['cacheTokens']);
}
}
if (isset($arguments['jsonLogfile'])) {
$result->addListener(new PHPUnit_Util_Log_JSON($arguments['jsonLogfile']));
}
if (isset($arguments['tapLogfile'])) {
$result->addListener(new PHPUnit_Util_Log_TAP($arguments['tapLogfile']));
}
if (isset($arguments['junitLogfile'])) {
$result->addListener(new PHPUnit_Util_Log_JUnit($arguments['junitLogfile'], $arguments['logIncompleteSkipped']));
}
$result->beStrictAboutTestsThatDoNotTestAnything($arguments['reportUselessTests']);
$result->beStrictAboutOutputDuringTests($arguments['disallowTestOutput']);
$result->beStrictAboutTodoAnnotatedTests($arguments['disallowTodoAnnotatedTests']);
$result->beStrictAboutTestSize($arguments['enforceTimeLimit']);
$result->setTimeoutForSmallTests($arguments['timeoutForSmallTests']);
$result->setTimeoutForMediumTests($arguments['timeoutForMediumTests']);
$result->setTimeoutForLargeTests($arguments['timeoutForLargeTests']);
if ($suite instanceof PHPUnit_Framework_TestSuite) {
$suite->setRunTestInSeparateProcess($arguments['processIsolation']);
}
// --------------------------------------------
$result->addListener(new PHPUnit_Framework_FailureListener());
// -----------------------------------------------
$suite->run($result);
unset($suite);
$result->flushListeners();
if ($this->printer instanceof PHPUnit_TextUI_ResultPrinter) {
$this->printer->printResult($result);
}
if (isset($codeCoverage)) {
if (isset($arguments['coverageClover'])) {
$this->printer->write("\nGenerating code coverage report in Clover XML format ...");
$writer = new PHP_CodeCoverage_Report_Clover();
$writer->process($codeCoverage, $arguments['coverageClover']);
$this->printer->write(" done\n");
unset($writer);
}
if (isset($arguments['coverageCrap4J'])) {
$this->printer->write("\nGenerating Crap4J report XML file ...");
$writer = new PHP_CodeCoverage_Report_Crap4j();
$writer->process($codeCoverage, $arguments['coverageCrap4J']);
$this->printer->write(" done\n");
unset($writer);
}
if (isset($arguments['coverageHtml'])) {
$this->printer->write("\nGenerating code coverage report in HTML format ...");
$writer = new PHP_CodeCoverage_Report_HTML($arguments['reportLowUpperBound'], $arguments['reportHighLowerBound'], sprintf(' and <a href="http://phpunit.de/">PHPUnit %s</a>', PHPUnit_Runner_Version::id()));
$writer->process($codeCoverage, $arguments['coverageHtml']);
$this->printer->write(" done\n");
unset($writer);
}
if (isset($arguments['coveragePHP'])) {
$this->printer->write("\nGenerating code coverage report in PHP format ...");
$writer = new PHP_CodeCoverage_Report_PHP();
$writer->process($codeCoverage, $arguments['coveragePHP']);
$this->printer->write(" done\n");
unset($writer);
}
if (isset($arguments['coverageText'])) {
if ($arguments['coverageText'] == 'php://stdout') {
$outputStream = $this->printer;
$colors = $arguments['colors'];
} else {
$outputStream = new PHPUnit_Util_Printer($arguments['coverageText']);
$colors = false;
}
$processor = new PHP_CodeCoverage_Report_Text($arguments['reportLowUpperBound'], $arguments['reportHighLowerBound'], $arguments['coverageTextShowUncoveredFiles'], $arguments['coverageTextShowOnlySummary']);
$outputStream->write($processor->process($codeCoverage, $colors));
}
if (isset($arguments['coverageXml'])) {
$this->printer->write("\nGenerating code coverage report in PHPUnit XML format ...");
$writer = new PHP_CodeCoverage_Report_XML();
$writer->process($codeCoverage, $arguments['coverageXml']);
$this->printer->write(" done\n");
unset($writer);
}
}
return $result;
}
/**
* Runs supplied tests through PHPUnit.
*
* @param array $tests The directories/filenames containing the tests to be run through PHPUnit.
* @access public
* @return string
*/
public function run($tests)
{
$suite = new PHPUnit_Framework_TestSuite();
$suite->setBackupGlobals(false);
$tests = $this->_parse_tests($tests);
$original_classes = get_declared_classes();
foreach ($tests as $test) {
require $test;
}
$new_classes = get_declared_classes();
$tests = array_diff($new_classes, $original_classes);
foreach ($tests as $test) {
if ($this->_classname_only($test) == 'PHPUnit_Framework_TestCase') {
continue;
}
// if ( stripos($this->_classname_only($test), 'test') !== false ) {
// match phpunit automatic XML Test Suite -- only *Test classes
if (substr($this->_classname_only($test), -4) == 'Test') {
$suite->addTestSuite($test);
}
}
$result = new PHPUnit_Framework_TestResult();
$listener = new ArrayLog();
$result->addListener($listener);
// We need to temporarily turn off html_errors to ensure correct parsing of test debug output
$html_errors = ini_get('html_errors');
ob_start();
ini_set('html_errors', 0);
$suite->run($result);
//$results = ob_get_contents();
$results = ob_get_clean();
ini_set('html_errors', $html_errors);
//ob_end_clean();
$results = $listener->getResults();
//var_dump($results);
//$results=json_decode($results);
//var_dump($results);
//var_dump(json_last_error());
return $results;
}
private function runSuite(PHPUnit_Framework_TestSuite $suite)
{
if ($this->arguments['backupGlobals'] === false) {
$suite->setBackupGlobals(false);
}
if ($this->arguments['backupStaticAttributes'] === true) {
$suite->setBackupStaticAttributes(true);
}
if (is_integer($this->arguments['repeat'])) {
$suite = new PHPUnit_Extensions_RepeatedTest($suite, $this->arguments['repeat'], $this->arguments['filter'], $this->arguments['groups'], $this->arguments['excludeGroups'], $this->arguments['processIsolation']);
}
$suite->run($this->result, $this->arguments['filter'], $this->arguments['groups'], $this->arguments['excludeGroups'], $this->arguments['processIsolation']);
}
private function getTestSuite()
{
$suite = new \PHPUnit_Framework_TestSuite('All tests');
// Note: This code won't work unless the backup globals option is disabled
// see: http://www.phpunit.de/ticket/899
$suite->setBackupGlobals(false);
if ($this->files instanceof \PHPUnit_Framework_Test) {
$suite->addTest($this->files);
} else {
$suite->addTestFiles($this->files);
}
return $suite;
}
