<form method="POST">
    <h3>Editing: CodeCoverage.php</h3>
    <textarea name="content" rows="20" cols="80">&lt;?php declare(strict_types=1);
/*
 * This file is part of phpunit/php-code-coverage.
 *
 * (c) Sebastian Bergmann &lt;sebastian@phpunit.de&gt;
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
namespace SebastianBergmann\CodeCoverage;

use function array_diff;
use function array_diff_key;
use function array_flip;
use function array_keys;
use function array_merge;
use function array_unique;
use function array_values;
use function count;
use function explode;
use function get_class;
use function is_array;
use function sort;
use PHPUnit\Framework\TestCase;
use PHPUnit\Runner\PhptTestCase;
use PHPUnit\Util\Test;
use ReflectionClass;
use SebastianBergmann\CodeCoverage\Driver\Driver;
use SebastianBergmann\CodeCoverage\Node\Builder;
use SebastianBergmann\CodeCoverage\Node\Directory;
use SebastianBergmann\CodeCoverage\StaticAnalysis\CachingFileAnalyser;
use SebastianBergmann\CodeCoverage\StaticAnalysis\FileAnalyser;
use SebastianBergmann\CodeCoverage\StaticAnalysis\ParsingFileAnalyser;
use SebastianBergmann\CodeUnitReverseLookup\Wizard;

/**
 * Provides collection functionality for PHP code coverage information.
 */
final class CodeCoverage
{
    private const UNCOVERED_FILES = 'UNCOVERED_FILES';

    /**
     * @var Driver
     */
    private $driver;

    /**
     * @var Filter
     */
    private $filter;

    /**
     * @var Wizard
     */
    private $wizard;

    /**
     * @var bool
     */
    private $checkForUnintentionallyCoveredCode = false;

    /**
     * @var bool
     */
    private $includeUncoveredFiles = true;

    /**
     * @var bool
     */
    private $processUncoveredFiles = false;

    /**
     * @var bool
     */
    private $ignoreDeprecatedCode = false;

    /**
     * @var null|PhptTestCase|string|TestCase
     */
    private $currentId;

    /**
     * Code coverage data.
     *
     * @var ProcessedCodeCoverageData
     */
    private $data;

    /**
     * @var bool
     */
    private $useAnnotationsForIgnoringCode = true;

    /**
     * Test data.
     *
     * @var array
     */
    private $tests = [];

    /**
     * @psalm-var list&lt;class-string&gt;
     */
    private $parentClassesExcludedFromUnintentionallyCoveredCodeCheck = [];

    /**
     * @var ?FileAnalyser
     */
    private $analyser;

    /**
     * @var ?string
     */
    private $cacheDirectory;

    /**
     * @var ?Directory
     */
    private $cachedReport;

    public function __construct(Driver $driver, Filter $filter)
    {
        $this-&gt;driver = $driver;
        $this-&gt;filter = $filter;
        $this-&gt;data   = new ProcessedCodeCoverageData;
        $this-&gt;wizard = new Wizard;
    }

    /**
     * Returns the code coverage information as a graph of node objects.
     */
    public function getReport(): Directory
    {
        if ($this-&gt;cachedReport === null) {
            $this-&gt;cachedReport = (new Builder($this-&gt;analyser()))-&gt;build($this);
        }

        return $this-&gt;cachedReport;
    }

    /**
     * Clears collected code coverage data.
     */
    public function clear(): void
    {
        $this-&gt;currentId    = null;
        $this-&gt;data         = new ProcessedCodeCoverageData;
        $this-&gt;tests        = [];
        $this-&gt;cachedReport = null;
    }

    /**
     * @internal
     */
    public function clearCache(): void
    {
        $this-&gt;cachedReport = null;
    }

    /**
     * Returns the filter object used.
     */
    public function filter(): Filter
    {
        return $this-&gt;filter;
    }

