Exclude mutations that are over specified time limit

src/Console/OutputFormatter/DotFormatter.php

@@ -66,7 +66,8 @@ public function start(int $mutationCount): void
             . '<escaped>M</escaped>: escaped, '
             . '<uncovered>U</uncovered>: uncovered, '
             . '<with-error>E</with-error>: fatal error, '
-            . '<timeout>T</timeout>: timed out',
+            . '<timeout>T</timeout>: timed out, '
+            . '<skipped>S</skipped>: skipped',
             '',
         ]);
     }
@@ -91,6 +92,10 @@ public function advance(MutantExecutionResult $executionResult, int $mutationCou
             case DetectionStatus::TIMED_OUT:
                 $this->output->write('<timeout>T</timeout>');
 
+                break;
+            case DetectionStatus::SKIPPED:
+                $this->output->write('<skipped>S</skipped>');
+
                 break;
             case DetectionStatus::ERROR:
                 $this->output->write('<with-error>E</with-error>');

src/Console/OutputFormatterStyleConfigurator.php

@@ -69,6 +69,7 @@ private static function configureMutantStyle(OutputFormatterInterface $formatter
             new OutputFormatterStyle('red', null, ['bold'])
         );
         $formatter->setStyle('killed', new OutputFormatterStyle('green'));
+        $formatter->setStyle('skipped', new OutputFormatterStyle('magenta'));
         $formatter->setStyle('code', new OutputFormatterStyle('white'));
     }
 

src/Container.php

@@ -565,7 +565,8 @@ public static function create(): self
                     $container->getConfiguration()->isDryRun()
                         ? new DummyFileSystem()
                         : $container->getFileSystem(),
