Spaces:
Runtime error
Runtime error
| declare(strict_types=1); | |
| /* | |
| * This file is part of phpunit/php-code-coverage. | |
| * | |
| * (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. | |
| */ | |
| namespace SebastianBergmann\CodeCoverage\Node; | |
| use function array_filter; | |
| use function count; | |
| use function range; | |
| /** | |
| * @internal This class is not covered by the backward compatibility promise for phpunit/php-code-coverage | |
| */ | |
| final class File extends AbstractNode | |
| { | |
| /** | |
| * @var array | |
| */ | |
| private $lineCoverageData; | |
| /** | |
| * @var array | |
| */ | |
| private $functionCoverageData; | |
| /** | |
| * @var array | |
| */ | |
| private $testData; | |
| /** | |
| * @var int | |
| */ | |
| private $numExecutableLines = 0; | |
| /** | |
| * @var int | |
| */ | |
| private $numExecutedLines = 0; | |
| /** | |
| * @var int | |
| */ | |
| private $numExecutableBranches = 0; | |
| /** | |
| * @var int | |
| */ | |
| private $numExecutedBranches = 0; | |
| /** | |
| * @var int | |
| */ | |
| private $numExecutablePaths = 0; | |
| /** | |
| * @var int | |
| */ | |
| private $numExecutedPaths = 0; | |
| /** | |
| * @var array | |
| */ | |
| private $classes = []; | |
| /** | |
| * @var array | |
| */ | |
| private $traits = []; | |
| /** | |
| * @var array | |
| */ | |
| private $functions = []; | |
| /** | |
| * @psalm-var array{linesOfCode: int, commentLinesOfCode: int, nonCommentLinesOfCode: int} | |
| */ | |
| private $linesOfCode; | |
| /** | |
| * @var int | |
| */ | |
| private $numClasses; | |
| /** | |
| * @var int | |
| */ | |
| private $numTestedClasses = 0; | |
| /** | |
| * @var int | |
| */ | |
| private $numTraits; | |
| /** | |
| * @var int | |
| */ | |
| private $numTestedTraits = 0; | |
| /** | |
| * @var int | |
| */ | |
| private $numMethods; | |
| /** | |
| * @var int | |
| */ | |
| private $numTestedMethods; | |
| /** | |
| * @var int | |
| */ | |
| private $numTestedFunctions; | |
| /** | |
| * @var array | |
| */ | |
| private $codeUnitsByLine = []; | |
| /** | |
| * @psalm-param array{linesOfCode: int, commentLinesOfCode: int, nonCommentLinesOfCode: int} $linesOfCode | |
| */ | |
| public function __construct(string $name, AbstractNode $parent, array $lineCoverageData, array $functionCoverageData, array $testData, array $classes, array $traits, array $functions, array $linesOfCode) | |
| { | |
| parent::__construct($name, $parent); | |
| $this->lineCoverageData = $lineCoverageData; | |
| $this->functionCoverageData = $functionCoverageData; | |
| $this->testData = $testData; | |
| $this->linesOfCode = $linesOfCode; | |
| $this->calculateStatistics($classes, $traits, $functions); | |
| } | |
| public function count(): int | |
| { | |
| return 1; | |
| } | |
| public function lineCoverageData(): array | |
| { | |
| return $this->lineCoverageData; | |
| } | |
| public function functionCoverageData(): array | |
| { | |
| return $this->functionCoverageData; | |
| } | |
| public function testData(): array | |
| { | |
| return $this->testData; | |
| } | |
| public function classes(): array | |
| { | |
| return $this->classes; | |
| } | |
| public function traits(): array | |
| { | |
| return $this->traits; | |
| } | |
| public function functions(): array | |
| { | |
| return $this->functions; | |
| } | |
| /** | |
| * @psalm-return array{linesOfCode: int, commentLinesOfCode: int, nonCommentLinesOfCode: int} | |
| */ | |
| public function linesOfCode(): array | |
| { | |
| return $this->linesOfCode; | |
| } | |
| public function numberOfExecutableLines(): int | |
| { | |
| return $this->numExecutableLines; | |
| } | |
| public function numberOfExecutedLines(): int | |
| { | |
| return $this->numExecutedLines; | |
| } | |
| public function numberOfExecutableBranches(): int | |
| { | |
| return $this->numExecutableBranches; | |
| } | |
| public function numberOfExecutedBranches(): int | |
| { | |
| return $this->numExecutedBranches; | |
| } | |
| public function numberOfExecutablePaths(): int | |
| { | |
| return $this->numExecutablePaths; | |
| } | |
| public function numberOfExecutedPaths(): int | |
| { | |
| return $this->numExecutedPaths; | |
| } | |
| public function numberOfClasses(): int | |
| { | |
| if ($this->numClasses === null) { | |
| $this->numClasses = 0; | |
| foreach ($this->classes as $class) { | |
| foreach ($class['methods'] as $method) { | |
| if ($method['executableLines'] > 0) { | |
| $this->numClasses++; | |
| continue 2; | |
| } | |
| } | |
| } | |
| } | |
| return $this->numClasses; | |
| } | |
| public function numberOfTestedClasses(): int | |
| { | |
| return $this->numTestedClasses; | |
| } | |
| public function numberOfTraits(): int | |
| { | |
| if ($this->numTraits === null) { | |
| $this->numTraits = 0; | |
| foreach ($this->traits as $trait) { | |
| foreach ($trait['methods'] as $method) { | |
| if ($method['executableLines'] > 0) { | |
| $this->numTraits++; | |
| continue 2; | |
| } | |
| } | |
| } | |
| } | |
| return $this->numTraits; | |
| } | |
| public function numberOfTestedTraits(): int | |
| { | |
| return $this->numTestedTraits; | |
| } | |
| public function numberOfMethods(): int | |
| { | |
| if ($this->numMethods === null) { | |
| $this->numMethods = 0; | |
| foreach ($this->classes as $class) { | |
| foreach ($class['methods'] as $method) { | |
| if ($method['executableLines'] > 0) { | |
| $this->numMethods++; | |
| } | |
| } | |
| } | |
| foreach ($this->traits as $trait) { | |
| foreach ($trait['methods'] as $method) { | |
| if ($method['executableLines'] > 0) { | |
| $this->numMethods++; | |
| } | |
| } | |
| } | |
| } | |
| return $this->numMethods; | |
| } | |
| public function numberOfTestedMethods(): int | |
| { | |
| if ($this->numTestedMethods === null) { | |
| $this->numTestedMethods = 0; | |
| foreach ($this->classes as $class) { | |
| foreach ($class['methods'] as $method) { | |
| if ($method['executableLines'] > 0 && | |
| $method['coverage'] === 100) { | |
| $this->numTestedMethods++; | |
| } | |
| } | |
| } | |
| foreach ($this->traits as $trait) { | |
| foreach ($trait['methods'] as $method) { | |
| if ($method['executableLines'] > 0 && | |
| $method['coverage'] === 100) { | |
| $this->numTestedMethods++; | |
| } | |
| } | |
| } | |
| } | |
| return $this->numTestedMethods; | |
| } | |
| public function numberOfFunctions(): int | |
| { | |
| return count($this->functions); | |
| } | |
| public function numberOfTestedFunctions(): int | |
| { | |
| if ($this->numTestedFunctions === null) { | |
| $this->numTestedFunctions = 0; | |
| foreach ($this->functions as $function) { | |
| if ($function['executableLines'] > 0 && | |
| $function['coverage'] === 100) { | |
| $this->numTestedFunctions++; | |
| } | |
| } | |
| } | |
| return $this->numTestedFunctions; | |
| } | |
| private function calculateStatistics(array $classes, array $traits, array $functions): void | |
| { | |
| foreach (range(1, $this->linesOfCode['linesOfCode']) as $lineNumber) { | |
| $this->codeUnitsByLine[$lineNumber] = []; | |
| } | |
| $this->processClasses($classes); | |
| $this->processTraits($traits); | |
| $this->processFunctions($functions); | |
| foreach (range(1, $this->linesOfCode['linesOfCode']) as $lineNumber) { | |
| if (isset($this->lineCoverageData[$lineNumber])) { | |
| foreach ($this->codeUnitsByLine[$lineNumber] as &$codeUnit) { | |
| $codeUnit['executableLines']++; | |
| } | |
| unset($codeUnit); | |
| $this->numExecutableLines++; | |
| if (count($this->lineCoverageData[$lineNumber]) > 0) { | |
| foreach ($this->codeUnitsByLine[$lineNumber] as &$codeUnit) { | |
| $codeUnit['executedLines']++; | |
| } | |
| unset($codeUnit); | |
| $this->numExecutedLines++; | |
| } | |
| } | |
| } | |
| foreach ($this->traits as &$trait) { | |
| foreach ($trait['methods'] as &$method) { | |
| $methodLineCoverage = $method['executableLines'] ? ($method['executedLines'] / $method['executableLines']) * 100 : 100; | |
| $methodBranchCoverage = $method['executableBranches'] ? ($method['executedBranches'] / $method['executableBranches']) * 100 : 0; | |
| $methodPathCoverage = $method['executablePaths'] ? ($method['executedPaths'] / $method['executablePaths']) * 100 : 0; | |
| $method['coverage'] = $methodBranchCoverage ?: $methodLineCoverage; | |
| $method['crap'] = (new CrapIndex($method['ccn'], $methodPathCoverage ?: $methodLineCoverage))->asString(); | |
| $trait['ccn'] += $method['ccn']; | |
| } | |
| unset($method); | |
| $traitLineCoverage = $trait['executableLines'] ? ($trait['executedLines'] / $trait['executableLines']) * 100 : 100; | |
| $traitBranchCoverage = $trait['executableBranches'] ? ($trait['executedBranches'] / $trait['executableBranches']) * 100 : 0; | |
| $traitPathCoverage = $trait['executablePaths'] ? ($trait['executedPaths'] / $trait['executablePaths']) * 100 : 0; | |
| $trait['coverage'] = $traitBranchCoverage ?: $traitLineCoverage; | |
| $trait['crap'] = (new CrapIndex($trait['ccn'], $traitPathCoverage ?: $traitLineCoverage))->asString(); | |
| if ($trait['executableLines'] > 0 && $trait['coverage'] === 100) { | |
| $this->numTestedClasses++; | |
| } | |
| } | |
| unset($trait); | |
| foreach ($this->classes as &$class) { | |
| foreach ($class['methods'] as &$method) { | |
| $methodLineCoverage = $method['executableLines'] ? ($method['executedLines'] / $method['executableLines']) * 100 : 100; | |
| $methodBranchCoverage = $method['executableBranches'] ? ($method['executedBranches'] / $method['executableBranches']) * 100 : 0; | |
| $methodPathCoverage = $method['executablePaths'] ? ($method['executedPaths'] / $method['executablePaths']) * 100 : 0; | |
| $method['coverage'] = $methodBranchCoverage ?: $methodLineCoverage; | |
| $method['crap'] = (new CrapIndex($method['ccn'], $methodPathCoverage ?: $methodLineCoverage))->asString(); | |
| $class['ccn'] += $method['ccn']; | |
| } | |
| unset($method); | |
| $classLineCoverage = $class['executableLines'] ? ($class['executedLines'] / $class['executableLines']) * 100 : 100; | |
| $classBranchCoverage = $class['executableBranches'] ? ($class['executedBranches'] / $class['executableBranches']) * 100 : 0; | |
| $classPathCoverage = $class['executablePaths'] ? ($class['executedPaths'] / $class['executablePaths']) * 100 : 0; | |
| $class['coverage'] = $classBranchCoverage ?: $classLineCoverage; | |
| $class['crap'] = (new CrapIndex($class['ccn'], $classPathCoverage ?: $classLineCoverage))->asString(); | |
| if ($class['executableLines'] > 0 && $class['coverage'] === 100) { | |
| $this->numTestedClasses++; | |
| } | |
| } | |
| unset($class); | |
| foreach ($this->functions as &$function) { | |
| $functionLineCoverage = $function['executableLines'] ? ($function['executedLines'] / $function['executableLines']) * 100 : 100; | |
| $functionBranchCoverage = $function['executableBranches'] ? ($function['executedBranches'] / $function['executableBranches']) * 100 : 0; | |
| $functionPathCoverage = $function['executablePaths'] ? ($function['executedPaths'] / $function['executablePaths']) * 100 : 0; | |
| $function['coverage'] = $functionBranchCoverage ?: $functionLineCoverage; | |
| $function['crap'] = (new CrapIndex($function['ccn'], $functionPathCoverage ?: $functionLineCoverage))->asString(); | |
| if ($function['coverage'] === 100) { | |
| $this->numTestedFunctions++; | |
| } | |
| } | |
| } | |
| private function processClasses(array $classes): void | |
| { | |
| $link = $this->id() . '.html#'; | |
| foreach ($classes as $className => $class) { | |
| $this->classes[$className] = [ | |
| 'className' => $className, | |
| 'namespace' => $class['namespace'], | |
| 'methods' => [], | |
| 'startLine' => $class['startLine'], | |
| 'executableLines' => 0, | |
| 'executedLines' => 0, | |
| 'executableBranches' => 0, | |
| 'executedBranches' => 0, | |
| 'executablePaths' => 0, | |
| 'executedPaths' => 0, | |
| 'ccn' => 0, | |
| 'coverage' => 0, | |
| 'crap' => 0, | |
| 'link' => $link . $class['startLine'], | |
| ]; | |
| foreach ($class['methods'] as $methodName => $method) { | |
| $methodData = $this->newMethod($className, $methodName, $method, $link); | |
| $this->classes[$className]['methods'][$methodName] = $methodData; | |
| $this->classes[$className]['executableBranches'] += $methodData['executableBranches']; | |
| $this->classes[$className]['executedBranches'] += $methodData['executedBranches']; | |
| $this->classes[$className]['executablePaths'] += $methodData['executablePaths']; | |
| $this->classes[$className]['executedPaths'] += $methodData['executedPaths']; | |
| $this->numExecutableBranches += $methodData['executableBranches']; | |
| $this->numExecutedBranches += $methodData['executedBranches']; | |
| $this->numExecutablePaths += $methodData['executablePaths']; | |
| $this->numExecutedPaths += $methodData['executedPaths']; | |
| foreach (range($method['startLine'], $method['endLine']) as $lineNumber) { | |
| $this->codeUnitsByLine[$lineNumber] = [ | |
| &$this->classes[$className], | |
| &$this->classes[$className]['methods'][$methodName], | |
| ]; | |
| } | |
| } | |
| } | |
| } | |
| private function processTraits(array $traits): void | |
| { | |
| $link = $this->id() . '.html#'; | |
| foreach ($traits as $traitName => $trait) { | |
| $this->traits[$traitName] = [ | |
| 'traitName' => $traitName, | |
| 'namespace' => $trait['namespace'], | |
| 'methods' => [], | |
| 'startLine' => $trait['startLine'], | |
| 'executableLines' => 0, | |
| 'executedLines' => 0, | |
| 'executableBranches' => 0, | |
| 'executedBranches' => 0, | |
| 'executablePaths' => 0, | |
| 'executedPaths' => 0, | |
| 'ccn' => 0, | |
| 'coverage' => 0, | |
| 'crap' => 0, | |
| 'link' => $link . $trait['startLine'], | |
| ]; | |
| foreach ($trait['methods'] as $methodName => $method) { | |
| $methodData = $this->newMethod($traitName, $methodName, $method, $link); | |
| $this->traits[$traitName]['methods'][$methodName] = $methodData; | |
| $this->traits[$traitName]['executableBranches'] += $methodData['executableBranches']; | |
| $this->traits[$traitName]['executedBranches'] += $methodData['executedBranches']; | |
| $this->traits[$traitName]['executablePaths'] += $methodData['executablePaths']; | |
| $this->traits[$traitName]['executedPaths'] += $methodData['executedPaths']; | |
| $this->numExecutableBranches += $methodData['executableBranches']; | |
| $this->numExecutedBranches += $methodData['executedBranches']; | |
| $this->numExecutablePaths += $methodData['executablePaths']; | |
| $this->numExecutedPaths += $methodData['executedPaths']; | |
| foreach (range($method['startLine'], $method['endLine']) as $lineNumber) { | |
| $this->codeUnitsByLine[$lineNumber] = [ | |
| &$this->traits[$traitName], | |
| &$this->traits[$traitName]['methods'][$methodName], | |
| ]; | |
| } | |
| } | |
| } | |
| } | |
| private function processFunctions(array $functions): void | |
| { | |
| $link = $this->id() . '.html#'; | |
| foreach ($functions as $functionName => $function) { | |
| $this->functions[$functionName] = [ | |
| 'functionName' => $functionName, | |
| 'namespace' => $function['namespace'], | |
| 'signature' => $function['signature'], | |
| 'startLine' => $function['startLine'], | |
| 'endLine' => $function['endLine'], | |
| 'executableLines' => 0, | |
| 'executedLines' => 0, | |
| 'executableBranches' => 0, | |
| 'executedBranches' => 0, | |
| 'executablePaths' => 0, | |
| 'executedPaths' => 0, | |
| 'ccn' => $function['ccn'], | |
| 'coverage' => 0, | |
| 'crap' => 0, | |
| 'link' => $link . $function['startLine'], | |
| ]; | |
| foreach (range($function['startLine'], $function['endLine']) as $lineNumber) { | |
| $this->codeUnitsByLine[$lineNumber] = [&$this->functions[$functionName]]; | |
| } | |
| if (isset($this->functionCoverageData[$functionName]['branches'])) { | |
| $this->functions[$functionName]['executableBranches'] = count( | |
| $this->functionCoverageData[$functionName]['branches'] | |
| ); | |
| $this->functions[$functionName]['executedBranches'] = count( | |
| array_filter( | |
| $this->functionCoverageData[$functionName]['branches'], | |
| static function (array $branch) | |
| { | |
| return (bool) $branch['hit']; | |
| } | |
| ) | |
| ); | |
| } | |
| if (isset($this->functionCoverageData[$functionName]['paths'])) { | |
| $this->functions[$functionName]['executablePaths'] = count( | |
| $this->functionCoverageData[$functionName]['paths'] | |
| ); | |
| $this->functions[$functionName]['executedPaths'] = count( | |
| array_filter( | |
| $this->functionCoverageData[$functionName]['paths'], | |
| static function (array $path) | |
| { | |
| return (bool) $path['hit']; | |
| } | |
| ) | |
| ); | |
| } | |
| $this->numExecutableBranches += $this->functions[$functionName]['executableBranches']; | |
| $this->numExecutedBranches += $this->functions[$functionName]['executedBranches']; | |
| $this->numExecutablePaths += $this->functions[$functionName]['executablePaths']; | |
| $this->numExecutedPaths += $this->functions[$functionName]['executedPaths']; | |
| } | |
| } | |
| private function newMethod(string $className, string $methodName, array $method, string $link): array | |
| { | |
| $methodData = [ | |
| 'methodName' => $methodName, | |
| 'visibility' => $method['visibility'], | |
| 'signature' => $method['signature'], | |
| 'startLine' => $method['startLine'], | |
| 'endLine' => $method['endLine'], | |
| 'executableLines' => 0, | |
| 'executedLines' => 0, | |
| 'executableBranches' => 0, | |
| 'executedBranches' => 0, | |
| 'executablePaths' => 0, | |
| 'executedPaths' => 0, | |
| 'ccn' => $method['ccn'], | |
| 'coverage' => 0, | |
| 'crap' => 0, | |
| 'link' => $link . $method['startLine'], | |
| ]; | |
| $key = $className . '->' . $methodName; | |
| if (isset($this->functionCoverageData[$key]['branches'])) { | |
| $methodData['executableBranches'] = count( | |
| $this->functionCoverageData[$key]['branches'] | |
| ); | |
| $methodData['executedBranches'] = count( | |
| array_filter( | |
| $this->functionCoverageData[$key]['branches'], | |
| static function (array $branch) | |
| { | |
| return (bool) $branch['hit']; | |
| } | |
| ) | |
| ); | |
| } | |
| if (isset($this->functionCoverageData[$key]['paths'])) { | |
| $methodData['executablePaths'] = count( | |
| $this->functionCoverageData[$key]['paths'] | |
| ); | |
| $methodData['executedPaths'] = count( | |
| array_filter( | |
| $this->functionCoverageData[$key]['paths'], | |
| static function (array $path) | |
| { | |
| return (bool) $path['hit']; | |
| } | |
| ) | |
| ); | |
| } | |
| return $methodData; | |
| } | |
| } | |