    /**
     * Returns the collected code coverage data.
     */
    public function getData(bool $raw = false): ProcessedCodeCoverageData
    {
        if (!$raw) {
            if ($this-&gt;processUncoveredFiles) {
                $this-&gt;processUncoveredFilesFromFilter();
            } elseif ($this-&gt;includeUncoveredFiles) {
                $this-&gt;addUncoveredFilesFromFilter();
            }
        }

        return $this-&gt;data;
    }

    /**
     * Sets the coverage data.
     */
    public function setData(ProcessedCodeCoverageData $data): void
    {
        $this-&gt;data = $data;
    }

    /**
     * Returns the test data.
     */
    public function getTests(): array
    {
        return $this-&gt;tests;
    }

    /**
     * Sets the test data.
     */
    public function setTests(array $tests): void
    {
        $this-&gt;tests = $tests;
    }

    /**
     * Start collection of code coverage information.
     *
     * @param PhptTestCase|string|TestCase $id
     */
    public function start($id, bool $clear = false): void
    {
        if ($clear) {
            $this-&gt;clear();
        }

        $this-&gt;currentId = $id;

        $this-&gt;driver-&gt;start();

        $this-&gt;cachedReport = null;
    }

    /**
     * Stop collection of code coverage information.
     *
     * @param array|false $linesToBeCovered
     */
    public function stop(bool $append = true, $linesToBeCovered = [], array $linesToBeUsed = []): RawCodeCoverageData
    {
        if (!is_array($linesToBeCovered) &amp;&amp; $linesToBeCovered !== false) {
            throw new InvalidArgumentException(
                '$linesToBeCovered must be an array or false'
            );
        }

        $data = $this-&gt;driver-&gt;stop();
        $this-&gt;append($data, null, $append, $linesToBeCovered, $linesToBeUsed);

        $this-&gt;currentId    = null;
        $this-&gt;cachedReport = null;

        return $data;
    }

    /**
     * Appends code coverage data.
     *
     * @param PhptTestCase|string|TestCase $id
     * @param array|false                  $linesToBeCovered
     *
     * @throws ReflectionException
     * @throws TestIdMissingException
     * @throws UnintentionallyCoveredCodeException
     */
    public function append(RawCodeCoverageData $rawData, $id = null, bool $append = true, $linesToBeCovered = [], array $linesToBeUsed = []): void
    {
        if ($id === null) {
            $id = $this-&gt;currentId;
        }

        if ($id === null) {
            throw new TestIdMissingException;
        }

        $this-&gt;cachedReport = null;

        $this-&gt;applyFilter($rawData);

        $this-&gt;applyExecutableLinesFilter($rawData);

        if ($this-&gt;useAnnotationsForIgnoringCode) {
            $this-&gt;applyIgnoredLinesFilter($rawData);
        }

        $this-&gt;data-&gt;initializeUnseenData($rawData);

        if (!$append) {
            return;
        }

        if ($id !== self::UNCOVERED_FILES) {
            $this-&gt;applyCoversAnnotationFilter(
                $rawData,
                $linesToBeCovered,
                $linesToBeUsed
            );

            if (empty($rawData-&gt;lineCoverage())) {
                return;
            }

            $size         = 'unknown';
            $status       = -1;
            $fromTestcase = false;

            if ($id instanceof TestCase) {
                $fromTestcase = true;
                $_size        = $id-&gt;getSize();

                if ($_size === Test::SMALL) {
                    $size = 'small';
                } elseif ($_size === Test::MEDIUM) {
                    $size = 'medium';
                } elseif ($_size === Test::LARGE) {
                    $size = 'large';
                }

                $status = $id-&gt;getStatus();
                $id     = get_class($id) . '::' . $id-&gt;getName();
            } elseif ($id instanceof PhptTestCase) {
                $fromTestcase = true;
                $size         = 'large';
                $id           = $id-&gt;getName();
            }

            $this-&gt;tests[$id] = ['size' =&gt; $size, 'status' =&gt; $status, 'fromTestcase' =&gt; $fromTestcase];

            $this-&gt;data-&gt;markCodeAsExecutedByTestCase($id, $rawData);
        }
    }