-                    $container->getConfiguration()->noProgress()
+                    $container->getConfiguration()->noProgress(),
+                    $container->getConfiguration()->getProcessTimeout()
                 );
             },
             LineRangeCalculator::class => static function (): LineRangeCalculator {

src/Event/MutantProcessWasFinished.php

@@ -39,8 +39,9 @@
 
 /**
  * @internal
+ * @final
  */
-final class MutantProcessWasFinished
+class MutantProcessWasFinished
 {
     private $executionResult;
 

src/Event/Subscriber/MutationTestingConsoleLoggerSubscriber.php

@@ -151,6 +151,7 @@ private function showMetrics(): void
         $this->output->writeln('<options=bold>' . $this->getPadded($this->metricsCalculator->getEscapedCount()) . '</options=bold> covered mutants were not detected');
         $this->output->writeln('<options=bold>' . $this->getPadded($this->metricsCalculator->getErrorCount()) . '</options=bold> errors were encountered');
         $this->output->writeln('<options=bold>' . $this->getPadded($this->metricsCalculator->getTimedOutCount()) . '</options=bold> time outs were encountered');
+        $this->output->writeln('<options=bold>' . $this->getPadded($this->metricsCalculator->getSkippedCount()) . '</options=bold> mutants required more time than configured');
 
         $mutationScoreIndicator = floor($this->metricsCalculator->getMutationScoreIndicator());
         $msiTag = $this->getPercentageTag($mutationScoreIndicator);

src/Logger/DebugFileLogger.php

@@ -88,6 +88,11 @@ public function getLogLines(): array
             'Timed Out',
             $separateSections
         );
+        $logs[] = $this->getResultsLine(
+            $this->metricsCalculator->getSkippedExecutionResults(),
+            'Skipped',
+            $separateSections
+        );
 
         if (!$this->onlyCoveredMode) {
             $logs[] = $this->getResultsLine(

src/Logger/JsonLogger.php

@@ -69,6 +69,7 @@ public function getLogLines(): array
                 'notCoveredCount' => $this->metricsCalculator->getNotTestedCount(),
                 'escapedCount' => $this->metricsCalculator->getEscapedCount(),
                 'errorCount' => $this->metricsCalculator->getErrorCount(),
+                'skippedCount' => $this->metricsCalculator->getSkippedCount(),
                 'timeOutCount' => $this->metricsCalculator->getTimedOutCount(),
                 'msi' => $this->metricsCalculator->getMutationScoreIndicator(),
                 'mutationCodeCoverage' => $this->metricsCalculator->getCoverageRate(),

src/Logger/PerMutatorLogger.php

@@ -68,7 +68,7 @@ public function getLogLines(): array
         $calculatorPerMutator = $this->createMetricsPerMutators();
 
         $table = [
-            ['Mutator', 'Mutations', 'Killed', 'Escaped', 'Errors', 'Timed Out', 'MSI (%s)', 'Covered MSI (%s)'],
+            ['Mutator', 'Mutations', 'Killed', 'Escaped', 'Errors', 'Timed Out', 'Skipped', 'MSI (%s)', 'Covered MSI (%s)'],
         ];
 
         foreach ($calculatorPerMutator as $mutatorName => $calculator) {
@@ -81,6 +81,7 @@ public function getLogLines(): array
                 (string) $calculator->getEscapedCount(),
                 (string) $calculator->getErrorCount(),
                 (string) $calculator->getTimedOutCount(),
+                (string) $calculator->getSkippedCount(),
                 self::formatScore($calculator->getMutationScoreIndicator()),
                 self::formatScore($calculator->getCoveredCodeMutationScoreIndicator()),
             ];

src/Logger/SummaryFileLogger.php

@@ -61,6 +61,7 @@ public function getLogLines(): array
             'Errored: ' . $this->metricsCalculator->getErrorCount(),
             'Escaped: ' . $this->metricsCalculator->getEscapedCount(),
             'Timed Out: ' . $this->metricsCalculator->getTimedOutCount(),
+            'Skipped: ' . $this->metricsCalculator->getSkippedCount(),
             'Not Covered: ' . $this->metricsCalculator->getNotTestedCount(),
             '',
         ];

src/Logger/TextFileLogger.php

@@ -77,18 +77,26 @@ public function getLogLines(): array
             'Escaped',
             $separateSections
         );
+
         $logs[] = $this->getResultsLine(
             $this->metricsCalculator->getTimedOutExecutionResults(),
             'Timed Out',
             $separateSections
         );
 
+        $logs[] = $this->getResultsLine(
+            $this->metricsCalculator->getSkippedExecutionResults(),
+            'Skipped',
+            $separateSections
+        );
+
         if ($this->debugVerbosity) {
             $logs[] = $this->getResultsLine(
                 $this->metricsCalculator->getKilledExecutionResults(),
                 'Killed',
                 $separateSections
             );
+
             $logs[] = $this->getResultsLine(
                 $this->metricsCalculator->getErrorExecutionResults(),
                 'Errors',

src/Metrics/Calculator.php

@@ -89,7 +89,7 @@ public static function fromMetrics(MetricsCalculator $calculator): self
             $calculator->getErrorCount(),
             $calculator->getTimedOutCount(),
             $calculator->getNotTestedCount(),
-            $calculator->getTotalMutantsCount()
+            $calculator->getTestedMutantsCount()
         );
     }
 

src/Metrics/MetricsCalculator.php

@@ -51,6 +51,7 @@ class MetricsCalculator
     private $errorExecutionResults;
     private $escapedExecutionResults;
     private $timedOutExecutionResults;
+    private $skippedExecutionResults;
     private $notCoveredExecutionResults;
     private $allExecutionResults;
 
@@ -64,6 +65,11 @@ class MetricsCalculator
      */
     private $errorCount = 0;
 
+    /**
+     * @var int
+     */
+    private $skippedCount = 0;
+
     /**
      * @var int
      */
@@ -96,6 +102,7 @@ public function __construct(int $roundingPrecision)
         $this->errorExecutionResults = new SortableMutantExecutionResults();
         $this->escapedExecutionResults = new SortableMutantExecutionResults();
         $this->timedOutExecutionResults = new SortableMutantExecutionResults();
+        $this->skippedExecutionResults = new SortableMutantExecutionResults();
         $this->notCoveredExecutionResults = new SortableMutantExecutionResults();
         $this->allExecutionResults = new SortableMutantExecutionResults();
     }
