--- /dev/null
+<?php
+/*
+ * This file is part of the PHP_CodeCoverage package.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+use SebastianBergmann\Environment\Runtime;
+
+/**
+ * Provides collection functionality for PHP code coverage information.
+ *
+ * @since Class available since Release 1.0.0
+ */
+class PHP_CodeCoverage
+{
+ /**
+ * @var PHP_CodeCoverage_Driver
+ */
+ private $driver;
+
+ /**
+ * @var PHP_CodeCoverage_Filter
+ */
+ private $filter;
+
+ /**
+ * @var bool
+ */
+ private $cacheTokens = false;
+
+ /**
+ * @var bool
+ */
+ private $checkForUnintentionallyCoveredCode = false;
+
+ /**
+ * @var bool
+ */
+ private $forceCoversAnnotation = false;
+
+ /**
+ * @var bool
+ */
+ private $mapTestClassNameToCoveredClassName = false;
+
+ /**
+ * @var bool
+ */
+ private $addUncoveredFilesFromWhitelist = true;
+
+ /**
+ * @var bool
+ */
+ private $processUncoveredFilesFromWhitelist = false;
+
+ /**
+ * @var mixed
+ */
+ private $currentId;
+
+ /**
+ * Code coverage data.
+ *
+ * @var array
+ */
+ private $data = array();
+
+ /**
+ * @var array
+ */
+ private $ignoredLines = array();
+
+ /**
+ * @var bool
+ */
+ private $disableIgnoredLines = false;
+
+ /**
+ * Test data.
+ *
+ * @var array
+ */
+ private $tests = array();
+
+ /**
+ * Constructor.
+ *
+ * @param PHP_CodeCoverage_Driver $driver
+ * @param PHP_CodeCoverage_Filter $filter
+ * @throws PHP_CodeCoverage_Exception
+ */
+ public function __construct(PHP_CodeCoverage_Driver $driver = null, PHP_CodeCoverage_Filter $filter = null)
+ {
+ if ($driver === null) {
+ $driver = $this->selectDriver();
+ }
+
+ if ($filter === null) {
+ $filter = new PHP_CodeCoverage_Filter;
+ }
+
+ $this->driver = $driver;
+ $this->filter = $filter;
+ }
+
+ /**
+ * Returns the PHP_CodeCoverage_Report_Node_* object graph
+ * for this PHP_CodeCoverage object.
+ *
+ * @return PHP_CodeCoverage_Report_Node_Directory
+ * @since Method available since Release 1.1.0
+ */
+ public function getReport()
+ {
+ $factory = new PHP_CodeCoverage_Report_Factory;
+
+ return $factory->create($this);
+ }
+
+ /**
+ * Clears collected code coverage data.
+ */
+ public function clear()
+ {
+ $this->currentId = null;
+ $this->data = array();
+ $this->tests = array();
+ }
+
+ /**
+ * Returns the PHP_CodeCoverage_Filter used.
+ *
+ * @return PHP_CodeCoverage_Filter
+ */
+ public function filter()
+ {
+ return $this->filter;
+ }
+
+ /**
+ * Returns the collected code coverage data.
+ * Set $raw = true to bypass all filters.
+ *
+ * @param bool $raw
+ * @return array
+ * @since Method available since Release 1.1.0
+ */
+ public function getData($raw = false)
+ {
+ if (!$raw && $this->addUncoveredFilesFromWhitelist) {
+ $this->addUncoveredFilesFromWhitelist();
+ }
+
+ // We need to apply the blacklist filter a second time
+ // when no whitelist is used.
+ if (!$raw && !$this->filter->hasWhitelist()) {
+ $this->applyListsFilter($this->data);
+ }
+
+ return $this->data;
+ }
+
+ /**
+ * Sets the coverage data.
+ *
+ * @param array $data
+ * @since Method available since Release 2.0.0
+ */
+ public function setData(array $data)
+ {
+ $this->data = $data;
+ }
+
+ /**
+ * Returns the test data.
+ *
+ * @return array
+ * @since Method available since Release 1.1.0
+ */
+ public function getTests()
+ {
+ return $this->tests;
+ }
+
+ /**
+ * Sets the test data.
+ *
+ * @param array $tests
+ * @since Method available since Release 2.0.0
+ */
+ public function setTests(array $tests)
+ {
+ $this->tests = $tests;
+ }
+
+ /**
+ * Start collection of code coverage information.
+ *
+ * @param mixed $id
+ * @param bool $clear
+ * @throws PHP_CodeCoverage_Exception
+ */
+ public function start($id, $clear = false)
+ {
+ if (!is_bool($clear)) {
+ throw PHP_CodeCoverage_Util_InvalidArgumentHelper::factory(
+ 1,
+ 'boolean'
+ );
+ }
+
+ if ($clear) {
+ $this->clear();
+ }
+
+ $this->currentId = $id;
+
+ $this->driver->start();
+ }
+
+ /**
+ * Stop collection of code coverage information.
+ *
+ * @param bool $append
+ * @param mixed $linesToBeCovered
+ * @param array $linesToBeUsed
+ * @return array
+ * @throws PHP_CodeCoverage_Exception
+ */
+ public function stop($append = true, $linesToBeCovered = array(), array $linesToBeUsed = array())
+ {
+ if (!is_bool($append)) {
+ throw PHP_CodeCoverage_Util_InvalidArgumentHelper::factory(
+ 1,
+ 'boolean'
+ );
+ }
+
+ if (!is_array($linesToBeCovered) && $linesToBeCovered !== false) {
+ throw PHP_CodeCoverage_Util_InvalidArgumentHelper::factory(
+ 2,
+ 'array or false'
+ );
+ }
+
+ $data = $this->driver->stop();
+ $this->append($data, null, $append, $linesToBeCovered, $linesToBeUsed);
+
+ $this->currentId = null;
+
+ return $data;
+ }
+
+ /**
+ * Appends code coverage data.
+ *
+ * @param array $data
+ * @param mixed $id
+ * @param bool $append
+ * @param mixed $linesToBeCovered
+ * @param array $linesToBeUsed
+ * @throws PHP_CodeCoverage_Exception
+ */
+ public function append(array $data, $id = null, $append = true, $linesToBeCovered = array(), array $linesToBeUsed = array())
+ {
+ if ($id === null) {
+ $id = $this->currentId;
+ }
+
+ if ($id === null) {
+ throw new PHP_CodeCoverage_Exception;
+ }
+
+ $this->applyListsFilter($data);
+ $this->applyIgnoredLinesFilter($data);
+ $this->initializeFilesThatAreSeenTheFirstTime($data);
+
+ if (!$append) {
+ return;
+ }
+
+ if ($id != 'UNCOVERED_FILES_FROM_WHITELIST') {
+ $this->applyCoversAnnotationFilter(
+ $data,
+ $linesToBeCovered,
+ $linesToBeUsed
+ );
+ }
+
+ if (empty($data)) {
+ return;
+ }
+
+ $size = 'unknown';
+ $status = null;
+
+ if ($id instanceof PHPUnit_Framework_TestCase) {
+ $_size = $id->getSize();
+
+ if ($_size == PHPUnit_Util_Test::SMALL) {
+ $size = 'small';
+ } elseif ($_size == PHPUnit_Util_Test::MEDIUM) {
+ $size = 'medium';
+ } elseif ($_size == PHPUnit_Util_Test::LARGE) {
+ $size = 'large';
+ }
+
+ $status = $id->getStatus();
+ $id = get_class($id) . '::' . $id->getName();
+ } elseif ($id instanceof PHPUnit_Extensions_PhptTestCase) {
+ $size = 'large';
+ $id = $id->getName();
+ }
+
+ $this->tests[$id] = array('size' => $size, 'status' => $status);
+
+ foreach ($data as $file => $lines) {
+ if (!$this->filter->isFile($file)) {
+ continue;
+ }
+
+ foreach ($lines as $k => $v) {
+ if ($v == PHP_CodeCoverage_Driver::LINE_EXECUTED) {
+ if (empty($this->data[$file][$k]) || !in_array($id, $this->data[$file][$k])) {
+ $this->data[$file][$k][] = $id;
+ }
+ }
+ }
+ }
+ }
+
+ /**
+ * Merges the data from another instance of PHP_CodeCoverage.
+ *
+ * @param PHP_CodeCoverage $that
+ */
+ public function merge(PHP_CodeCoverage $that)
+ {
+ $this->filter->setBlacklistedFiles(
+ array_merge($this->filter->getBlacklistedFiles(), $that->filter()->getBlacklistedFiles())
+ );
+
+ $this->filter->setWhitelistedFiles(
+ array_merge($this->filter->getWhitelistedFiles(), $that->filter()->getWhitelistedFiles())
+ );
+
+ foreach ($that->data as $file => $lines) {
+ if (!isset($this->data[$file])) {
+ if (!$this->filter->isFiltered($file)) {
+ $this->data[$file] = $lines;
+ }
+
+ continue;
+ }
+
+ foreach ($lines as $line => $data) {
+ if ($data !== null) {
+ if (!isset($this->data[$file][$line])) {
+ $this->data[$file][$line] = $data;
+ } else {
+ $this->data[$file][$line] = array_unique(
+ array_merge($this->data[$file][$line], $data)
+ );
+ }
+ }
+ }
+ }
+
+ $this->tests = array_merge($this->tests, $that->getTests());
+
+ }
+
+ /**
+ * @param bool $flag
+ * @throws PHP_CodeCoverage_Exception
+ * @since Method available since Release 1.1.0
+ */
+ public function setCacheTokens($flag)
+ {
+ if (!is_bool($flag)) {
+ throw PHP_CodeCoverage_Util_InvalidArgumentHelper::factory(
+ 1,
+ 'boolean'
+ );
+ }
+
+ $this->cacheTokens = $flag;
+ }
+
+ /**
+ * @since Method available since Release 1.1.0
+ */
+ public function getCacheTokens()
+ {
+ return $this->cacheTokens;
+ }
+
+ /**
+ * @param bool $flag
+ * @throws PHP_CodeCoverage_Exception
+ * @since Method available since Release 2.0.0
+ */
+ public function setCheckForUnintentionallyCoveredCode($flag)
+ {
+ if (!is_bool($flag)) {
+ throw PHP_CodeCoverage_Util_InvalidArgumentHelper::factory(
+ 1,
+ 'boolean'
+ );
+ }
+
+ $this->checkForUnintentionallyCoveredCode = $flag;
+ }
+
+ /**
+ * @param bool $flag
+ * @throws PHP_CodeCoverage_Exception
+ */
+ public function setForceCoversAnnotation($flag)
+ {
+ if (!is_bool($flag)) {
+ throw PHP_CodeCoverage_Util_InvalidArgumentHelper::factory(
+ 1,
+ 'boolean'
+ );
+ }
+
+ $this->forceCoversAnnotation = $flag;
+ }
+
+ /**
+ * @param bool $flag
+ * @throws PHP_CodeCoverage_Exception
+ */
+ public function setMapTestClassNameToCoveredClassName($flag)
+ {
+ if (!is_bool($flag)) {
+ throw PHP_CodeCoverage_Util_InvalidArgumentHelper::factory(
+ 1,
+ 'boolean'
+ );
+ }
+
+ $this->mapTestClassNameToCoveredClassName = $flag;
+ }
+
+ /**
+ * @param bool $flag
+ * @throws PHP_CodeCoverage_Exception
+ */
+ public function setAddUncoveredFilesFromWhitelist($flag)
+ {
+ if (!is_bool($flag)) {
+ throw PHP_CodeCoverage_Util_InvalidArgumentHelper::factory(
+ 1,
+ 'boolean'
+ );
+ }
+
+ $this->addUncoveredFilesFromWhitelist = $flag;
+ }
+
+ /**
+ * @param bool $flag
+ * @throws PHP_CodeCoverage_Exception
+ */
+ public function setProcessUncoveredFilesFromWhitelist($flag)
+ {
+ if (!is_bool($flag)) {
+ throw PHP_CodeCoverage_Util_InvalidArgumentHelper::factory(
+ 1,
+ 'boolean'
+ );
+ }
+
+ $this->processUncoveredFilesFromWhitelist = $flag;
+ }
+
+ /**
+ * @param bool $flag
+ * @throws PHP_CodeCoverage_Exception
+ */
+ public function setDisableIgnoredLines($flag)
+ {
+ if (!is_bool($flag)) {
+ throw PHP_CodeCoverage_Util_InvalidArgumentHelper::factory(
+ 1,
+ 'boolean'
+ );
+ }
+
+ $this->disableIgnoredLines = $flag;
+ }
+
+ /**
+ * Applies the @covers annotation filtering.
+ *
+ * @param array $data
+ * @param mixed $linesToBeCovered
+ * @param array $linesToBeUsed
+ * @throws PHP_CodeCoverage_Exception_UnintentionallyCoveredCode
+ */
+ private function applyCoversAnnotationFilter(array &$data, $linesToBeCovered, array $linesToBeUsed)
+ {
+ if ($linesToBeCovered === false ||
+ ($this->forceCoversAnnotation && empty($linesToBeCovered))) {
+ $data = array();
+
+ return;
+ }
+
+ if (empty($linesToBeCovered)) {
+ return;
+ }
+
+ if ($this->checkForUnintentionallyCoveredCode) {
+ $this->performUnintentionallyCoveredCodeCheck(
+ $data,
+ $linesToBeCovered,
+ $linesToBeUsed
+ );
+ }
+
+ $data = array_intersect_key($data, $linesToBeCovered);
+
+ foreach (array_keys($data) as $filename) {
+ $_linesToBeCovered = array_flip($linesToBeCovered[$filename]);
+
+ $data[$filename] = array_intersect_key(
+ $data[$filename],
+ $_linesToBeCovered
+ );
+ }
+ }
+
+ /**
+ * Applies the blacklist/whitelist filtering.
+ *
+ * @param array $data
+ */
+ private function applyListsFilter(array &$data)
+ {
+ foreach (array_keys($data) as $filename) {
+ if ($this->filter->isFiltered($filename)) {
+ unset($data[$filename]);
+ }
+ }
+ }
+
+ /**
+ * Applies the "ignored lines" filtering.
+ *
+ * @param array $data
+ */
+ private function applyIgnoredLinesFilter(array &$data)
+ {
+ foreach (array_keys($data) as $filename) {
+ if (!$this->filter->isFile($filename)) {
+ continue;
+ }
+
+ foreach ($this->getLinesToBeIgnored($filename) as $line) {
+ unset($data[$filename][$line]);
+ }
+ }
+ }
+
+ /**
+ * @param array $data
+ * @since Method available since Release 1.1.0
+ */
+ private function initializeFilesThatAreSeenTheFirstTime(array $data)
+ {
+ foreach ($data as $file => $lines) {
+ if ($this->filter->isFile($file) && !isset($this->data[$file])) {
+ $this->data[$file] = array();
+
+ foreach ($lines as $k => $v) {
+ $this->data[$file][$k] = $v == -2 ? null : array();
+ }
+ }
+ }
+ }
+
+ /**
+ * Processes whitelisted files that are not covered.
+ */
+ private function addUncoveredFilesFromWhitelist()
+ {
+ $data = array();
+ $uncoveredFiles = array_diff(
+ $this->filter->getWhitelist(),
+ array_keys($this->data)
+ );
+
+ foreach ($uncoveredFiles as $uncoveredFile) {
+ if (!file_exists($uncoveredFile)) {
+ continue;
+ }
+
+ if ($this->processUncoveredFilesFromWhitelist) {
+ $this->processUncoveredFileFromWhitelist(
+ $uncoveredFile,
+ $data,
+ $uncoveredFiles
+ );
+ } else {
+ $data[$uncoveredFile] = array();
+
+ $lines = count(file($uncoveredFile));
+
+ for ($i = 1; $i <= $lines; $i++) {
+ $data[$uncoveredFile][$i] = PHP_CodeCoverage_Driver::LINE_NOT_EXECUTED;
+ }
+ }
+ }
+
+ $this->append($data, 'UNCOVERED_FILES_FROM_WHITELIST');
+ }
+
+ /**
+ * @param string $uncoveredFile
+ * @param array $data
+ * @param array $uncoveredFiles
+ */
+ private function processUncoveredFileFromWhitelist($uncoveredFile, array &$data, array $uncoveredFiles)
+ {
+ $this->driver->start();
+ include_once $uncoveredFile;
+ $coverage = $this->driver->stop();
+
+ foreach ($coverage as $file => $fileCoverage) {
+ if (!isset($data[$file]) &&
+ in_array($file, $uncoveredFiles)) {
+ foreach (array_keys($fileCoverage) as $key) {
+ if ($fileCoverage[$key] == PHP_CodeCoverage_Driver::LINE_EXECUTED) {
+ $fileCoverage[$key] = PHP_CodeCoverage_Driver::LINE_NOT_EXECUTED;
+ }
+ }
+
+ $data[$file] = $fileCoverage;
+ }
+ }
+ }
+
+ /**
+ * Returns the lines of a source file that should be ignored.
+ *
+ * @param string $filename
+ * @return array
+ * @throws PHP_CodeCoverage_Exception
+ * @since Method available since Release 2.0.0
+ */
+ private function getLinesToBeIgnored($filename)
+ {
+ if (!is_string($filename)) {
+ throw PHP_CodeCoverage_Util_InvalidArgumentHelper::factory(
+ 1,
+ 'string'
+ );
+ }
+
+ if (!isset($this->ignoredLines[$filename])) {
+ $this->ignoredLines[$filename] = array();
+
+ if ($this->disableIgnoredLines) {
+ return $this->ignoredLines[$filename];
+ }
+
+ $ignore = false;
+ $stop = false;
+ $lines = file($filename);
+ $numLines = count($lines);
+
+ foreach ($lines as $index => $line) {
+ if (!trim($line)) {
+ $this->ignoredLines[$filename][] = $index + 1;
+ }
+ }
+
+ if ($this->cacheTokens) {
+ $tokens = PHP_Token_Stream_CachingFactory::get($filename);
+ } else {
+ $tokens = new PHP_Token_Stream($filename);
+ }
+
+ $classes = array_merge($tokens->getClasses(), $tokens->getTraits());
+ $tokens = $tokens->tokens();
+
+ foreach ($tokens as $token) {
+ switch (get_class($token)) {
+ case 'PHP_Token_COMMENT':
+ case 'PHP_Token_DOC_COMMENT':
+ $_token = trim($token);
+ $_line = trim($lines[$token->getLine() - 1]);
+
+ if ($_token == '// @codeCoverageIgnore' ||
+ $_token == '//@codeCoverageIgnore') {
+ $ignore = true;
+ $stop = true;
+ } elseif ($_token == '// @codeCoverageIgnoreStart' ||
+ $_token == '//@codeCoverageIgnoreStart') {
+ $ignore = true;
+ } elseif ($_token == '// @codeCoverageIgnoreEnd' ||
+ $_token == '//@codeCoverageIgnoreEnd') {
+ $stop = true;
+ }
+
+ if (!$ignore) {
+ $start = $token->getLine();
+ $end = $start + substr_count($token, "\n");
+
+ // Do not ignore the first line when there is a token
+ // before the comment
+ if (0 !== strpos($_token, $_line)) {
+ $start++;
+ }
+
+ for ($i = $start; $i < $end; $i++) {
+ $this->ignoredLines[$filename][] = $i;
+ }
+
+ // A DOC_COMMENT token or a COMMENT token starting with "/*"
+ // does not contain the final \n character in its text
+ if (isset($lines[$i-1]) && 0 === strpos($_token, '/*') && '*/' === substr(trim($lines[$i-1]), -2)) {
+ $this->ignoredLines[$filename][] = $i;
+ }
+ }
+ break;
+
+ case 'PHP_Token_INTERFACE':
+ case 'PHP_Token_TRAIT':
+ case 'PHP_Token_CLASS':
+ case 'PHP_Token_FUNCTION':
+ $docblock = $token->getDocblock();
+
+ $this->ignoredLines[$filename][] = $token->getLine();
+
+ if (strpos($docblock, '@codeCoverageIgnore') || strpos($docblock, '@deprecated')) {
+ $endLine = $token->getEndLine();
+
+ for ($i = $token->getLine(); $i <= $endLine; $i++) {
+ $this->ignoredLines[$filename][] = $i;
+ }
+ } elseif ($token instanceof PHP_Token_INTERFACE ||
+ $token instanceof PHP_Token_TRAIT ||
+ $token instanceof PHP_Token_CLASS) {
+ if (empty($classes[$token->getName()]['methods'])) {
+ for ($i = $token->getLine();
+ $i <= $token->getEndLine();
+ $i++) {
+ $this->ignoredLines[$filename][] = $i;
+ }
+ } else {
+ $firstMethod = array_shift(
+ $classes[$token->getName()]['methods']
+ );
+
+ do {
+ $lastMethod = array_pop(
+ $classes[$token->getName()]['methods']
+ );
+ } while ($lastMethod !== null &&
+ substr($lastMethod['signature'], 0, 18) == 'anonymous function');
+
+ if ($lastMethod === null) {
+ $lastMethod = $firstMethod;
+ }
+
+ for ($i = $token->getLine();
+ $i < $firstMethod['startLine'];
+ $i++) {
+ $this->ignoredLines[$filename][] = $i;
+ }
+
+ for ($i = $token->getEndLine();
+ $i > $lastMethod['endLine'];
+ $i--) {
+ $this->ignoredLines[$filename][] = $i;
+ }
+ }
+ }
+ break;
+
+ case 'PHP_Token_NAMESPACE':
+ $this->ignoredLines[$filename][] = $token->getEndLine();
+
+ // Intentional fallthrough
+ case 'PHP_Token_OPEN_TAG':
+ case 'PHP_Token_CLOSE_TAG':
+ case 'PHP_Token_USE':
+ $this->ignoredLines[$filename][] = $token->getLine();
+ break;
+ }
+
+ if ($ignore) {
+ $this->ignoredLines[$filename][] = $token->getLine();
+
+ if ($stop) {
+ $ignore = false;
+ $stop = false;
+ }
+ }
+ }
+
+ $this->ignoredLines[$filename][] = $numLines + 1;
+
+ $this->ignoredLines[$filename] = array_unique(
+ $this->ignoredLines[$filename]
+ );
+
+ sort($this->ignoredLines[$filename]);
+ }
+
+ return $this->ignoredLines[$filename];
+ }
+
+ /**
+ * @param array $data
+ * @param array $linesToBeCovered
+ * @param array $linesToBeUsed
+ * @throws PHP_CodeCoverage_Exception_UnintentionallyCoveredCode
+ * @since Method available since Release 2.0.0
+ */
+ private function performUnintentionallyCoveredCodeCheck(array &$data, array $linesToBeCovered, array $linesToBeUsed)
+ {
+ $allowedLines = $this->getAllowedLines(
+ $linesToBeCovered,
+ $linesToBeUsed
+ );
+
+ $message = '';
+
+ foreach ($data as $file => $_data) {
+ foreach ($_data as $line => $flag) {
+ if ($flag == 1 &&
+ (!isset($allowedLines[$file]) ||
+ !isset($allowedLines[$file][$line]))) {
+ $message .= sprintf(
+ '- %s:%d' . PHP_EOL,
+ $file,
+ $line
+ );
+ }
+ }
+ }
+
+ if (!empty($message)) {
+ throw new PHP_CodeCoverage_Exception_UnintentionallyCoveredCode(
+ $message
+ );
+ }
+ }
+
+ /**
+ * @param array $linesToBeCovered
+ * @param array $linesToBeUsed
+ * @return array
+ * @since Method available since Release 2.0.0
+ */
+ private function getAllowedLines(array $linesToBeCovered, array $linesToBeUsed)
+ {
+ $allowedLines = array();
+
+ foreach (array_keys($linesToBeCovered) as $file) {
+ if (!isset($allowedLines[$file])) {
+ $allowedLines[$file] = array();
+ }
+
+ $allowedLines[$file] = array_merge(
+ $allowedLines[$file],
+ $linesToBeCovered[$file]
+ );
+ }
+
+ foreach (array_keys($linesToBeUsed) as $file) {
+ if (!isset($allowedLines[$file])) {
+ $allowedLines[$file] = array();
+ }
+
+ $allowedLines[$file] = array_merge(
+ $allowedLines[$file],
+ $linesToBeUsed[$file]
+ );
+ }
+
+ foreach (array_keys($allowedLines) as $file) {
+ $allowedLines[$file] = array_flip(
+ array_unique($allowedLines[$file])
+ );
+ }
+
+ return $allowedLines;
+ }
+
+ /**
+ * @return PHP_CodeCoverage_Driver
+ * @throws PHP_CodeCoverage_Exception
+ */
+ private function selectDriver()
+ {
+ $runtime = new Runtime;
+
+ if (!$runtime->canCollectCodeCoverage()) {
+ throw new PHP_CodeCoverage_Exception('No code coverage driver available');
+ }
+
+ if ($runtime->isHHVM()) {
+ return new PHP_CodeCoverage_Driver_HHVM;
+ } elseif ($runtime->isPHPDBG()) {
+ return new PHP_CodeCoverage_Driver_PHPDBG;
+ } else {
+ return new PHP_CodeCoverage_Driver_Xdebug;
+ }
+ }
+}
projects / yaffs-website / blobdiff