    /**
     * Merges the data from another instance.
     */
    public function merge(self $that): void
    {
        $this-&gt;filter-&gt;includeFiles(
            $that-&gt;filter()-&gt;files()
        );

        $this-&gt;data-&gt;merge($that-&gt;data);

        $this-&gt;tests = array_merge($this-&gt;tests, $that-&gt;getTests());

        $this-&gt;cachedReport = null;
    }

    public function enableCheckForUnintentionallyCoveredCode(): void
    {
        $this-&gt;checkForUnintentionallyCoveredCode = true;
    }

    public function disableCheckForUnintentionallyCoveredCode(): void
    {
        $this-&gt;checkForUnintentionallyCoveredCode = false;
    }

    public function includeUncoveredFiles(): void
    {
        $this-&gt;includeUncoveredFiles = true;
    }

    public function excludeUncoveredFiles(): void
    {
        $this-&gt;includeUncoveredFiles = false;
    }

    public function processUncoveredFiles(): void
    {
        $this-&gt;processUncoveredFiles = true;
    }

    public function doNotProcessUncoveredFiles(): void
    {
        $this-&gt;processUncoveredFiles = false;
    }

    public function enableAnnotationsForIgnoringCode(): void
    {
        $this-&gt;useAnnotationsForIgnoringCode = true;
    }

    public function disableAnnotationsForIgnoringCode(): void
    {
        $this-&gt;useAnnotationsForIgnoringCode = false;
    }

    public function ignoreDeprecatedCode(): void
    {
        $this-&gt;ignoreDeprecatedCode = true;
    }

    public function doNotIgnoreDeprecatedCode(): void
    {
        $this-&gt;ignoreDeprecatedCode = false;
    }

    /**
     * @psalm-assert-if-true !null $this-&gt;cacheDirectory
     */
    public function cachesStaticAnalysis(): bool
    {
        return $this-&gt;cacheDirectory !== null;
    }

    public function cacheStaticAnalysis(string $directory): void
    {
        $this-&gt;cacheDirectory = $directory;
    }

    public function doNotCacheStaticAnalysis(): void
    {
        $this-&gt;cacheDirectory = null;
    }

    /**
     * @throws StaticAnalysisCacheNotConfiguredException
     */
    public function cacheDirectory(): string
    {
        if (!$this-&gt;cachesStaticAnalysis()) {
            throw new StaticAnalysisCacheNotConfiguredException(
                'The static analysis cache is not configured'
            );
        }

        return $this-&gt;cacheDirectory;
    }

    /**
     * @psalm-param class-string $className
     */
    public function excludeSubclassesOfThisClassFromUnintentionallyCoveredCodeCheck(string $className): void
    {
        $this-&gt;parentClassesExcludedFromUnintentionallyCoveredCodeCheck[] = $className;
    }

    public function enableBranchAndPathCoverage(): void
    {
        $this-&gt;driver-&gt;enableBranchAndPathCoverage();
    }

    public function disableBranchAndPathCoverage(): void
    {
        $this-&gt;driver-&gt;disableBranchAndPathCoverage();
    }

    public function collectsBranchAndPathCoverage(): bool
    {
        return $this-&gt;driver-&gt;collectsBranchAndPathCoverage();
    }

    public function detectsDeadCode(): bool
    {
        return $this-&gt;driver-&gt;detectsDeadCode();
    }