@@ -136,6 +143,12 @@ public function collect(MutantExecutionResult ...$executionResults): void
 
                     break;
 
+                case DetectionStatus::SKIPPED:
+                    $this->skippedCount++;
+                    $this->skippedExecutionResults->add($executionResult);
+
+                    break;
+
                 case DetectionStatus::ERROR:
                     $this->errorCount++;
                     $this->errorExecutionResults->add($executionResult);
@@ -172,6 +185,14 @@ public function getErrorExecutionResults(): array
         return $this->errorExecutionResults->getSortedExecutionResults();
     }
 
+    /**
+     * @return MutantExecutionResult[]
+     */
+    public function getSkippedExecutionResults(): array
+    {
+        return $this->skippedExecutionResults->getSortedExecutionResults();
+    }
+
     /**
      * @return MutantExecutionResult[]
      */
@@ -214,6 +235,11 @@ public function getErrorCount(): int
         return $this->errorCount;
     }
 
+    public function getSkippedCount(): int
+    {
+        return $this->skippedCount;
+    }
+
     public function getEscapedCount(): int
     {
         return $this->escapedCount;
@@ -234,6 +260,11 @@ public function getTotalMutantsCount(): int
         return $this->totalMutantsCount;
     }
 
+    public function getTestedMutantsCount(): int
+    {
+        return $this->totalMutantsCount - $this->skippedCount;
+    }
+
     /**
      * Mutation Score Indicator (MSI)
      */

src/Mutant/DetectionStatus.php

@@ -48,13 +48,15 @@ final class DetectionStatus
     public const ESCAPED = 'escaped';
     public const ERROR = 'error';
     public const TIMED_OUT = 'timed out';
+    public const SKIPPED = 'skipped';
     public const NOT_COVERED = 'not covered';
 
     public const ALL = [
         self::KILLED,
         self::ESCAPED,
         self::ERROR,
         self::TIMED_OUT,
+        self::SKIPPED,
         self::NOT_COVERED,
     ];
 }

src/Mutant/MutantExecutionResult.php

@@ -82,19 +82,12 @@ public function __construct(
 
     public static function createFromNonCoveredMutant(Mutant $mutant): self
     {
-        $mutation = $mutant->getMutation();
+        return self::createFromMutant($mutant, DetectionStatus::NOT_COVERED);
+    }
 
-        return new self(
-            '',
-            '',
-            DetectionStatus::NOT_COVERED,
-            $mutant->getDiff(),
-            $mutant->getMutation()->getMutatorName(),
-            $mutation->getOriginalFilePath(),
-            $mutation->getOriginalStartingLine(),
-            $mutant->getPrettyPrintedOriginalCode(),
-            $mutant->getMutatedCode()
-        );
+    public static function createFromTimeSkippedMutant(Mutant $mutant): self
+    {
+        return self::createFromMutant($mutant, DetectionStatus::SKIPPED);
     }
 
     public function getProcessCommandLine(): string
@@ -141,4 +134,21 @@ public function getMutatedCode(): string
     {
         return $this->mutatedCode;
     }
+
+    private static function createFromMutant(Mutant $mutant, string $detectionStatus): self
+    {
+        $mutation = $mutant->getMutation();
+
+        return new self(
+            '',
+            '',
+            $detectionStatus,
+            $mutant->getDiff(),
+            $mutant->getMutation()->getMutatorName(),
+            $mutation->getOriginalFilePath(),
+            $mutation->getOriginalStartingLine(),
+            $mutant->getPrettyPrintedOriginalCode(),
+            $mutant->getMutatedCode()
+        );
+    }
 }

src/Mutation/Mutation.php

@@ -37,7 +37,8 @@
 
 use function array_intersect_key;
 use function array_keys;
