/**
* @param PHP_CodeCoverage $coverage
* @param string $target
*/
public function process(PHP_CodeCoverage $coverage, $target)
{
$target = $this->getDirectory($target);
$report = $coverage->getReport();
unset($coverage);
if (!isset($_SERVER['REQUEST_TIME'])) {
$_SERVER['REQUEST_TIME'] = time();
}
$date = date('D M j G:i:s T Y', $_SERVER['REQUEST_TIME']);
$dashboard = new PHP_CodeCoverage_Report_HTML_Renderer_Dashboard($this->templatePath, $this->generator, $date, $this->lowUpperBound, $this->highLowerBound);
$directory = new PHP_CodeCoverage_Report_HTML_Renderer_Directory($this->templatePath, $this->generator, $date, $this->lowUpperBound, $this->highLowerBound);
$file = new PHP_CodeCoverage_Report_HTML_Renderer_File($this->templatePath, $this->generator, $date, $this->lowUpperBound, $this->highLowerBound);
$directory->render($report, $target . 'index.html');
$dashboard->render($report, $target . 'dashboard.html');
foreach ($report as $node) {
$id = $node->getId();
if ($node instanceof PHP_CodeCoverage_Report_Node_Directory) {
if (!file_exists($target . $id)) {
mkdir($target . $id, 0777, true);
}
$directory->render($node, $target . $id . '/index.html');
$dashboard->render($node, $target . $id . '/dashboard.html');
} else {
$dir = dirname($target . $id);
if (!file_exists($dir)) {
mkdir($dir, 0777, true);
}
$file->render($node, $target . $id . '.html');
}
}
$this->copyFiles($target);
}
public function afterExample(ExampleEvent $event)
{
if (!$this->enabled) {
return;
}
$this->coverage->stop();
}
protected function getCoverageForFileWithIgnoredLines()
{
$coverage = new PHP_CodeCoverage($this->setUpXdebugStubForFileWithIgnoredLines(), new PHP_CodeCoverage_Filter());
$coverage->start('FileWithIgnoredLines', TRUE);
$coverage->stop();
return $coverage;
}
/**
* Test merge for code coverage library 3 version
*
* @requires function \PHP_CodeCoverage::merge
*/
public function testSimpleMergeLegacy()
{
$firstFile = PARATEST_ROOT . '/src/ParaTest/Logging/LogInterpreter.php';
$secondFile = PARATEST_ROOT . '/src/ParaTest/Logging/MetaProvider.php';
$filter = new \PHP_CodeCoverage_Filter();
$filter->addFilesToWhitelist([$firstFile, $secondFile]);
$coverage1 = new \PHP_CodeCoverage(null, $filter);
$coverage1->append(array($firstFile => array(35 => 1), $secondFile => array(34 => 1)), 'Test1');
$coverage2 = new \PHP_CodeCoverage(null, $filter);
$coverage2->append(array($firstFile => array(35 => 1, 36 => 1)), 'Test2');
$merger = new CoverageMerger();
$this->call($merger, 'addCoverage', $coverage1);
$this->call($merger, 'addCoverage', $coverage2);
/** @var \PHP_CodeCoverage $coverage */
$coverage = $this->getObjectValue($merger, 'coverage');
$this->assertInstanceOf('\\PHP_CodeCoverage', $coverage);
$data = $coverage->getData();
$this->assertCount(2, $data[$firstFile][35]);
$this->assertEquals('Test1', $data[$firstFile][35][0]);
$this->assertEquals('Test2', $data[$firstFile][35][1]);
$this->assertCount(1, $data[$firstFile][36]);
$this->assertEquals('Test2', $data[$firstFile][36][0]);
$this->assertCount(1, $data[$secondFile][34]);
$this->assertEquals('Test1', $data[$secondFile][34][0]);
}
protected function getCoverageForClassWithAnonymousFunction()
{
$coverage = new PHP_CodeCoverage($this->setUpXdebugStubForClassWithAnonymousFunction(), new PHP_CodeCoverage_Filter());
$coverage->start('ClassWithAnonymousFunction', true);
$coverage->stop();
return $coverage;
}
/**
* @param \PHP_CodeCoverage|CodeCoverage $coverage
*/
private function addCoverage($coverage)
{
if (null === $this->coverage) {
$this->coverage = $coverage;
} else {
$this->coverage->merge($coverage);
}
}
/**
* @param PHP_CodeCoverage $coverage
*/
public function create(PHP_CodeCoverage $coverage)
{
$files = $coverage->getData();
$commonPath = $this->reducePaths($files);
$root = new PHP_CodeCoverage_Report_Node_Directory($commonPath, null);
$this->addItems($root, $this->buildDirectoryStructure($files), $coverage->getTests(), $coverage->getCacheTokens());
return $root;
}
/**
* @return \PHP_CodeCoverage
*/
public function coverage()
{
$coverage = new \PHP_CodeCoverage();
$coverage->setData($this->data);
$coverage->setTests($this->tests);
$filter = $coverage->filter();
$filter->setBlacklistedFiles($this->blackList);
$filter->setWhitelistedFiles($this->whiteList);
return $coverage;
}
public function parseReport(\PHP_CodeCoverage $report)
{
$classes = array();
foreach ($report->getData() as $filename => $coverage) {
try {
$classes[] = $this->parseClass($filename, $coverage);
} catch (ParserException $e) {
echo "Skipping class " . $filename . ", failed to parse\n";
}
}
return $classes;
}
/**
* Stop or pause coverage proccess
*/
protected function _stop()
{
if ($this->_isStart && $this->_coverage) {
$this->_isStart = false;
$this->_coverage->stop();
}
}
/**
* @param Closure $callback
* @return mixed
*/
public function init(\Closure $callback)
{
if ($this->_coverage) {
$this->_coverage->start($this->_covHash, true);
}
return $callback();
}
public function process(PHP_CodeCoverage $coverage, $target)
{
if (substr($target, -1, 1) != DIRECTORY_SEPARATOR) {
$target .= DIRECTORY_SEPARATOR;
}
$this->target = $target;
$this->initTargetDirectory($target);
$report = $coverage->getReport();
$this->project = new PHP_CodeCoverage_Report_XML_Project($coverage->getReport()->getName());
$this->processTests($coverage->getTests());
$this->processDirectory($report, $this->project);
$index = $this->project->asDom();
$index->formatOutput = true;
$index->preserveWhiteSpace = false;
$index->save($target . '/index.xml');
}
/**
* @param PHP_CodeCoverage $coverage
* @param string $target
* @return string
*/
public function process(PHP_CodeCoverage $coverage, $target = null)
{
$filter = $coverage->filter();
$output = sprintf('<?php
$coverage = new PHP_CodeCoverage;
$coverage->setData(%s);
$coverage->setTests(%s);
$filter = $coverage->filter();
$filter->setWhitelistedFiles(%s);
return $coverage;', var_export($coverage->getData(true), 1), var_export($coverage->getTests(), 1), var_export($filter->getWhitelistedFiles(), 1));
if ($target !== null) {
return file_put_contents($target, $output);
} else {
return $output;
}
}
/**
* @covers PHP_CodeCoverage::performUnexecutedCoveredCodeCheck
* @expectedException PHP_CodeCoverage_CoveredCodeNotExecutedException
*/
public function testAppendThrowsExceptionIfUsedCodeWasNotExecuted()
{
$this->coverage->filter()->addDirectoryToWhitelist(TEST_FILES_PATH);
$this->coverage->setCheckForUnexecutedCoveredCode(true);
$data = [TEST_FILES_PATH . 'BankAccount.php' => [29 => -1, 31 => -1]];
$linesToBeCovered = [TEST_FILES_PATH . 'BankAccount.php' => [29, 31]];
$linesToBeUsed = [TEST_FILES_PATH . 'BankAccount.php' => [22, 24]];
$this->coverage->append($data, 'File1.php', true, $linesToBeCovered, $linesToBeUsed);
}
public static function suite()
{
$srcDir = dirname(dirname(dirname(__DIR__))) . '/src/Pyrus/AtomicFileTransaction/Transaction';
// Setup coverage filters
$filter = PHP_CodeCoverage::getInstance()->filter();
$filter->addDirectoryToWhitelist($srcDir);
// Build and return test suite
return new PHPUnit_Extensions_PhptTestSuite(__DIR__);
}
public function get_reports()
{
$this->reports = get_transient('json_testhelper_coverage');
if (empty($this->reports)) {
return new WP_Error('json_testhelper_no_report', __('No report data available', 'json_testhelper'), array('status' => 400));
}
if (!class_exists('PHP_CodeCoverage')) {
return new WP_Error('json_testhelper_missing_codecoverage', __('The CodeCoverage classes are missing', 'json_testhelper'), array('status' => 500));
}
$master = new PHP_CodeCoverage();
foreach ($this->reports as $report) {
$master->merge($report);
}
// Clean up
delete_transient('json_testhelper_coverage');
$data = array('reports' => count($this->reports), 'data' => serialize($master));
return $data;
}
/**
* Renders and outputs the code coverage report.
*
* @return void
*/
protected function renderCodeCoverage()
{
$this->coverage->stop();
$codeCoverageDirectory = PATH_site . 'typo3temp/codecoverage/';
if (!is_readable($codeCoverageDirectory) && !is_dir($codeCoverageDirectory)) {
t3lib_div::mkdir($codeCoverageDirectory);
}
$coverageReport = new PHP_CodeCoverage_Report_HTML();
$coverageReport->process($this->coverage, $codeCoverageDirectory);
$this->outputService->output('<p><a target="_blank" href="../typo3temp/codecoverage/index.html">' . 'Click here to access the Code Coverage report</a></p>' . '<p>Memory peak usage: ' . t3lib_div::formatSize(memory_get_peak_usage()) . 'B<p/>');
}
public function testSimpleMerge()
{
$firstFile = PARATEST_ROOT . '/src/ParaTest/Logging/LogInterpreter.php';
$secondFile = PARATEST_ROOT . '/src/ParaTest/Logging/MetaProvider.php';
$coverage1 = new \PHP_CodeCoverage();
$coverage1->append(array($firstFile => array(35 => 1), $secondFile => array(34 => 1)), 'Test1');
$coverage2 = new \PHP_CodeCoverage();
$coverage2->append(array($firstFile => array(35 => 1, 36 => 1)), 'Test2');
$merger = new CoverageMerger();
$merger->addCoverage($coverage1);
$merger->addCoverage($coverage2);
$coverage = $merger->getCoverage();
$data = $coverage->getData();
$this->assertEquals(2, count($data[$firstFile][35]));
$this->assertEquals('Test1', $data[$firstFile][35][0]);
$this->assertEquals('Test2', $data[$firstFile][35][1]);
$this->assertEquals(1, count($data[$firstFile][36]));
$this->assertEquals('Test2', $data[$firstFile][36][0]);
$this->assertEquals(1, count($data[$secondFile][34]));
$this->assertEquals('Test1', $data[$secondFile][34][0]);
}
public static function handleError($level, $message, $file, $line)
{
$isFiltered = false;
if (version_compare(PHPUnit_Runner_Version::id(), '3.5.0') >= 0) {
$isFiltered = PHP_CodeCoverage::getInstance()->filter()->isFiltered($file, array(), true);
} else {
$isFiltered = PHPUnit_Util_Filter::isFiltered($file, true, true);
}
if (!$isFiltered) {
return PHPUnit_Util_ErrorHandler::handleError($level, $message, $file, $line);
}
}
function __begin_coverage()
{
global $__coverage;
if (isset($__coverage)) {
return;
}
if (!getenv("TEST_COVERAGE")) {
return;
}
require_once "PHP/CodeCoverage.php";
require_once "PHP/CodeCoverage/Driver.php";
require_once "PHP/CodeCoverage/Driver/Xdebug.php";
require_once "PHP/CodeCoverage/Filter.php";
require_once "PHP/CodeCoverage/Util.php";
require_once "File/Iterator/Facade.php";
require_once "File/Iterator/Factory.php";
require_once "File/Iterator.php";
$__coverage = new PHP_CodeCoverage();
$__coverage->start('test');
$__coverage->filter()->addDirectoryToWhitelist(realpath(dirname(__FILE__) . "/../Modyllic"));
register_shutdown_function('__end_coverage');
}
/**
* Extract the data from the PHPUnit code coverage
*
* @param PHP_CodeCoverage $codeCoverage
*
* @return array
*/
private function getCoverageStats(\PHP_CodeCoverage $codeCoverage)
{
$report = $codeCoverage->getReport();
$classCoverage = [];
foreach ($report as $item) {
if (!$item instanceof \PHP_CodeCoverage_Report_Node_File) {
continue;
}
$classes = $item->getClassesAndTraits();
foreach ($classes as $className => $class) {
$classStatements = 0;
$coveredClassStatements = 0;
$coveredMethods = 0;
$classMethods = 0;
foreach ($class['methods'] as $method) {
if ($method['executableLines'] == 0) {
continue;
}
$classMethods++;
$classStatements += $method['executableLines'];
$coveredClassStatements += $method['executedLines'];
if ($method['coverage'] == 100) {
$coveredMethods++;
}
}
if (!empty($class['package']['namespace'])) {
$namespace = '\\' . $class['package']['namespace'] . '::';
} elseif (!empty($class['package']['fullPackage'])) {
$namespace = '@' . $class['package']['fullPackage'] . '::';
} else {
$namespace = '';
}
if ($coveredClassStatements != 0) {
$classCoverage[$namespace . $className] = ['namespace' => $namespace, 'className ' => $className, 'methodsCovered' => $coveredMethods, 'methodCount' => $classMethods, 'statementsCovered' => $coveredClassStatements, 'statementCount' => $classStatements];
}
}
}
return ['classes' => ['total' => $report->getNumClassesAndTraits(), 'tested' => $report->getNumTestedClassesAndTraits()], 'methods' => ['total' => $report->getNumMethods(), 'tested' => $report->getNumTestedMethods()], 'lines' => ['total' => $report->getNumExecutableLines(), 'tested' => $report->getNumExecutedLines()], 'coverage' => $classCoverage];
}
public function getOutput(\PHP_CodeCoverage $coverage)
{
$output = '';
$report = $coverage->getReport();
foreach ($report as $item) {
if (!$item instanceof \PHP_CodeCoverage_Report_Node_File) {
continue;
}
$coverageData = $item->getCoverageData();
$codeLines = explode(PHP_EOL, file_get_contents($item->getPath()));
$widestLine = $this->getWidestLine($codeLines);
$reportLines = [];
$i = 1;
foreach ($codeLines as $line) {
if (array_key_exists($i, $coverageData)) {
$numTests = count($coverageData[$i]);
if ($coverageData[$i] === null) {
$code = self::COVERAGE_META;
} elseif ($numTests == 0) {
$code = self::COVERAGE_NOT_COVERED;
} else {
$code = self::COVERAGE_COVERED;
}
} else {
$code = self::COVERAGE_META;
}
$reportLines[] = ['line' => $line, 'code' => $code];
++$i;
}
$classCoverage = $this->getClassCoverage($item->getClassesAndTraits());
$totalCoverage = $this->getTotalCoverage($classCoverage);
$output .= $this->renderClassCoverage($classCoverage);
if (!$totalCoverage) {
$output .= $this->renderCodeCoverage($reportLines, $widestLine);
}
}
return $output;
}
protected function prepare_harness()
{
if ($this->ver_phpunit < 3.5) {
require_once 'PHPUnit/Framework.php';
require_once 'PHPUnit/TextUI/ResultPrinter.php';
require_once 'PHPUnit/TextUI/Command.php';
PHPUnit_Util_Filter::addDirectoryToFilter($this->root, '.php', 'PHPUNIT', '');
} elseif ($this->ver_phpunit < 3.6) {
require_once 'PHPUnit/Autoload.php';
require_once 'PHP/CodeCoverage.php';
PHP_CodeCoverage::getInstance()->filter()->addDirectoryToBlacklist($this->root, '.php', '', 'PHPUNIT');
} else {
// PHPUnit 3.6+
/**
* Change to support PHPUnit 4+
* These libraries are loaded in via phpunit.phar or don't exist in PHPUnit 4+
*/
//require_once( 'PHPUnit/Autoload.php' );
//require_once( 'PHP/CodeCoverage.php' );
$this->add_directory_to_blacklist($this->root, '.php');
}
}
/**
* @param PHP_CodeCoverage $coverage
* @param string $target
* @param string $name
* @return string
*/
public function process(PHP_CodeCoverage $coverage, $target = NULL, $name = NULL)
{
$document = new DOMDocument('1.0', 'UTF-8');
$document->formatOutput = TRUE;
$root = $document->createElement('coverage');
$root->setAttribute('generated', (int) $_SERVER['REQUEST_TIME']);
$document->appendChild($root);
$project = $document->createElement('project');
$project->setAttribute('timestamp', (int) $_SERVER['REQUEST_TIME']);
if (is_string($name)) {
$project->setAttribute('name', $name);
}
$root->appendChild($project);
$files = $coverage->getSummary();
$packages = array();
$projectStatistics = array('files' => 0, 'loc' => 0, 'ncloc' => 0, 'classes' => 0, 'methods' => 0, 'coveredMethods' => 0, 'conditionals' => 0, 'coveredConditionals' => 0, 'statements' => 0, 'coveredStatements' => 0);
foreach ($files as $filename => $data) {
$namespace = 'global';
if (file_exists($filename)) {
$fileStatistics = array('classes' => 0, 'methods' => 0, 'coveredMethods' => 0, 'conditionals' => 0, 'coveredConditionals' => 0, 'statements' => 0, 'coveredStatements' => 0);
$file = $document->createElement('file');
$file->setAttribute('name', $filename);
$tokens = PHP_Token_Stream_CachingFactory::get($filename);
$classesInFile = $tokens->getClasses();
$linesOfCode = $tokens->getLinesOfCode();
unset($tokens);
$ignoredLines = PHP_CodeCoverage_Util::getLinesToBeIgnored($filename);
$lines = array();
foreach ($classesInFile as $className => $_class) {
$classStatistics = array('methods' => 0, 'coveredMethods' => 0, 'conditionals' => 0, 'coveredConditionals' => 0, 'statements' => 0, 'coveredStatements' => 0);
foreach ($_class['methods'] as $methodName => $method) {
$classStatistics['methods']++;
$methodCount = 0;
$methodLines = 0;
$methodLinesCovered = 0;
for ($i = $method['startLine']; $i <= $method['endLine']; $i++) {
if (isset($ignoredLines[$i])) {
continue;
}
$add = TRUE;
$count = 0;
if (isset($files[$filename][$i])) {
if ($files[$filename][$i] != -2) {
$classStatistics['statements']++;
$methodLines++;
}
if (is_array($files[$filename][$i])) {
$classStatistics['coveredStatements']++;
$methodLinesCovered++;
$count = count($files[$filename][$i]);
} else {
if ($files[$filename][$i] == -2) {
$add = FALSE;
}
}
} else {
$add = FALSE;
}
$methodCount = max($methodCount, $count);
if ($add) {
$lines[$i] = array('count' => $count, 'type' => 'stmt');
}
}
if ($methodCount > 0) {
$classStatistics['coveredMethods']++;
}
$lines[$method['startLine']] = array('count' => $methodCount, 'crap' => PHP_CodeCoverage_Util::crap($method['ccn'], PHP_CodeCoverage_Util::percent($methodLinesCovered, $methodLines)), 'type' => 'method', 'name' => $methodName);
}
$package = PHP_CodeCoverage_Util::getPackageInformation($className, $_class['docblock']);
if (!empty($package['namespace'])) {
$namespace = $package['namespace'];
}
$class = $document->createElement('class');
$class->setAttribute('name', $className);
$class->setAttribute('namespace', $namespace);
if (!empty($package['fullPackage'])) {
$class->setAttribute('fullPackage', $package['fullPackage']);
}
if (!empty($package['category'])) {
$class->setAttribute('category', $package['category']);
}
if (!empty($package['package'])) {
$class->setAttribute('package', $package['package']);
}
if (!empty($package['subpackage'])) {
$class->setAttribute('subpackage', $package['subpackage']);
}
$file->appendChild($class);
$metrics = $document->createElement('metrics');
$metrics->setAttribute('methods', $classStatistics['methods']);
$metrics->setAttribute('coveredmethods', $classStatistics['coveredMethods']);
$metrics->setAttribute('conditionals', $classStatistics['conditionals']);
$metrics->setAttribute('coveredconditionals', $classStatistics['coveredConditionals']);
$metrics->setAttribute('statements', $classStatistics['statements']);
$metrics->setAttribute('coveredstatements', $classStatistics['coveredStatements']);
$metrics->setAttribute('elements', $classStatistics['conditionals'] + $classStatistics['statements'] + $classStatistics['methods']);
$metrics->setAttribute('coveredelements', $classStatistics['coveredConditionals'] + $classStatistics['coveredStatements'] + $classStatistics['coveredMethods']);
$class->appendChild($metrics);
$fileStatistics['methods'] += $classStatistics['methods'];
$fileStatistics['coveredMethods'] += $classStatistics['coveredMethods'];
$fileStatistics['conditionals'] += $classStatistics['conditionals'];
$fileStatistics['coveredConditionals'] += $classStatistics['coveredConditionals'];
$fileStatistics['statements'] += $classStatistics['statements'];
$fileStatistics['coveredStatements'] += $classStatistics['coveredStatements'];
$fileStatistics['classes']++;
}
foreach ($data as $_line => $_data) {
if (isset($lines[$_line]) || isset($ignoredLines[$_line])) {
continue;
}
if ($_data != -2) {
$fileStatistics['statements']++;
if (is_array($_data)) {
$count = count($_data);
$fileStatistics['coveredStatements']++;
} else {
$count = 0;
}
$lines[$_line] = array('count' => $count, 'type' => 'stmt');
}
}
ksort($lines);
foreach ($lines as $_line => $_data) {
if (isset($ignoredLines[$_line])) {
continue;
}
$line = $document->createElement('line');
$line->setAttribute('num', $_line);
$line->setAttribute('type', $_data['type']);
if (isset($_data['name'])) {
$line->setAttribute('name', $_data['name']);
}
if (isset($_data['crap'])) {
$line->setAttribute('crap', $_data['crap']);
}
$line->setAttribute('count', $_data['count']);
$file->appendChild($line);
}
$metrics = $document->createElement('metrics');
$metrics->setAttribute('loc', $linesOfCode['loc']);
$metrics->setAttribute('ncloc', $linesOfCode['ncloc']);
$metrics->setAttribute('classes', $fileStatistics['classes']);
$metrics->setAttribute('methods', $fileStatistics['methods']);
$metrics->setAttribute('coveredmethods', $fileStatistics['coveredMethods']);
$metrics->setAttribute('conditionals', $fileStatistics['conditionals']);
$metrics->setAttribute('coveredconditionals', $fileStatistics['coveredConditionals']);
$metrics->setAttribute('statements', $fileStatistics['statements']);
$metrics->setAttribute('coveredstatements', $fileStatistics['coveredStatements']);
$metrics->setAttribute('elements', $fileStatistics['conditionals'] + $fileStatistics['statements'] + $fileStatistics['methods']);
$metrics->setAttribute('coveredelements', $fileStatistics['coveredConditionals'] + $fileStatistics['coveredStatements'] + $fileStatistics['coveredMethods']);
$file->appendChild($metrics);
if ($namespace == 'global') {
$project->appendChild($file);
} else {
if (!isset($packages[$namespace])) {
$packages[$namespace] = $document->createElement('package');
$packages[$namespace]->setAttribute('name', $namespace);
$project->appendChild($packages[$namespace]);
}
$packages[$namespace]->appendChild($file);
}
$projectStatistics['loc'] += $linesOfCode['loc'];
$projectStatistics['ncloc'] += $linesOfCode['ncloc'];
$projectStatistics['classes'] += $fileStatistics['classes'];
$projectStatistics['methods'] += $fileStatistics['methods'];
$projectStatistics['coveredMethods'] += $fileStatistics['coveredMethods'];
$projectStatistics['conditionals'] += $fileStatistics['conditionals'];
$projectStatistics['coveredConditionals'] += $fileStatistics['coveredConditionals'];
$projectStatistics['statements'] += $fileStatistics['statements'];
$projectStatistics['coveredStatements'] += $fileStatistics['coveredStatements'];
$projectStatistics['files']++;
}
}
$metrics = $document->createElement('metrics');
$metrics->setAttribute('files', $projectStatistics['files']);
$metrics->setAttribute('loc', $projectStatistics['loc']);
$metrics->setAttribute('ncloc', $projectStatistics['ncloc']);
$metrics->setAttribute('classes', $projectStatistics['classes']);
$metrics->setAttribute('methods', $projectStatistics['methods']);
$metrics->setAttribute('coveredmethods', $projectStatistics['coveredMethods']);
$metrics->setAttribute('conditionals', $projectStatistics['conditionals']);
$metrics->setAttribute('coveredconditionals', $projectStatistics['coveredConditionals']);
$metrics->setAttribute('statements', $projectStatistics['statements']);
$metrics->setAttribute('coveredstatements', $projectStatistics['coveredStatements']);
$metrics->setAttribute('elements', $projectStatistics['conditionals'] + $projectStatistics['statements'] + $projectStatistics['methods']);
$metrics->setAttribute('coveredelements', $projectStatistics['coveredConditionals'] + $projectStatistics['coveredStatements'] + $projectStatistics['coveredMethods']);
$project->appendChild($metrics);
if ($target !== NULL) {
return $document->save($target);
} else {
return $document->saveXML();
}
}
/**
* @covers PHP_CodeCoverage::getData
* @covers PHP_CodeCoverage::merge
*/
public function testMerge2()
{
$driver = $this->getMockBuilder('PHP_CodeCoverage_Driver')->setConstructorArgs(array(new PHP_CodeCoverage_Filter(), new PHP_CodeCoverage_Parser()))->getMockForAbstractClass();
$coverage = new PHP_CodeCoverage($driver, new PHP_CodeCoverage_Filter());
$coverage->merge($this->getCoverageForBankAccount());
$this->assertEquals($this->getExpectedDataArrayForBankAccount(), $coverage->getData());
}
/**
* @param PHPUnit_Framework_Test $suite
* @param array $arguments
* @return PHPUnit_Framework_TestResult
*/
public function doRun(PHPUnit_Framework_Test $suite, array $arguments = array())
{
$this->handleConfiguration($arguments);
$this->processSuiteFilters($suite, $arguments);
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']);
}
$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;
}
require 'vendor/phpunit/php-text-template/src/Template.php';
require 'vendor/phpunit/php-token-stream/src/Token.php';
require 'vendor/phpunit/php-code-coverage/src/CodeCoverage/Driver.php';
require 'vendor/phpunit/php-code-coverage/src/CodeCoverage/Driver/Xdebug.php';
require 'vendor/sebastian/environment/src/Runtime.php';
require 'vendor/phpunit/php-code-coverage/src/CodeCoverage.php';
require 'vendor/phpunit/php-file-iterator/src/Iterator.php';
require 'vendor/phpunit/php-file-iterator/src/Factory.php';
require 'vendor/phpunit/php-file-iterator/src/Facade.php';
require 'vendor/phpunit/php-code-coverage/src/CodeCoverage/Filter.php';
$filter = new PHP_CodeCoverage_Filter();
$filter->addFileToBlacklist('fmt.php');
$filter->addFileToBlacklist('fmt.src.php');
$filter->addFileToBlacklist('test.php');
$filter->addDirectoryToBlacklist('vendor');
$coverage = new PHP_CodeCoverage(null, $filter);
}
$testNumber = '';
if (isset($opt['testNumber'])) {
if (is_numeric($opt['testNumber'])) {
$testNumber = sprintf('%03d', (int) $opt['testNumber']);
} else {
$testNumber = sprintf('%s', $opt['testNumber']);
}
}
$bogomips = null;
if (isset($opt['baseline'])) {
echo 'Calculating baseline... ';
$bogomips = bogomips();
echo 'done', PHP_EOL;
}
/**
* Constructs a new TestSuite:
*
* - PHPUnit_Framework_TestSuite() constructs an empty TestSuite.
*
* - PHPUnit_Framework_TestSuite(ReflectionClass) constructs a
* TestSuite from the given class.
*
* - PHPUnit_Framework_TestSuite(ReflectionClass, String)
* constructs a TestSuite from the given class with the given
* name.
*
* - PHPUnit_Framework_TestSuite(String) either constructs a
* TestSuite from the given class (if the passed string is the
* name of an existing class) or constructs an empty TestSuite
* with the given name.
*
* @param mixed $theClass
* @param string $name
* @throws InvalidArgumentException
*/
public function __construct($theClass = '', $name = '')
{
$argumentsValid = FALSE;
if (is_object($theClass) && $theClass instanceof ReflectionClass) {
$argumentsValid = TRUE;
} else {
if (is_string($theClass) && $theClass !== '' && class_exists($theClass, FALSE)) {
$argumentsValid = TRUE;
if ($name == '') {
$name = $theClass;
}
$theClass = new ReflectionClass($theClass);
} else {
if (is_string($theClass)) {
$this->setName($theClass);
return;
}
}
}
if (!$argumentsValid) {
throw new InvalidArgumentException();
}
if (!$theClass->isSubclassOf('PHPUnit_Framework_TestCase')) {
throw new InvalidArgumentException('Class does not extend PHPUnit_Framework_TestCase.');
}
$filename = $theClass->getFilename();
if (strpos($filename, 'eval()') === FALSE) {
PHP_CodeCoverage::getInstance()->filter()->addFileToBlacklist(realpath($filename), 'TESTS');
}
if ($name != '') {
$this->setName($name);
} else {
$this->setName($theClass->getName());
}
$constructor = $theClass->getConstructor();
if ($constructor !== NULL && !$constructor->isPublic()) {
$this->addTest(self::warning(sprintf('Class "%s" has no public constructor.', $theClass->getName())));
return;
}
foreach ($theClass->getMethods() as $method) {
if (strpos($method->getDeclaringClass()->getName(), 'PHPUnit_') !== 0) {
$this->addTestMethod($theClass, $method);
}
}
if (empty($this->tests)) {
$this->addTest(self::warning(sprintf('No tests found in class "%s".', $theClass->getName())));
}
$this->testCase = TRUE;
}
/**
* Runs a TestCase.
*
* @param PHPUnit_Framework_Test $test
*/
public function run(PHPUnit_Framework_Test $test)
{
PHPUnit_Framework_Assert::resetCount();
$error = false;
$failure = false;
$warning = false;
$incomplete = false;
$risky = false;
$skipped = false;
$this->startTest($test);
$errorHandlerSet = false;
if ($this->convertErrorsToExceptions) {
$oldErrorHandler = set_error_handler(['PHPUnit_Util_ErrorHandler', 'handleError'], E_ALL | E_STRICT);
if ($oldErrorHandler === null) {
$errorHandlerSet = true;
} else {
restore_error_handler();
}
}
$collectCodeCoverage = $this->codeCoverage !== null && !$test instanceof PHPUnit_Framework_WarningTestCase;
if ($collectCodeCoverage) {
$this->codeCoverage->start($test);
}
$monitorFunctions = $this->beStrictAboutResourceUsageDuringSmallTests && !$test instanceof PHPUnit_Framework_WarningTestCase && $test->getSize() == PHPUnit_Util_Test::SMALL && function_exists('xdebug_start_function_monitor');
if ($monitorFunctions) {
xdebug_start_function_monitor(ResourceOperations::getFunctions());
}
PHP_Timer::start();
try {
if (!$test instanceof PHPUnit_Framework_WarningTestCase && $test->getSize() != PHPUnit_Util_Test::UNKNOWN && $this->enforceTimeLimit && extension_loaded('pcntl') && class_exists('PHP_Invoker')) {
switch ($test->getSize()) {
case PHPUnit_Util_Test::SMALL:
$_timeout = $this->timeoutForSmallTests;
break;
case PHPUnit_Util_Test::MEDIUM:
$_timeout = $this->timeoutForMediumTests;
break;
case PHPUnit_Util_Test::LARGE:
$_timeout = $this->timeoutForLargeTests;
break;
}
$invoker = new PHP_Invoker();
$invoker->invoke([$test, 'runBare'], [], $_timeout);
} else {
$test->runBare();
}
} catch (PHPUnit_Framework_AssertionFailedError $e) {
$failure = true;
if ($e instanceof PHPUnit_Framework_RiskyTestError) {
$risky = true;
} elseif ($e instanceof PHPUnit_Framework_IncompleteTestError) {
$incomplete = true;
} elseif ($e instanceof PHPUnit_Framework_SkippedTestError) {
$skipped = true;
}
} catch (PHPUnit_Framework_Warning $e) {
$warning = true;
} catch (PHPUnit_Framework_Exception $e) {
$error = true;
} catch (Throwable $e) {
$e = new PHPUnit_Framework_ExceptionWrapper($e);
$error = true;
} catch (Exception $e) {
$e = new PHPUnit_Framework_ExceptionWrapper($e);
$error = true;
}
$time = PHP_Timer::stop();
$test->addToAssertionCount(PHPUnit_Framework_Assert::getCount());
if ($monitorFunctions) {
$blacklist = new PHPUnit_Util_Blacklist();
$functions = xdebug_get_monitored_functions();
xdebug_stop_function_monitor();
foreach ($functions as $function) {
if (!$blacklist->isBlacklisted($function['filename'])) {
$this->addFailure($test, new PHPUnit_Framework_RiskyTestError(sprintf('%s() used in %s:%s', $function['function'], $function['filename'], $function['lineno'])), $time);
}
}
}
if ($this->beStrictAboutTestsThatDoNotTestAnything && $test->getNumAssertions() == 0) {
$risky = true;
}
if ($collectCodeCoverage) {
$append = !$risky && !$incomplete && !$skipped;
$linesToBeCovered = [];
$linesToBeUsed = [];
if ($append && $test instanceof PHPUnit_Framework_TestCase) {
$linesToBeCovered = PHPUnit_Util_Test::getLinesToBeCovered(get_class($test), $test->getName(false));
$linesToBeUsed = PHPUnit_Util_Test::getLinesToBeUsed(get_class($test), $test->getName(false));
}
try {
$this->codeCoverage->stop($append, $linesToBeCovered, $linesToBeUsed);
} catch (PHP_CodeCoverage_UnintentionallyCoveredCodeException $cce) {
$this->addFailure($test, new PHPUnit_Framework_UnintentionallyCoveredCodeError('This test executed code that is not listed as code to be covered or used:' . PHP_EOL . $cce->getMessage()), $time);
} catch (PHPUnit_Framework_InvalidCoversTargetException $cce) {
$this->addFailure($test, new PHPUnit_Framework_InvalidCoversTargetError($cce->getMessage()), $time);
} catch (PHP_CodeCoverage_Exception $cce) {
$error = true;
if (!isset($e)) {
$e = $cce;
}
}
}
if ($errorHandlerSet === true) {
restore_error_handler();
}
if ($error === true) {
$this->addError($test, $e, $time);
} elseif ($failure === true) {
$this->addFailure($test, $e, $time);
} elseif ($warning === true) {
$this->addWarning($test, $e, $time);
} elseif ($this->beStrictAboutTestsThatDoNotTestAnything && $test->getNumAssertions() == 0) {
$this->addFailure($test, new PHPUnit_Framework_RiskyTestError('This test did not perform any assertions'), $time);
} elseif ($this->beStrictAboutOutputDuringTests && $test->hasOutput()) {
$this->addFailure($test, new PHPUnit_Framework_OutputError(sprintf('This test printed output: %s', $test->getActualOutput())), $time);
} elseif ($this->beStrictAboutTodoAnnotatedTests && $test instanceof PHPUnit_Framework_TestCase) {
$annotations = $test->getAnnotations();
if (isset($annotations['method']['todo'])) {
$this->addFailure($test, new PHPUnit_Framework_RiskyTestError('Test method is annotated with @todo'), $time);
}
}
$this->endTest($test, $time);
}
/**
* @param PHPUnit_Framework_Test $suite
* @param array $arguments
* @param bool $exit
*
* @return PHPUnit_Framework_TestResult
*/
public function doRun(PHPUnit_Framework_Test $suite, array $arguments = [], $exit)
{
if (isset($arguments['configuration'])) {
$GLOBALS['__PHPUNIT_CONFIGURATION_FILE'] = $arguments['configuration'];
}
$this->handleConfiguration($arguments);
$this->processSuiteFilters($suite, $arguments);
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['beStrictAboutChangesToGlobalState'] === true) {
$suite->setbeStrictAboutChangesToGlobalState(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['stopOnWarning']) {
$result->stopOnWarning(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'], $arguments['reverseList']);
}
}
if (!$this->printer instanceof PHPUnit_Util_Log_TAP) {
$this->printer->write(PHPUnit_Runner_Version::getVersionString() . "\n");
self::$versionStringPrinted = true;
if ($arguments['verbose']) {
$runtime = $this->runtime->getNameWithVersion();
if ($this->runtime->hasXdebug()) {
$runtime .= sprintf(' with Xdebug %s', phpversion('xdebug'));
}
$this->writeMessage('Runtime', $runtime);
if (isset($arguments['configuration'])) {
$this->writeMessage('Configuration', $arguments['configuration']->getFilename());
}
}
if (isset($arguments['deprecatedCheckForUnintentionallyCoveredCodeSettingUsed'])) {
print "Warning: Deprecated configuration setting \"checkForUnintentionallyCoveredCode\" 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 (isset($arguments['noCoverage'])) {
$codeCoverageReports = 0;
}
if ($codeCoverageReports > 0) {
if (!$this->runtime->canCollectCodeCoverage()) {
$this->writeMessage('Error', 'No code coverage driver is available');
$codeCoverageReports = 0;
} elseif (!isset($arguments['whitelist']) && !$this->codeCoverageFilter->hasWhitelist()) {
$this->writeMessage('Error', 'No whitelist configured, no code coverage will be generated');
$codeCoverageReports = 0;
}
}
if (!$this->printer instanceof PHPUnit_Util_Log_TAP) {
$this->printer->write("\n");
}
if ($codeCoverageReports > 0) {
$codeCoverage = new PHP_CodeCoverage(null, $this->codeCoverageFilter);
$codeCoverage->setAddUncoveredFilesFromWhitelist($arguments['addUncoveredFilesFromWhitelist']);
$codeCoverage->setCheckForUnintentionallyCoveredCode($arguments['strictCoverage']);
$codeCoverage->setCheckForUnexecutedCoveredCode($arguments['strictCoverage']);
$codeCoverage->setProcessUncoveredFilesFromWhitelist($arguments['processUncoveredFilesFromWhitelist']);
if (isset($arguments['forceCoversAnnotation'])) {
$codeCoverage->setForceCoversAnnotation($arguments['forceCoversAnnotation']);
}
if (isset($arguments['disableCodeCoverageIgnore'])) {
$codeCoverage->setDisableIgnoredLines(true);
}
if (isset($arguments['whitelist'])) {
$this->codeCoverageFilter->addDirectoryToWhitelist($arguments['whitelist']);
}
$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['teamcityLogfile'])) {
$result->addListener(new PHPUnit_Util_Log_TeamCity($arguments['teamcityLogfile']));
}
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->beStrictAboutResourceUsageDuringSmallTests($arguments['beStrictAboutResourceUsageDuringSmallTests']);
$result->enforceTimeLimit($arguments['enforceTimeLimit']);
$result->setTimeoutForSmallTests($arguments['timeoutForSmallTests']);
$result->setTimeoutForMediumTests($arguments['timeoutForMediumTests']);
$result->setTimeoutForLargeTests($arguments['timeoutForLargeTests']);
if ($suite instanceof PHPUnit_Framework_TestSuite) {
$suite->setRunTestInSeparateProcess($arguments['processIsolation']);
}
$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 ...");
try {
$writer = new PHP_CodeCoverage_Report_Clover();
$writer->process($codeCoverage, $arguments['coverageClover']);
$this->printer->write(" done\n");
unset($writer);
} catch (PHP_CodeCoverage_Exception $e) {
$this->printer->write(" failed\n" . $e->getMessage() . "\n");
}
}
if (isset($arguments['coverageCrap4J'])) {
$this->printer->write("\nGenerating Crap4J report XML file ...");
try {
$writer = new PHP_CodeCoverage_Report_Crap4j($arguments['crap4jThreshold']);
$writer->process($codeCoverage, $arguments['coverageCrap4J']);
$this->printer->write(" done\n");
unset($writer);
} catch (PHP_CodeCoverage_Exception $e) {
$this->printer->write(" failed\n" . $e->getMessage() . "\n");
}
}
if (isset($arguments['coverageHtml'])) {
$this->printer->write("\nGenerating code coverage report in HTML format ...");
try {
$writer = new PHP_CodeCoverage_Report_HTML($arguments['reportLowUpperBound'], $arguments['reportHighLowerBound'], sprintf(' and <a href="https://phpunit.de/">PHPUnit %s</a>', PHPUnit_Runner_Version::id()));
$writer->process($codeCoverage, $arguments['coverageHtml']);
$this->printer->write(" done\n");
unset($writer);
} catch (PHP_CodeCoverage_Exception $e) {
$this->printer->write(" failed\n" . $e->getMessage() . "\n");
}
}
if (isset($arguments['coveragePHP'])) {
$this->printer->write("\nGenerating code coverage report in PHP format ...");
try {
$writer = new PHP_CodeCoverage_Report_PHP();
$writer->process($codeCoverage, $arguments['coveragePHP']);
$this->printer->write(" done\n");
unset($writer);
} catch (PHP_CodeCoverage_Exception $e) {
$this->printer->write(" failed\n" . $e->getMessage() . "\n");
}
}
if (isset($arguments['coverageText'])) {
if ($arguments['coverageText'] == 'php://stdout') {
$outputStream = $this->printer;
$colors = $arguments['colors'] && $arguments['colors'] != PHPUnit_TextUI_ResultPrinter::COLOR_NEVER;
} 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 ...");
try {
$writer = new PHP_CodeCoverage_Report_XML();
$writer->process($codeCoverage, $arguments['coverageXml']);
$this->printer->write(" done\n");
unset($writer);
} catch (PHP_CodeCoverage_Exception $e) {
$this->printer->write(" failed\n" . $e->getMessage() . "\n");
}
}
}
if ($exit) {
if ($result->wasSuccessful()) {
if ($arguments['failOnRisky'] && !$result->allHarmless()) {
exit(self::FAILURE_EXIT);
}
if ($arguments['failOnWarning'] && $result->warningCount() > 0) {
exit(self::FAILURE_EXIT);
}
exit(self::SUCCESS_EXIT);
}
if ($result->errorCount() > 0) {
exit(self::EXCEPTION_EXIT);
}
if ($result->failureCount() > 0) {
exit(self::FAILURE_EXIT);
}
}
return $result;
}