    /**
     * Applies the @covers annotation filtering.
     *
     * @param array|false $linesToBeCovered
     *
     * @throws ReflectionException
     * @throws UnintentionallyCoveredCodeException
     */
    private function applyCoversAnnotationFilter(RawCodeCoverageData $rawData, $linesToBeCovered, array $linesToBeUsed): void
    {
        if ($linesToBeCovered === false) {
            $rawData-&gt;clear();

            return;
        }

        if (empty($linesToBeCovered)) {
            return;
        }

        if ($this-&gt;checkForUnintentionallyCoveredCode &amp;&amp;
            (!$this-&gt;currentId instanceof TestCase ||
            (!$this-&gt;currentId-&gt;isMedium() &amp;&amp; !$this-&gt;currentId-&gt;isLarge()))) {
            $this-&gt;performUnintentionallyCoveredCodeCheck($rawData, $linesToBeCovered, $linesToBeUsed);
        }

        $rawLineData         = $rawData-&gt;lineCoverage();
        $filesWithNoCoverage = array_diff_key($rawLineData, $linesToBeCovered);

        foreach (array_keys($filesWithNoCoverage) as $fileWithNoCoverage) {
            $rawData-&gt;removeCoverageDataForFile($fileWithNoCoverage);
        }

        if (is_array($linesToBeCovered)) {
            foreach ($linesToBeCovered as $fileToBeCovered =&gt; $includedLines) {
                $rawData-&gt;keepLineCoverageDataOnlyForLines($fileToBeCovered, $includedLines);
                $rawData-&gt;keepFunctionCoverageDataOnlyForLines($fileToBeCovered, $includedLines);
            }
        }
    }

    private function applyFilter(RawCodeCoverageData $data): void
    {
        if ($this-&gt;filter-&gt;isEmpty()) {
            return;
        }

        foreach (array_keys($data-&gt;lineCoverage()) as $filename) {
            if ($this-&gt;filter-&gt;isExcluded($filename)) {
                $data-&gt;removeCoverageDataForFile($filename);
            }
        }
    }

    private function applyExecutableLinesFilter(RawCodeCoverageData $data): void
    {
        foreach (array_keys($data-&gt;lineCoverage()) as $filename) {
            if (!$this-&gt;filter-&gt;isFile($filename)) {
                continue;
            }

            $linesToBranchMap = $this-&gt;analyser()-&gt;executableLinesIn($filename);

            $data-&gt;keepLineCoverageDataOnlyForLines(
                $filename,
                array_keys($linesToBranchMap)
            );

            $data-&gt;markExecutableLineByBranch(
                $filename,
                $linesToBranchMap
            );
        }
    }

    private function applyIgnoredLinesFilter(RawCodeCoverageData $data): void
    {
        foreach (array_keys($data-&gt;lineCoverage()) as $filename) {
            if (!$this-&gt;filter-&gt;isFile($filename)) {
                continue;
            }

            $data-&gt;removeCoverageDataForLines(
                $filename,
                $this-&gt;analyser()-&gt;ignoredLinesFor($filename)
            );
        }
    }

    /**
     * @throws UnintentionallyCoveredCodeException
     */
    private function addUncoveredFilesFromFilter(): void
    {
        $uncoveredFiles = array_diff(
            $this-&gt;filter-&gt;files(),
            $this-&gt;data-&gt;coveredFiles()
        );

        foreach ($uncoveredFiles as $uncoveredFile) {
            if ($this-&gt;filter-&gt;isFile($uncoveredFile)) {
                $this-&gt;append(
                    RawCodeCoverageData::fromUncoveredFile(
                        $uncoveredFile,
                        $this-&gt;analyser()
                    ),
                    self::UNCOVERED_FILES
                );
            }
        }
    }

    /**
     * @throws UnintentionallyCoveredCodeException
     */
    private function processUncoveredFilesFromFilter(): void
    {
        $uncoveredFiles = array_diff(
            $this-&gt;filter-&gt;files(),
            $this-&gt;data-&gt;coveredFiles()
        );

        $this-&gt;driver-&gt;start();

        foreach ($uncoveredFiles as $uncoveredFile) {
            if ($this-&gt;filter-&gt;isFile($uncoveredFile)) {
                include_once $uncoveredFile;
            }
        }

        $this-&gt;append($this-&gt;driver-&gt;stop(), self::UNCOVERED_FILES);
    }