-use function count;
+use function array_map;
+use function array_sum;
 use function implode;
 use Infection\AbstractTestFramework\Coverage\TestLocation;
 use Infection\Mutator\ProfileList;
@@ -62,6 +63,10 @@ class Mutation
     private $originalFileAst;
     private $tests;
     private $coveredByTests;
+    /**
+     * @var float|null
+     */
+    private $nominalTimeToTest;
 
     /**
      * @var string|null
@@ -97,7 +102,7 @@ public function __construct(
         $this->mutatedNode = $mutatedNode;
         $this->mutationByMutatorIndex = $mutationByMutatorIndex;
         $this->tests = $tests;
-        $this->coveredByTests = count($tests) > 0;
+        $this->coveredByTests = $tests !== [];
     }
 
     public function getOriginalFilePath(): string
@@ -155,6 +160,19 @@ public function getAllTests(): array
         return $this->tests;
     }
 
+    /**
+     * Overall time needed to run known tests for a mutation, excluding dependencies.
+     */
+    public function getNominalTestExecutionTime(): float
+    {
+        return $this->nominalTimeToTest ?? $this->nominalTimeToTest = array_sum(array_map(
+            static function (TestLocation $testLocation) {
+                return $testLocation->getExecutionTime();
+            },
+            $this->tests
+        ));
+    }
+
     public function getHash(): string
     {
         return $this->hash ?? $this->hash = $this->createHash();

src/Process/Factory/MutantProcessFactory.php

@@ -58,7 +58,7 @@ class MutantProcessFactory
     // TODO: is it necessary for the timeout to be an int?
     public function __construct(
         TestFrameworkAdapter $testFrameworkAdapter,
-        int $timeout,
+        float $timeout,
         EventDispatcher $eventDispatcher,
         MutantExecutionResultFactory $resultFactory
     ) {
@@ -80,7 +80,7 @@ public function createProcessForMutant(Mutant $mutant, string $testFrameworkExtr
             )
         );
 
-        $process->setTimeout((float) $this->timeout);
+        $process->setTimeout($this->timeout);
 
         if (method_exists($process, 'inheritEnvironmentVariables')) {
             // in version 4.4.0 this method is deprecated and removed in 5.0.0

src/Process/Runner/MutationTestingRunner.php

@@ -59,21 +59,24 @@ final class MutationTestingRunner
     private $eventDispatcher;
     private $fileSystem;
     private $runConcurrently;
+    private $timeout;
 
     public function __construct(
         MutantProcessFactory $processFactory,
         MutantFactory $mutantFactory,
         ProcessRunner $processRunner,
         EventDispatcher $eventDispatcher,
         Filesystem $fileSystem,
-        bool $runConcurrently
+        bool $runConcurrently,
+        float $timeout
     ) {
         $this->processFactory = $processFactory;
         $this->mutantFactory = $mutantFactory;
         $this->processRunner = $processRunner;
         $this->eventDispatcher = $eventDispatcher;
         $this->fileSystem = $fileSystem;
         $this->runConcurrently = $runConcurrently;
+        $this->timeout = $timeout;
     }
 
     /**
@@ -100,6 +103,17 @@ public function run(iterable $mutations, string $testFrameworkExtraOptions): voi
 
                 return false;
             })
+            ->filter(function (Mutant $mutant) {
+                if ($mutant->getMutation()->getNominalTestExecutionTime() < $this->timeout) {
+                    return true;
+                }
+
+                $this->eventDispatcher->dispatch(new MutantProcessWasFinished(
+                    MutantExecutionResult::createFromTimeSkippedMutant($mutant)
+                ));
+
+                return false;
+            })
             ->map(function (Mutant $mutant) use ($testFrameworkExtraOptions): ProcessBearer {
                 $this->fileSystem->dumpFile($mutant->getFilePath(), $mutant->getMutatedCode());
 

tests/e2e/Config_Bootstrap/expected-file.txt

@@ -1 +1 @@
-Hello World!
+Hello World!