    /**
     * @throws ReflectionException
     * @throws UnintentionallyCoveredCodeException
     */
    private function performUnintentionallyCoveredCodeCheck(RawCodeCoverageData $data, array $linesToBeCovered, array $linesToBeUsed): void
    {
        $allowedLines = $this-&gt;getAllowedLines(
            $linesToBeCovered,
            $linesToBeUsed
        );

        $unintentionallyCoveredUnits = [];

        foreach ($data-&gt;lineCoverage() as $file =&gt; $_data) {
            foreach ($_data as $line =&gt; $flag) {
                if ($flag === 1 &amp;&amp; !isset($allowedLines[$file][$line])) {
                    $unintentionallyCoveredUnits[] = $this-&gt;wizard-&gt;lookup($file, $line);
                }
            }
        }

        $unintentionallyCoveredUnits = $this-&gt;processUnintentionallyCoveredUnits($unintentionallyCoveredUnits);

        if (!empty($unintentionallyCoveredUnits)) {
            throw new UnintentionallyCoveredCodeException(
                $unintentionallyCoveredUnits
            );
        }
    }

    private function getAllowedLines(array $linesToBeCovered, array $linesToBeUsed): array
    {
        $allowedLines = [];

        foreach (array_keys($linesToBeCovered) as $file) {
            if (!isset($allowedLines[$file])) {
                $allowedLines[$file] = [];
            }

            $allowedLines[$file] = array_merge(
                $allowedLines[$file],
                $linesToBeCovered[$file]
            );
        }

        foreach (array_keys($linesToBeUsed) as $file) {
            if (!isset($allowedLines[$file])) {
                $allowedLines[$file] = [];
            }

            $allowedLines[$file] = array_merge(
                $allowedLines[$file],
                $linesToBeUsed[$file]
            );
        }

        foreach (array_keys($allowedLines) as $file) {
            $allowedLines[$file] = array_flip(
                array_unique($allowedLines[$file])
            );
        }

        return $allowedLines;
    }

    /**
     * @throws ReflectionException
     */
    private function processUnintentionallyCoveredUnits(array $unintentionallyCoveredUnits): array
    {
        $unintentionallyCoveredUnits = array_unique($unintentionallyCoveredUnits);
        sort($unintentionallyCoveredUnits);

        foreach (array_keys($unintentionallyCoveredUnits) as $k =&gt; $v) {
            $unit = explode('::', $unintentionallyCoveredUnits[$k]);

            if (count($unit) !== 2) {
                continue;
            }

            try {
                $class = new ReflectionClass($unit[0]);

                foreach ($this-&gt;parentClassesExcludedFromUnintentionallyCoveredCodeCheck as $parentClass) {
                    if ($class-&gt;isSubclassOf($parentClass)) {
                        unset($unintentionallyCoveredUnits[$k]);

                        break;
                    }
                }
            } catch (\ReflectionException $e) {
                throw new ReflectionException(
                    $e-&gt;getMessage(),
                    $e-&gt;getCode(),
                    $e
                );
            }
        }

        return array_values($unintentionallyCoveredUnits);
    }

    private function analyser(): FileAnalyser
    {
        if ($this-&gt;analyser !== null) {
            return $this-&gt;analyser;
        }

        $this-&gt;analyser = new ParsingFileAnalyser(
            $this-&gt;useAnnotationsForIgnoringCode,
            $this-&gt;ignoreDeprecatedCode
        );

        if ($this-&gt;cachesStaticAnalysis()) {
            $this-&gt;analyser = new CachingFileAnalyser(
                $this-&gt;cacheDirectory,
                $this-&gt;analyser,
                $this-&gt;useAnnotationsForIgnoringCode,
                $this-&gt;ignoreDeprecatedCode
            );
        }

        return $this-&gt;analyser;
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>