Merge pull request #659 from pestphp/pest-parallel

Parallel support

bin/pest

@@ -17,6 +17,7 @@ use Symfony\Component\Console\Output\OutputInterface;
     $_SERVER['COLLISION_PRINTER'] = 'DefaultPrinter';
 
     $args = $_SERVER['argv'];
+
     $dirty = false;
     $todo = false;
 
@@ -68,11 +69,11 @@ use Symfony\Component\Console\Output\OutputInterface;
 
     // Get $rootPath based on $autoloadPath
     $rootPath = dirname($autoloadPath, 2);
-    $argv = new ArgvInput();
+    $input = new ArgvInput();
 
     $testSuite = TestSuite::getInstance(
         $rootPath,
-        $argv->getParameterOption('--test-directory', (new ConfigLoader($rootPath))->getTestsDirectory()),
+        $input->getParameterOption('--test-directory', (new ConfigLoader($rootPath))->getTestsDirectory()),
     );
 
     if ($dirty) {
@@ -83,19 +84,13 @@ use Symfony\Component\Console\Output\OutputInterface;
         $testSuite->tests->addTestCaseMethodFilter(new TodoTestCaseFilter());
     }
 
-    $isDecorated = $argv->getParameterOption('--colors', 'always') !== 'never';
+    $isDecorated = $input->getParameterOption('--colors', 'always') !== 'never';
 
     $output = new ConsoleOutput(ConsoleOutput::VERBOSITY_NORMAL, $isDecorated);
 
-    $container = Container::getInstance();
+    $kernel = Kernel::boot($testSuite, $input, $output);
-    $container->add(TestSuite::class, $testSuite);
-    $container->add(OutputInterface::class, $output);
-    $container->add(InputInterface::class, $argv);
-    $container->add(Container::class, $container);
 
-    $kernel = Kernel::boot();
+    $result = $kernel->handle($args);
-
-    $result = $kernel->handle($output, $args);
 
     $kernel->shutdown();
 

bin/worker.php

@@ -0,0 +1,110 @@
+<?php
+
+declare(strict_types=1);
+
+use ParaTest\WrapperRunner\ApplicationForWrapperWorker;
+use ParaTest\WrapperRunner\WrapperWorker;
+use Pest\ConfigLoader;
+use Pest\Kernel;
+use Pest\Plugins\Actions\CallsHandleArguments;
+use Pest\TestCaseMethodFilters\TodoTestCaseFilter;
+use Pest\TestSuite;
+use Symfony\Component\Console\Input\ArgvInput;
+use Symfony\Component\Console\Output\ConsoleOutput;
+use Symfony\Component\Console\Output\OutputInterface;
+
+$bootPest = (static function (): void {
+    $workerArgv = new ArgvInput();
+    $masterArgv = new ArgvInput(json_decode($_SERVER['PEST_PARALLEL_ARGV']));
+
+    $rootPath = dirname(PHPUNIT_COMPOSER_INSTALL, 2);
+    $testSuite = TestSuite::getInstance($rootPath, $workerArgv->getParameterOption(
+        '--test-directory',
+        (new ConfigLoader($rootPath))->getTestsDirectory()
+    ));
+
+    if ($masterArgv->hasParameterOption('--todo')) {
+        $testSuite->tests->addTestCaseMethodFilter(new TodoTestCaseFilter());
+    }
+
+    $input = new ArgvInput();
+
+    $output = new ConsoleOutput(OutputInterface::VERBOSITY_NORMAL, true);
+
+    Kernel::boot($testSuite, $input, $output);
+});
+
+(static function () use ($bootPest): void {
+    $getopt = getopt('', [
+        'status-file:',
+        'progress-file:',
+        'testresult-file:',
+        'teamcity-file:',
+        'testdox-file:',
+        'testdox-color',
+        'phpunit-argv:',
+    ]);
+
+    require_once __DIR__.'/../overrides/Runner/TestSuiteLoader.php';
+    require_once __DIR__.'/../overrides/Runner/Filter/NameFilterIterator.php';
+
+    $composerAutoloadFiles = [
+        dirname(__DIR__, 3).DIRECTORY_SEPARATOR.'autoload.php',
+        dirname(__DIR__, 2).DIRECTORY_SEPARATOR.'vendor'.DIRECTORY_SEPARATOR.'autoload.php',
+        dirname(__DIR__).DIRECTORY_SEPARATOR.'vendor'.DIRECTORY_SEPARATOR.'autoload.php',
+    ];
+
+    foreach ($composerAutoloadFiles as $file) {
+        if (file_exists($file)) {
+            require_once $file;
+            define('PHPUNIT_COMPOSER_INSTALL', $file);
+
+            break;
+        }
+    }
+
+    assert(isset($getopt['status-file']) && is_string($getopt['status-file']));
+    $statusFile = fopen($getopt['status-file'], 'wb');
+    assert(is_resource($statusFile));
+
+    assert(isset($getopt['progress-file']) && is_string($getopt['progress-file']));
+    assert(isset($getopt['testresult-file']) && is_string($getopt['testresult-file']));
+    assert(! isset($getopt['teamcity-file']) || is_string($getopt['teamcity-file']));
+    assert(! isset($getopt['testdox-file']) || is_string($getopt['testdox-file']));
+
+    assert(isset($getopt['phpunit-argv']) && is_string($getopt['phpunit-argv']));
+    $phpunitArgv = unserialize($getopt['phpunit-argv'], ['allowed_classes' => false]);
+    assert(is_array($phpunitArgv));
+
+    $bootPest();
+
+    $phpunitArgv = (new CallsHandleArguments())($phpunitArgv);
+
+    $application = new ApplicationForWrapperWorker(
+        $phpunitArgv,
+        $getopt['progress-file'],
+        $getopt['testresult-file'],
+        $getopt['teamcity-file'] ?? null,
+        $getopt['testdox-file'] ?? null,
+        isset($getopt['testdox-color']),
+    );
+
+    while (true) {
+        if (feof(STDIN)) {
+            $application->end();
+            exit;
+        }
+
+        $testPath = fgets(STDIN);
+        if ($testPath === false || $testPath === WrapperWorker::COMMAND_EXIT) {
+            $application->end();
+
+            exit;
+        }
+
+        $exitCode = $application->runTest(trim($testPath));
+
+        fwrite($statusFile, (string) $exitCode);
+        fflush($statusFile);
+    }
+})();

composer.json

@@ -23,6 +23,9 @@
         "pestphp/pest-plugin": "^2.0.0",
         "phpunit/phpunit": "^10.0.7"
     },
+    "conflict": {
+        "brianium/paratest": "<7.0.4"
+    },
     "version": "2.x-dev",
     "autoload": {
         "psr-4": {
@@ -43,6 +46,7 @@
         ]
     },
     "require-dev": {
+        "brianium/paratest": "^7.0.5",
         "pestphp/pest-dev-tools": "^2.4.0",
         "pestphp/pest-plugin-arch": "^2.0.0",
         "symfony/process": "^6.2.5"
@@ -89,7 +93,8 @@
                 "Pest\\Plugins\\Memory",
                 "Pest\\Plugins\\Printer",
                 "Pest\\Plugins\\Retry",
-                "Pest\\Plugins\\Version"
+                "Pest\\Plugins\\Version",
+                "Pest\\Plugins\\Parallel"
             ]
         }
     }

docker/Dockerfile

@@ -12,6 +12,10 @@ RUN docker-php-ext-configure intl
 RUN docker-php-ext-install intl
 RUN docker-php-ext-enable intl
 
+RUN apk add --no-cache $PHPIZE_DEPS linux-headers
+RUN pecl install xdebug
+RUN docker-php-ext-enable xdebug
+
 COPY --from=composer:2 /usr/bin/composer /usr/bin/composer
 
 WORKDIR /var/www/html

phpstan.neon

@@ -12,9 +12,10 @@ parameters:
     reportUnmatchedIgnoredErrors: true
 
     ignoreErrors:
+        - "#Language construct isset\\(\\) should not be used.#"
+        - "#is not allowed to extend#"
         - "#with a nullable type declaration#"
         - "#type mixed is not subtype of native#"
-        - "#is not allowed to extend#"
         - "# with null as default value#"
         - "#has parameter \\$closure with default value.#"
         - "#has parameter \\$description with default value.#"

src/Kernel.php

@@ -11,7 +11,7 @@ use Pest\Plugins\Actions\CallsBoot;
 use Pest\Plugins\Actions\CallsShutdown;
 use Pest\Support\Container;
 use PHPUnit\TextUI\Application;
-use PHPUnit\TextUI\Exception;
+use Symfony\Component\Console\Input\InputInterface;
 use Symfony\Component\Console\Output\OutputInterface;
 
 /**
@@ -36,7 +36,8 @@ final class Kernel
      * Creates a new Kernel instance.
      */
     public function __construct(
-        private readonly Application $application
+        private readonly Application $application,
+        private readonly OutputInterface $output,
     ) {
         register_shutdown_function(function (): void {
             if (error_get_last() !== null) {
@@ -50,8 +51,16 @@ final class Kernel
     /**
      * Boots the Kernel.
      */
-    public static function boot(): self
+    public static function boot(TestSuite $testSuite, InputInterface $input, OutputInterface $output): self
     {
+        $container = Container::getInstance();
+
+        $container
+            ->add(TestSuite::class, $testSuite)
+            ->add(InputInterface::class, $input)
+            ->add(OutputInterface::class, $output)
+            ->add(Container::class, $container);
+
         foreach (self::BOOTSTRAPPERS as $bootstrapper) {
             $bootstrapper = Container::getInstance()->get($bootstrapper);
             assert($bootstrapper instanceof Bootstrapper);
@@ -61,24 +70,25 @@ final class Kernel
 
         (new CallsBoot())->__invoke();
 
-        return new self(new Application());
+        return new self(
+            new Application(),
+            $output,
+        );
     }
 
     /**
-     * Handles the given argv.
+     * Runs the application, and returns the exit code.
      *
-     * @param  array<int, string>  $argv
+     * @param  array<int, string>  $args
-     *
-     * @throws Exception
      */
-    public function handle(OutputInterface $output, array $argv): int
+    public function handle(array $args): int
     {
-        $argv = (new Plugins\Actions\CallsHandleArguments())->__invoke($argv);
+        $args = (new Plugins\Actions\CallsHandleArguments())->__invoke($args);
 
         try {
-            $this->application->run($argv);
+            $this->application->run($args);
         } catch (NoTestsFound) {
-            $output->writeln([
+            $this->output->writeln([
                 '',
                 '  <fg=white;options=bold;bg=blue> INFO </> No tests found.',
                 '',

src/Logging/TeamCity/Converter.php

@@ -5,20 +5,14 @@ declare(strict_types=1);
 namespace Pest\Logging\TeamCity;
 
 use NunoMaduro\Collision\Adapters\Phpunit\State;
-use NunoMaduro\Collision\Adapters\Phpunit\TestResult;
 use Pest\Exceptions\ShouldNotHappen;
+use Pest\Support\StateGenerator;
 use Pest\Support\Str;
 use PHPUnit\Event\Code\Test;
-use PHPUnit\Event\Code\TestDox;
 use PHPUnit\Event\Code\TestMethod;
 use PHPUnit\Event\Code\Throwable;
-use PHPUnit\Event\Test\Errored;
-use PHPUnit\Event\TestData\TestDataCollection;
 use PHPUnit\Event\TestSuite\TestSuite;
 use PHPUnit\Framework\Exception as FrameworkException;
-use PHPUnit\Framework\IncompleteTestError;
-use PHPUnit\Framework\SkippedWithMessageException;
-use PHPUnit\Metadata\MetadataCollection;
 use PHPUnit\TestRunner\TestResult\TestResult as PhpUnitTestResult;
 
 /**
@@ -28,12 +22,15 @@ final class Converter
 {
     private const PREFIX = 'P\\';
 
+    private readonly StateGenerator $stateGenerator;
+
     /**
      * Creates a new instance of the Converter.
      */
     public function __construct(
         private readonly string $rootPath,
     ) {
+        $this->stateGenerator = new StateGenerator();
     }
 
     /**
@@ -183,83 +180,6 @@ final class Converter
      */
     public function getStateFromResult(PhpUnitTestResult $result): State
     {
-        $state = new State();
+        return $this->stateGenerator->fromPhpUnitTestResult($result);
-
-        foreach ($result->testErroredEvents() as $resultEvent) {
-            assert($resultEvent instanceof Errored);
-            $state->add(TestResult::fromTestCase(
-                $resultEvent->test(),
-                TestResult::FAIL,
-                $resultEvent->throwable()
-            ));
-        }
-
-        foreach ($result->testFailedEvents() as $resultEvent) {
-            $state->add(TestResult::fromTestCase(
-                $resultEvent->test(),
-                TestResult::FAIL,
-                $resultEvent->throwable()
-            ));
-        }
-
-        foreach ($result->testMarkedIncompleteEvents() as $resultEvent) {
-            $state->add(TestResult::fromTestCase(
-                $resultEvent->test(),
-                TestResult::INCOMPLETE,
-                $resultEvent->throwable()
-            ));
-        }
-
-        foreach ($result->testConsideredRiskyEvents() as $riskyEvents) {
-            foreach ($riskyEvents as $riskyEvent) {
-                $state->add(TestResult::fromTestCase(
-                    $riskyEvent->test(),
-                    TestResult::RISKY,
-                    Throwable::from(new IncompleteTestError($riskyEvent->message()))
-                ));
-            }
-        }
-
-        foreach ($result->testSkippedEvents() as $resultEvent) {
-            if ($resultEvent->message() === '__TODO__') {
-                $state->add(TestResult::fromTestCase($resultEvent->test(), TestResult::TODO));
-
-                continue;
-            }
-
-            $state->add(TestResult::fromTestCase(
-                $resultEvent->test(),
-                TestResult::SKIPPED,
-                Throwable::from(new SkippedWithMessageException($resultEvent->message()))
-            ));
-        }
-
-        $numberOfPassedTests = $result->numberOfTests()
-            - $result->numberOfTestErroredEvents()
-            - $result->numberOfTestFailedEvents()
-            - $result->numberOfTestSkippedEvents()
-            - $result->numberOfTestsWithTestConsideredRiskyEvents()
-            - $result->numberOfTestMarkedIncompleteEvents();
-
-        for ($i = 0; $i < $numberOfPassedTests; $i++) {
-            $state->add(TestResult::fromTestCase(
-
-                new TestMethod(
-                    /** @phpstan-ignore-next-line */
-                    "$i",
-                    /** @phpstan-ignore-next-line */
-                    '',
-                    '',
-                    1,
-                    /** @phpstan-ignore-next-line */
-                    TestDox::fromClassNameAndMethodName('', ''),
-                    MetadataCollection::fromArray([]),
-                    TestDataCollection::fromArray([])
-                ),
-                TestResult::PASS
-            ));
-        }
-
-        return $state;
     }
 }

src/Plugins/Parallel.php

@@ -0,0 +1,139 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins;
+
+use JsonException;
+use ParaTest\ParaTestCommand;
+use Pest\Contracts\Plugins\HandlesArguments;
+use Pest\Plugins\Actions\CallsAddsOutput;
+use Pest\Plugins\Concerns\HandleArguments;
+use Pest\Plugins\Parallel\Contracts\HandlersWorkerArguments;
+use Pest\Plugins\Parallel\Paratest\CleanConsoleOutput;
+use Pest\Support\Arr;
+use Pest\Support\Container;
+use Pest\TestSuite;
+use function Pest\version;
+use Symfony\Component\Console\Application;
+use Symfony\Component\Console\Command\Command;
+use Symfony\Component\Console\Input\ArgvInput;
+use Symfony\Component\Console\Output\OutputInterface;
+
+final class Parallel implements HandlesArguments
+{
+    use HandleArguments;
+
+    private const HANDLERS = [
+        Parallel\Handlers\Parallel::class,
+        Parallel\Handlers\Pest::class,
+        Parallel\Handlers\Laravel::class,
+    ];
+
+    public static function isInParallelProcess(): bool
+    {
+        $argvValue = Arr::get($_SERVER, 'PARATEST');
+
+        assert(is_string($argvValue) || is_int($argvValue) || is_null($argvValue));
+
+        return ((int) $argvValue) === 1;
+    }
+
+    public function handleArguments(array $arguments): array
+    {
+        if ($this->argumentsContainParallelFlags($arguments)) {
+            exit($this->runTestSuiteInParallel($arguments));
+        }
+
+        if (self::isInParallelProcess()) {
+            return $this->runWorkersHandlers($arguments);
+        }
+
+        return $arguments;
+    }
+
+    /**
+     * @param  array<int, string>  $arguments
+     */
+    private function argumentsContainParallelFlags(array $arguments): bool
+    {
+        if ($this->hasArgument('--parallel', $arguments)) {
+            return true;
+        }
+
+        return $this->hasArgument('-p', $arguments);
+    }
+
+    /**
+     * @param  array<int, string>  $arguments
+     *
+     * @throws JsonException
+     */
+    private function runTestSuiteInParallel(array $arguments): int
+    {
+        if (! class_exists(ParaTestCommand::class)) {
+            $this->askUserToInstallParatest();
+
+            return Command::FAILURE;
+        }
+
+        $_ENV['PEST_PARALLEL_ARGV'] = json_encode($_SERVER['argv'], JSON_THROW_ON_ERROR);
+
+        $handlers = array_filter(
+            array_map(fn ($handler): object|string => Container::getInstance()->get($handler), self::HANDLERS),
+            fn ($handler): bool => $handler instanceof HandlesArguments,
+        );
+
+        $filteredArguments = array_reduce(
+            $handlers,
+            fn ($arguments, HandlesArguments $handler): array => $handler->handleArguments($arguments),
+            $arguments
+        );
+
+        $exitCode = $this->paratestCommand()->run(new ArgvInput($filteredArguments), new CleanConsoleOutput());
+
+        return (new CallsAddsOutput())($exitCode);
+    }
+
+    /**
+     * @param  array<int, string>  $arguments
+     * @return array<int, string>
+     */
+    private function runWorkersHandlers(array $arguments): array
+    {
+        $handlers = array_filter(
+            array_map(fn ($handler): object|string => Container::getInstance()->get($handler), self::HANDLERS),
+            fn ($handler): bool => $handler instanceof HandlersWorkerArguments,
+        );
+
+        return array_reduce(
+            $handlers,
+            fn ($arguments, HandlersWorkerArguments $handler): array => $handler->handleWorkerArguments($arguments),
+            $arguments
+        );
+    }
+
+    private function askUserToInstallParatest(): void
+    {
+        /** @var OutputInterface $output */
+        $output = Container::getInstance()->get(OutputInterface::class);
+
+        $output->writeln([
+            '<fg=red>Pest Parallel requires ParaTest to run.</>',
+            'Please run <fg=yellow>composer require --dev brianium/paratest</>.',
+        ]);
+    }
+
+    private function paratestCommand(): Application
+    {
+        /** @var non-empty-string $rootPath */
+        $rootPath = TestSuite::getInstance()->rootPath;
+
+        $command = ParaTestCommand::applicationFactory($rootPath);
+        $command->setAutoExit(false);
+        $command->setName('Pest');
+        $command->setVersion(version());
+
+        return $command;
+    }
+}

src/Plugins/Parallel/Contracts/HandlersWorkerArguments.php

@@ -0,0 +1,14 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Parallel\Contracts;
+
+interface HandlersWorkerArguments
+{
+    /**
+     * @param  array<int, string>  $arguments
+     * @return array<int, string>
+     */
+    public function handleWorkerArguments(array $arguments): array;
+}

src/Plugins/Parallel/Handlers/Laravel.php

@@ -0,0 +1,87 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Parallel\Handlers;
+
+use Composer\InstalledVersions;
+use Illuminate\Testing\ParallelRunner;
+use ParaTest\Options;
+use ParaTest\RunnerInterface;
+use Pest\Contracts\Plugins\HandlesArguments;
+use Pest\Plugins\Concerns\HandleArguments;
+use Pest\Plugins\Parallel\Paratest\WrapperRunner;
+use Symfony\Component\Console\Output\OutputInterface;
+
+/**
+ * @internal
+ */
+final class Laravel implements HandlesArguments
+{
+    use HandleArguments;
+
+    public function handleArguments(array $arguments): array
+    {
+        if (! self::isALaravelApplication()) {
+            return $arguments;
+        }
+
+        $this->setLaravelParallelRunner();
+
+        $arguments = $this->setEnvironmentVariables($arguments);
+
+        return $this->useLaravelRunner($arguments);
+    }
+
+    private function setLaravelParallelRunner(): void
+    {
+        ParallelRunner::resolveRunnerUsing( // @phpstan-ignore-line
+            fn (Options $options, OutputInterface $output): RunnerInterface => new WrapperRunner($options, $output)
+        );
+    }
+
+    private static function isALaravelApplication(): bool
+    {
+        if (! InstalledVersions::isInstalled('laravel/framework', false)) {
+            return false;
+        }
+
+        return ! class_exists(\Orchestra\Testbench\TestCase::class);
+    }
+
+    /**
+     * @param  array<int, string>  $arguments
+     * @return array<int, string>
+     */
+    private function setEnvironmentVariables(array $arguments): array
+    {
+        $_ENV['LARAVEL_PARALLEL_TESTING'] = 1;
+
+        if ($this->hasArgument('--recreate-databases', $arguments)) {
+            $_ENV['LARAVEL_PARALLEL_TESTING_RECREATE_DATABASES'] = 1;
+        }
+
+        if ($this->hasArgument('--drop-databases', $arguments)) {
+            $_ENV['LARAVEL_PARALLEL_TESTING_DROP_DATABASES'] = 1;
+        }
+
+        $arguments = $this->popArgument('--recreate-databases', $arguments);
+
+        return $this->popArgument('--drop-databases', $arguments);
+    }
+
+    /**
+     * @param  array<int, string>  $arguments
+     * @return array<int, string>
+     */
+    private function useLaravelRunner(array $arguments): array
+    {
+        foreach ($arguments as $value) {
+            if (str_starts_with($value, '--runner')) {
+                $arguments = $this->popArgument($value, $arguments);
+            }
+        }
+
+        return $this->pushArgument('--runner=\Illuminate\Testing\ParallelRunner', $arguments);
+    }
+}

src/Plugins/Parallel/Handlers/Parallel.php

@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Parallel\Handlers;
+
+use Pest\Contracts\Plugins\HandlesArguments;
+use Pest\Plugins\Concerns\HandleArguments;
+use Pest\Plugins\Parallel\Paratest\WrapperRunner;
+
+/**
+ * @internal
+ */
+final class Parallel implements HandlesArguments
+{
+    use HandleArguments;
+
+    /**
+     * @var string[]
+     */
+    private const ARGS_TO_REMOVE = [
+        '--parallel',
+        '-p',
+        '--no-output',
+    ];
+
+    public function handleArguments(array $arguments): array
+    {
+        $args = array_reduce(self::ARGS_TO_REMOVE, fn ($args, $arg): array => $this->popArgument($arg, $args), $arguments);
+
+        return $this->pushArgument('--runner='.WrapperRunner::class, $args);
+    }
+}

src/Plugins/Parallel/Handlers/Pest.php

@@ -0,0 +1,35 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Parallel\Handlers;
+
+use Pest\Contracts\Plugins\HandlesArguments;
+use Pest\Plugins\Concerns\HandleArguments;
+use Pest\Plugins\Parallel\Contracts\HandlersWorkerArguments;
+use Pest\Plugins\Retry;
+
+final class Pest implements HandlesArguments, HandlersWorkerArguments
+{
+    use HandleArguments;
+
+    public function handleArguments(array $arguments): array
+    {
+        if (Retry::$retrying) {
+            $_ENV['PEST_RETRY'] = '1';
+        }
+
+        return $arguments;
+    }
+
+    public function handleWorkerArguments(array $arguments): array
+    {
+        $_SERVER['PEST_PARALLEL'] = '1';
+
+        if (isset($_SERVER['PEST_RETRY'])) {
+            Retry::$retrying = true;
+        }
+
+        return $arguments;
+    }
+}

src/Plugins/Parallel/Paratest/CleanConsoleOutput.php

@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Parallel\Paratest;
+
+use Symfony\Component\Console\Output\ConsoleOutput;
+
+final class CleanConsoleOutput extends ConsoleOutput
+{
+    /**
+     * {@inheritdoc}
+     */
+    protected function doWrite(string $message, bool $newline): void
+    {
+        if ($this->isOpeningHeadline($message)) {
+            return;
+        }
+
+        parent::doWrite($message, $newline);
+    }
+
+    /**
+     * Determines if the given message is the descriptive message
+     * that Paratest outputs when it starts.
+     */
+    private function isOpeningHeadline(string $message): bool
+    {
+        return str_contains($message, 'by Sebastian Bergmann and contributors.');
+    }
+}

src/Plugins/Parallel/Paratest/ResultPrinter.php

@@ -0,0 +1,206 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Parallel\Paratest;
+
+use function assert;
+use function fclose;
+use function feof;
+use function fopen;
+use function fread;
+use function fseek;
+use function ftell;
+use function fwrite;
+use ParaTest\Options;
+use Pest\Plugins\Parallel\Support\CompactPrinter;
+use Pest\Support\StateGenerator;
+use PHPUnit\TestRunner\TestResult\TestResult;
+use PHPUnit\TextUI\Output\Printer;
+use function preg_replace;
+use SebastianBergmann\Timer\Duration;
+use SplFileInfo;
+use function sprintf;
+use function strlen;
+use Symfony\Component\Console\Formatter\OutputFormatter;
+use Symfony\Component\Console\Output\OutputInterface;
+
+/** @internal */
+final class ResultPrinter
+{
+    public readonly Printer $printer;
+
+    private readonly CompactPrinter $compactPrinter;
+
+    private int $totalCases = 0;
+
+    /** @var resource|null */
+    private $teamcityLogFileHandle;
+
+    /** @var array<string, int> */
+    private array $tailPositions;
+
+    public function __construct(
+        private readonly OutputInterface $output,
+        private readonly Options $options
+    ) {
+        $this->printer = new class($this->output) implements Printer
+        {
+            public function __construct(
+                private readonly OutputInterface $output,
+            ) {
+            }
+
+            public function print(string $buffer): void
+            {
+                $this->output->write(OutputFormatter::escape($buffer));
+            }
+
+            public function flush(): void
+            {
+            }
+        };
+
+        $this->compactPrinter = new CompactPrinter();
+
+        if (! $this->options->configuration->hasLogfileTeamcity()) {
+            return;
+        }
+
+        $teamcityLogFileHandle = fopen($this->options->configuration->logfileTeamcity(), 'ab+');
+        assert($teamcityLogFileHandle !== false);
+        $this->teamcityLogFileHandle = $teamcityLogFileHandle;
+    }
+
+    public function setTestCount(int $testCount): void
+    {
+        $this->totalCases = $testCount;
+    }
+
+    public function start(): void
+    {
+        $this->compactPrinter->line(sprintf(
+            'Running %d test%s using %d process%s',
+            $this->totalCases,
+            $this->totalCases === 1 ? '' : 's',
+            $this->options->processes,
+            $this->options->processes === 1 ? '' : 'es')
+        );
+    }
+
+    /** @param  array<int, SplFileInfo>  $teamcityFiles */
+    public function printFeedback(SplFileInfo $progressFile, array $teamcityFiles): void
+    {
+        if ($this->options->needsTeamcity) {
+            $teamcityProgress = $this->tailMultiple($teamcityFiles);
+
+            if ($this->teamcityLogFileHandle !== null) {
+                fwrite($this->teamcityLogFileHandle, $teamcityProgress);
+            }
+        }
+
+        if ($this->options->configuration->outputIsTeamCity()) {
+            assert(isset($teamcityProgress));
+            $this->output->write($teamcityProgress);
+
+            return;
+        }
+
+        if ($this->options->configuration->noProgress()) {
+            return;
+        }
+
+        $feedbackItems = $this->tail($progressFile);
+        if ($feedbackItems === '') {
+            return;
+        }
+
+        $feedbackItems = (string) preg_replace('/ +\\d+ \\/ \\d+ \\( ?\\d+%\\)\\s*/', '', $feedbackItems);
+
+        $actualTestCount = strlen($feedbackItems);
+        for ($index = 0; $index < $actualTestCount; $index++) {
+            $this->printFeedbackItem($feedbackItems[$index]);
+        }
+    }
+
+    /**
+     * @param  array<int, SplFileInfo>  $teamcityFiles
+     * @param  array<int, SplFileInfo>  $testdoxFiles
+     */
+    public function printResults(TestResult $testResult, array $teamcityFiles, array $testdoxFiles, Duration $duration): void
+    {
+        if ($this->options->needsTeamcity) {
+            $teamcityProgress = $this->tailMultiple($teamcityFiles);
+
+            if ($this->teamcityLogFileHandle !== null) {
+                fwrite($this->teamcityLogFileHandle, $teamcityProgress);
+                $resource = $this->teamcityLogFileHandle;
+                $this->teamcityLogFileHandle = null;
+                fclose($resource);
+            }
+        }
+
+        if ($this->options->configuration->outputIsTeamCity()) {
+            assert(isset($teamcityProgress));
+            $this->output->write($teamcityProgress);
+
+            return;
+        }
+
+        if ($this->options->configuration->outputIsTestDox()) {
+            $this->output->write($this->tailMultiple($testdoxFiles));
+
+            return;
+        }
+
+        $this->compactPrinter->newLine();
+
+        $state = (new StateGenerator())->fromPhpUnitTestResult($testResult);
+
+        $this->compactPrinter->errors($state);
+        $this->compactPrinter->recap($state, $testResult, $duration);
+    }
+
+    private function printFeedbackItem(string $item): void
+    {
+        $this->compactPrinter->descriptionItem($item);
+    }
+
+    /** @param  array<int, SplFileInfo>  $files */
+    private function tailMultiple(array $files): string
+    {
+        $content = '';
+        foreach ($files as $file) {
+            if (! $file->isFile()) {
+                continue;
+            }
+
+            $content .= $this->tail($file);
+        }
+
+        return $content;
+    }
+
+    private function tail(SplFileInfo $file): string
+    {
+        $path = $file->getPathname();
+        $handle = fopen($path, 'r');
+        assert($handle !== false);
+        $fseek = fseek($handle, $this->tailPositions[$path] ?? 0);
+        assert($fseek === 0);
+
+        $contents = '';
+        while (! feof($handle)) {
+            $fread = fread($handle, 8192);
+            assert($fread !== false);
+            $contents .= $fread;
+        }
+
+        $ftell = ftell($handle);
+        assert($ftell !== false);
+        $this->tailPositions[$path] = $ftell;
+        fclose($handle);
+
+        return $contents;
+    }
+}

src/Plugins/Parallel/Paratest/WrapperRunner.php

@@ -0,0 +1,403 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Parallel\Paratest;
+
+use function array_merge;
+use function array_merge_recursive;
+use function array_shift;
+use function assert;
+use function count;
+use const DIRECTORY_SEPARATOR;
+use function dirname;
+use function file_get_contents;
+use function max;
+use ParaTest\Coverage\CoverageMerger;
+use ParaTest\JUnit\LogMerger;
+use ParaTest\JUnit\Writer;
+use ParaTest\Options;
+use ParaTest\RunnerInterface;
+use ParaTest\WrapperRunner\SuiteLoader;
+use ParaTest\WrapperRunner\WrapperWorker;
+use Pest\TestSuite;
+use PHPUnit\Event\Facade as EventFacade;
+use PHPUnit\Runner\CodeCoverage;
+use PHPUnit\TestRunner\TestResult\Facade as TestResultFacade;
+use PHPUnit\TestRunner\TestResult\TestResult;
+use PHPUnit\TextUI\Configuration\CodeCoverageFilterRegistry;
+use PHPUnit\TextUI\ShellExitCodeCalculator;
+use PHPUnit\Util\ExcludeList;
+use function realpath;
+use SebastianBergmann\Timer\Timer;
+use SplFileInfo;
+use Symfony\Component\Console\Output\OutputInterface;
+use Symfony\Component\Process\PhpExecutableFinder;
+use function unlink;
+use function unserialize;
+use function usleep;
+
+/**
+ * @internal
+ */
+final class WrapperRunner implements RunnerInterface
+{
+    private const CYCLE_SLEEP = 10000;
+
+    private readonly ResultPrinter $printer;
+
+    private readonly Timer $timer;
+
+    /** @var array<int, string> */
+    private array $pending = [];
+
+    private int $exitCode = -1;
+
+    /** @var array<int,WrapperWorker> */
+    private array $workers = [];
+
+    /** @var array<int,int> */
+    private array $batches = [];
+
+    /** @var array<int, SplFileInfo> */
+    private array $testresultFiles = [];
+
+    /** @var array<int, SplFileInfo> */
+    private array $coverageFiles = [];
+
+    /** @var array<int, SplFileInfo> */
+    private array $junitFiles = [];
+
+    /** @var array<int, SplFileInfo> */
+    private array $teamcityFiles = [];
+
+    /** @var array<int, SplFileInfo> */
+    private array $testdoxFiles = [];
+
+    /** @var array<int, string> */
+    private readonly array $parameters;
+
+    private readonly CodeCoverageFilterRegistry $codeCoverageFilterRegistry;
+
+    public function __construct(
+        private readonly Options $options,
+        private readonly OutputInterface $output
+    ) {
+        $this->printer = new ResultPrinter($output, $options);
+        $this->timer = new Timer();
+
+        $worker = realpath(
+            dirname(__DIR__, 4).DIRECTORY_SEPARATOR.'bin'.DIRECTORY_SEPARATOR.'worker.php',
+        );
+
+        assert($worker !== false);
+        $phpFinder = new PhpExecutableFinder();
+        $phpBin = $phpFinder->find(false);
+        assert($phpBin !== false);
+        $parameters = [$phpBin];
+        $parameters = array_merge($parameters, $phpFinder->findArguments());
+
+        if ($options->passthruPhp !== null) {
+            $parameters = array_merge($parameters, $options->passthruPhp);
+        }
+
+        $parameters[] = $worker;
+
+        $this->parameters = $parameters;
+        $this->codeCoverageFilterRegistry = new CodeCoverageFilterRegistry();
+    }
+
+    public function run(): int
+    {
+        $directory = dirname(__DIR__);
+        assert(strlen($directory) > 0);
+        ExcludeList::addDirectory($directory);
+
+        TestResultFacade::init();
+        EventFacade::seal();
+
+        $suiteLoader = new SuiteLoader($this->options, $this->output, $this->codeCoverageFilterRegistry);
+        $this->pending = $this->getTestFiles($suiteLoader);
+
+        $result = TestResultFacade::result();
+
+        $this->printer->setTestCount($suiteLoader->testCount);
+        $this->printer->start();
+
+        $this->timer->start();
+
+        $this->startWorkers();
+        $this->assignAllPendingTests();
+        $this->waitForAllToFinish();
+
+        return $this->complete($result);
+    }
+
+    private function startWorkers(): void
+    {
+        for ($token = 1; $token <= $this->options->processes; $token++) {
+            $this->startWorker($token);
+        }
+    }
+
+    private function assignAllPendingTests(): void
+    {
+        $batchSize = $this->options->maxBatchSize;
+
+        while ($this->pending !== [] && $this->workers !== []) {
+            foreach ($this->workers as $token => $worker) {
+                if (! $worker->isRunning()) {
+                    throw $worker->getWorkerCrashedException();
+                }
+
+                if (! $worker->isFree()) {
+                    continue;
+                }
+
+                $this->flushWorker($worker);
+
+                if ($batchSize !== 0 && $this->batches[$token] === $batchSize) {
+                    $this->destroyWorker($token);
+                    $worker = $this->startWorker($token);
+                }
+
+                if (
+                    $this->exitCode > 0
+                    && $this->options->configuration->stopOnFailure()
+                ) {
+                    $this->pending = [];
+                } elseif (($pending = array_shift($this->pending)) !== null) {
+                    $this->debug(sprintf('Assigning %s to worker %d', $pending, $token));
+
+                    $worker->assign($pending);
+                    $this->batches[$token]++;
+                }
+            }
+
+            usleep(self::CYCLE_SLEEP);
+        }
+    }
+
+    private function flushWorker(WrapperWorker $worker): void
+    {
+        $this->exitCode = max($this->exitCode, $worker->getExitCode());
+        $this->printer->printFeedback(
+            $worker->progressFile,
+            $this->teamcityFiles,
+        );
+        $worker->reset();
+    }
+
+    private function waitForAllToFinish(): void
+    {
+        $stopped = [];
+        while ($this->workers !== []) {
+            foreach ($this->workers as $index => $worker) {
+                if ($worker->isRunning()) {
+                    if (! array_key_exists($index, $stopped) && $worker->isFree()) {
+                        $worker->stop();
+                        $stopped[$index] = true;
+                    }
+
+                    continue;
+                }
+
+                if (! $worker->isFree()) {
+                    throw $worker->getWorkerCrashedException();
+                }
+
+                $this->flushWorker($worker);
+                unset($this->workers[$index]);
+            }
+
+            usleep(self::CYCLE_SLEEP);
+        }
+    }
+
+    private function startWorker(int $token): WrapperWorker
+    {
+        /** @var array<non-empty-string> $parameters */
+        $parameters = $this->parameters;
+
+        $worker = new WrapperWorker(
+            $this->output,
+            $this->options,
+            $parameters,
+            $token,
+        );
+
+        $worker->start();
+
+        $this->batches[$token] = 0;
+
+        $this->testresultFiles[] = $worker->testresultFile;
+
+        if (isset($worker->junitFile)) {
+            $this->junitFiles[] = $worker->junitFile;
+        }
+
+        if (isset($worker->coverageFile)) {
+            $this->coverageFiles[] = $worker->coverageFile;
+        }
+
+        if (isset($worker->teamcityFile)) {
+            $this->teamcityFiles[] = $worker->teamcityFile;
+        }
+
+        if (isset($worker->testdoxFile)) {
+            $this->testdoxFiles[] = $worker->testdoxFile;
+        }
+
+        return $this->workers[$token] = $worker;
+    }
+
+    private function destroyWorker(int $token): void
+    {
+        // Mutation Testing tells us that the following `unset()` already destroys
+        // the `WrapperWorker`, which destroys the Symfony's `Process`, which
+        // automatically calls `Process::stop` within `Process::__destruct()`.
+        // But we prefer to have an explicit stops.
+        $this->workers[$token]->stop();
+
+        unset($this->workers[$token]);
+    }
+
+    private function complete(TestResult $testResultSum): int
+    {
+        foreach ($this->testresultFiles as $testresultFile) {
+            if (! $testresultFile->isFile()) {
+                continue;
+            }
+
+            $contents = file_get_contents($testresultFile->getPathname());
+            assert($contents !== false);
+            $testResult = unserialize($contents);
+            assert($testResult instanceof TestResult);
+
+            $testResultSum = new TestResult(
+                $testResultSum->numberOfTests() + $testResult->numberOfTests(),
+                $testResultSum->numberOfTestsRun() + $testResult->numberOfTestsRun(),
+                $testResultSum->numberOfAssertions() + $testResult->numberOfAssertions(),
+                array_merge_recursive($testResultSum->testErroredEvents(), $testResult->testErroredEvents()),
+                array_merge_recursive($testResultSum->testFailedEvents(), $testResult->testFailedEvents()),
+                array_merge_recursive($testResultSum->testConsideredRiskyEvents(), $testResult->testConsideredRiskyEvents()),
+                array_merge_recursive($testResultSum->testSuiteSkippedEvents(), $testResult->testSuiteSkippedEvents()),
+                array_merge_recursive($testResultSum->testSkippedEvents(), $testResult->testSkippedEvents()),
+                array_merge_recursive($testResultSum->testMarkedIncompleteEvents(), $testResult->testMarkedIncompleteEvents()),
+                array_merge_recursive($testResultSum->testTriggeredDeprecationEvents(), $testResult->testTriggeredDeprecationEvents()),
+                array_merge_recursive($testResultSum->testTriggeredPhpDeprecationEvents(), $testResult->testTriggeredPhpDeprecationEvents()),
+                array_merge_recursive($testResultSum->testTriggeredPhpunitDeprecationEvents(), $testResult->testTriggeredPhpunitDeprecationEvents()),
+                array_merge_recursive($testResultSum->testTriggeredErrorEvents(), $testResult->testTriggeredErrorEvents()),
+                array_merge_recursive($testResultSum->testTriggeredNoticeEvents(), $testResult->testTriggeredNoticeEvents()),
+                array_merge_recursive($testResultSum->testTriggeredPhpNoticeEvents(), $testResult->testTriggeredPhpNoticeEvents()),
+                array_merge_recursive($testResultSum->testTriggeredWarningEvents(), $testResult->testTriggeredWarningEvents()),
+                array_merge_recursive($testResultSum->testTriggeredPhpWarningEvents(), $testResult->testTriggeredPhpWarningEvents()),
+                array_merge_recursive($testResultSum->testTriggeredPhpunitErrorEvents(), $testResult->testTriggeredPhpunitErrorEvents()),
+                array_merge_recursive($testResultSum->testTriggeredPhpunitWarningEvents(), $testResult->testTriggeredPhpunitWarningEvents()),
+                array_merge_recursive($testResultSum->testRunnerTriggeredDeprecationEvents(), $testResult->testRunnerTriggeredDeprecationEvents()),
+                array_merge_recursive($testResultSum->testRunnerTriggeredWarningEvents(), $testResult->testRunnerTriggeredWarningEvents()),
+            );
+        }
+
+        $this->printer->printResults(
+            $testResultSum,
+            $this->teamcityFiles,
+            $this->testdoxFiles,
+            $this->timer->stop(),
+        );
+        $this->generateCodeCoverageReports();
+        $this->generateLogs();
+
+        $exitcode = (new ShellExitCodeCalculator())->calculate(
+            $this->options->configuration->failOnEmptyTestSuite(),
+            $this->options->configuration->failOnRisky(),
+            $this->options->configuration->failOnWarning(),
+            $this->options->configuration->failOnIncomplete(),
+            $this->options->configuration->failOnSkipped(),
+            $testResultSum,
+        );
+
+        $this->clearFiles($this->testresultFiles);
+        $this->clearFiles($this->coverageFiles);
+        $this->clearFiles($this->junitFiles);
+        $this->clearFiles($this->teamcityFiles);
+        $this->clearFiles($this->testdoxFiles);
+
+        return $exitcode;
+    }
+
+    private function generateCodeCoverageReports(): void
+    {
+        if ($this->coverageFiles === []) {
+            return;
+        }
+
+        $coverageManager = new CodeCoverage();
+        $coverageManager->init($this->options->configuration, $this->codeCoverageFilterRegistry);
+        $coverageMerger = new CoverageMerger($coverageManager->codeCoverage());
+        foreach ($this->coverageFiles as $coverageFile) {
+            $coverageMerger->addCoverageFromFile($coverageFile);
+        }
+
+        $coverageManager->generateReports(
+            $this->printer->printer,
+            $this->options->configuration,
+        );
+    }
+
+    private function generateLogs(): void
+    {
+        if ($this->junitFiles === []) {
+            return;
+        }
+
+        $testSuite = (new LogMerger())->merge($this->junitFiles);
+        (new Writer())->write(
+            $testSuite,
+            $this->options->configuration->logfileJunit(),
+        );
+    }
+
+    /** @param  array<int, SplFileInfo>  $files */
+    private function clearFiles(array $files): void
+    {
+        foreach ($files as $file) {
+            if (! $file->isFile()) {
+                continue;
+            }
+
+            unlink($file->getPathname());
+        }
+    }
+
+    /**
+     * Returns the test files to be executed.
+     *
+     * @return array<int, string>
+     */
+    private function getTestFiles(SuiteLoader $suiteLoader): array
+    {
+        $this->debug(sprintf('Found %d test file%s', count($suiteLoader->files), count($suiteLoader->files) === 1 ? '' : 's'));
+
+        /** @var array<string, string> $files */
+        $files = $suiteLoader->files;
+
+        return [
+            ...array_values(array_filter(
+                $files,
+                fn (string $filename): bool => ! str_ends_with($filename, "eval()'d code")
+            )),
+            ...TestSuite::getInstance()->tests->getFilenames(),
+        ];
+    }
+
+    /**
+     * Prints a debug message.
+     */
+    private function debug(string $message): void
+    {
+        if ($this->options->verbose) {
+            $this->output->writeln("  <fg=blue>{$message}</>  ");
+        }
+    }
+}

src/Plugins/Parallel/Support/CompactPrinter.php

@@ -0,0 +1,131 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Parallel\Support;
+
+use NunoMaduro\Collision\Adapters\Phpunit\State;
+use NunoMaduro\Collision\Adapters\Phpunit\Style;
+use PHPUnit\Event\Telemetry\HRTime;
+use PHPUnit\Event\Telemetry\Info;
+use PHPUnit\Event\Telemetry\MemoryUsage;
+use PHPUnit\Event\Telemetry\Snapshot;
+use PHPUnit\TestRunner\TestResult\TestResult as PHPUnitTestResult;
+use SebastianBergmann\Timer\Duration;
+use Symfony\Component\Console\Output\ConsoleOutput;
+use Symfony\Component\Console\Output\ConsoleOutputInterface;
+use function Termwind\render;
+use Termwind\Terminal;
+use function Termwind\terminal;
+
+/**
+ * @internal
+ */
+final class CompactPrinter
+{
+    private readonly Terminal $terminal;
+
+    private readonly ConsoleOutputInterface $output;
+
+    private readonly Style $style;
+
+    private int $compactProcessed = 0;
+
+    private readonly int $compactSymbolsPerLine;
+
+    /**
+     * @var array<string, array<int, string>>
+     */
+    private const LOOKUP_TABLE = [
+        '.' => ['gray', '.'],
+        'S' => ['yellow', 's'],
+        'I' => ['yellow', 'i'],
+        'N' => ['yellow', 'i'],
+        'R' => ['yellow', '!'],
+        'W' => ['yellow', '!'],
+        'E' => ['red', '⨯'],
+        'F' => ['red', '⨯'],
+    ];
+
+    public function __construct()
+    {
+        $this->terminal = terminal();
+        $this->output = new ConsoleOutput(decorated: true);
+        $this->style = new Style($this->output);
+
+        $this->compactSymbolsPerLine = $this->terminal->width() - 4;
+    }
+
+    /**
+     * Output an empty line in the console. Useful for providing a little breathing room.
+     */
+    public function newLine(): void
+    {
+        render('<div class="py-1"></div>');
+    }
+
+    /**
+     * Write the given message to the console, adding vertical and horizontal padding.
+     */
+    public function line(string $message): void
+    {
+        render("<span class='mx-2 py-1 text-gray-700'>{$message}</span>");
+    }
+
+    /**
+     * Outputs the given description item from the ProgressPrinter as a gorgeous, colored symbol.
+     */
+    public function descriptionItem(string $item): void
+    {
+        [$color, $icon] = self::LOOKUP_TABLE[$item] ?? self::LOOKUP_TABLE['.'];
+
+        $symbolsOnCurrentLine = $this->compactProcessed % $this->compactSymbolsPerLine;
+
+        if ($symbolsOnCurrentLine >= $this->terminal->width() - 4) {
+            $symbolsOnCurrentLine = 0;
+        }
+
+        if ($symbolsOnCurrentLine === 0) {
+            $this->output->writeln('');
+            $this->output->write('  ');
+        }
+
+        $this->output->write(sprintf('<fg=%s;options=bold>%s</>', $color, $icon));
+
+        $this->compactProcessed++;
+    }
+
+    /**
+     * Outputs all errors from the given state using Collision's beautiful error output.
+     */
+    public function errors(State $state): void
+    {
+        $this->style->writeErrorsSummary($state, false);
+    }
+
+    /**
+     * Outputs a clean recap of the test run, including the number of tests, assertions, and failures.
+     */
+    public function recap(State $state, PHPUnitTestResult $testResult, Duration $duration): void
+    {
+        assert($this->output instanceof ConsoleOutput);
+
+        $nanoseconds = $duration->asNanoseconds() % 1_000_000_000;
+        $snapshotDuration = HRTime::fromSecondsAndNanoseconds((int) $duration->asSeconds(), $nanoseconds);
+        $telemetryDuration = \PHPUnit\Event\Telemetry\Duration::fromSecondsAndNanoseconds((int) $duration->asSeconds(), $nanoseconds);
+
+        $telemetry = new Info(
+            new Snapshot(
+                $snapshotDuration,
+                MemoryUsage::fromBytes(0),
+                MemoryUsage::fromBytes(0),
+            ),
+            $telemetryDuration,
+            MemoryUsage::fromBytes(0),
+            \PHPUnit\Event\Telemetry\Duration::fromSecondsAndNanoseconds(0, 0),
+            MemoryUsage::fromBytes(0),
+        );
+
+        $this->style->writeRecap($state, $telemetry, $testResult);
+    }
+}

src/Repositories/TestRepository.php

@@ -125,6 +125,12 @@ final class TestRepository
      */
     public function set(TestCaseMethodFactory $method): void
     {
+        foreach ($this->testCaseFilters as $filter) {
+            if (! $filter->accept($method->filename)) {
+                return;
+            }
+        }
+
         foreach ($this->testCaseMethodFilters as $filter) {
             if (! $filter->accept($method)) {
                 return;
@@ -147,15 +153,13 @@ final class TestRepository
             return;
         }
 
-        $accepted = array_reduce(
+        foreach ($this->testCaseFilters as $filter) {
-            $this->testCaseFilters,
+            if (! $filter->accept($filename)) {
-            fn (bool $carry, TestCaseFilter $filter): bool => $carry && $filter->accept($filename),
+                return;
-            true,
+            }
-        );
-
-        if ($accepted) {
-            $this->make($this->testCases[$filename]);
         }
+
+        $this->make($this->testCases[$filename]);
     }
 
     /**

src/Subscribers/EnsureTeamCityEnabled.php

@@ -21,8 +21,8 @@ final class EnsureTeamCityEnabled implements ConfiguredSubscriber
      * Creates a new Configured Subscriber instance.
      */
     public function __construct(
-        private readonly OutputInterface $output,
         private readonly InputInterface $input,
+        private readonly OutputInterface $output,
         private readonly TestSuite $testSuite,
     ) {
     }

src/Support/Container.php

@@ -47,10 +47,14 @@ final class Container
 
     /**
      * Adds the given instance to the container.
+     *
+     * @return $this
      */
-    public function add(string $id, object|string $instance): void
+    public function add(string $id, object|string $instance): self
     {
         $this->instances[$id] = $instance;
+
+        return $this;
     }
 
     /**

src/Support/StateGenerator.php

@@ -0,0 +1,105 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Support;
+
+use NunoMaduro\Collision\Adapters\Phpunit\State;
+use NunoMaduro\Collision\Adapters\Phpunit\TestResult;
+use PHPUnit\Event\Code\TestDox;
+use PHPUnit\Event\Code\TestMethod;
+use PHPUnit\Event\Code\Throwable;
+use PHPUnit\Event\Test\Errored;
+use PHPUnit\Event\TestData\TestDataCollection;
+use PHPUnit\Framework\IncompleteTestError;
+use PHPUnit\Framework\SkippedWithMessageException;
+use PHPUnit\Metadata\MetadataCollection;
+use PHPUnit\TestRunner\TestResult\TestResult as PHPUnitTestResult;
+
+final class StateGenerator
+{
+    public function fromPhpUnitTestResult(PHPUnitTestResult $testResult): State
+    {
+        $state = new State();
+
+        foreach ($testResult->testErroredEvents() as $testResultEvent) {
+            if ($testResultEvent instanceof Errored) {
+                $state->add(TestResult::fromTestCase(
+                    $testResultEvent->test(),
+                    TestResult::FAIL,
+                    $testResultEvent->throwable()
+                ));
+            } else {
+                $state->add(TestResult::fromBeforeFirstTestMethodErrored($testResultEvent));
+            }
+        }
+
+        foreach ($testResult->testFailedEvents() as $testResultEvent) {
+            $state->add(TestResult::fromTestCase(
+                $testResultEvent->test(),
+                TestResult::FAIL,
+                $testResultEvent->throwable()
+            ));
+        }
+
+        foreach ($testResult->testMarkedIncompleteEvents() as $testResultEvent) {
+            $state->add(TestResult::fromTestCase(
+                $testResultEvent->test(),
+                TestResult::INCOMPLETE,
+                $testResultEvent->throwable()
+            ));
+        }
+
+        foreach ($testResult->testConsideredRiskyEvents() as $riskyEvents) {
+            foreach ($riskyEvents as $riskyEvent) {
+                $state->add(TestResult::fromTestCase(
+                    $riskyEvent->test(),
+                    TestResult::RISKY,
+                    Throwable::from(new IncompleteTestError($riskyEvent->message()))
+                ));
+            }
+        }
+
+        foreach ($testResult->testSkippedEvents() as $testResultEvent) {
+            if ($testResultEvent->message() === '__TODO__') {
+                $state->add(TestResult::fromTestCase($testResultEvent->test(), TestResult::TODO));
+
+                continue;
+            }
+
+            $state->add(TestResult::fromTestCase(
+                $testResultEvent->test(),
+                TestResult::SKIPPED,
+                Throwable::from(new SkippedWithMessageException($testResultEvent->message()))
+            ));
+        }
+
+        $numberOfPassedTests = $testResult->numberOfTestsRun()
+            - $testResult->numberOfTestErroredEvents()
+            - $testResult->numberOfTestFailedEvents()
+            - $testResult->numberOfTestSkippedEvents()
+            - $testResult->numberOfTestsWithTestConsideredRiskyEvents()
+            - $testResult->numberOfTestMarkedIncompleteEvents();
+
+        for ($i = 0; $i < $numberOfPassedTests; $i++) {
+            $state->add(TestResult::fromTestCase(
+
+                new TestMethod(
+                    /** @phpstan-ignore-next-line */
+                    "$i",
+                    /** @phpstan-ignore-next-line */
+                    '',
+                    '',
+                    1,
+                    /** @phpstan-ignore-next-line */
+                    TestDox::fromClassNameAndMethodName('', ''),
+                    MetadataCollection::fromArray([]),
+                    TestDataCollection::fromArray([])
+                ),
+                TestResult::PASS
+            ));
+        }
+
+        return $state;
+    }
+}

tests/.snapshots/Failure.php.inc

@@ -1,24 +0,0 @@
-##teamcity[testSuiteStarted name='Tests/tests/Failure' locationHint='file://tests/.tests/Failure.php' flowId='1234']
-##teamcity[testStarted name='it can fail with comparison' locationHint='pest_qn://tests/.tests/Failure.php::it can fail with comparison' flowId='1234']
-##teamcity[testFailed name='it can fail with comparison' message='Failed asserting that true matches expected false.' details='at src/Mixins/Expectation.php:342|nat src/Support/ExpectationPipeline.php:75|nat src/Support/ExpectationPipeline.php:79|nat src/Expectation.php:300|nat tests/.tests/Failure.php:6|nat src/Factories/TestCaseMethodFactory.php:105|nat src/Concerns/Testable.php:262|nat src/Support/ExceptionTrace.php:28|nat src/Concerns/Testable.php:262|nat src/Concerns/Testable.php:217|nat src/Kernel.php:79' type='comparisonFailure' actual='true' expected='false' flowId='1234']
-##teamcity[testFinished name='it can fail with comparison' duration='100000' flowId='1234']
-##teamcity[testStarted name='it can be ignored because of no assertions' locationHint='pest_qn://tests/.tests/Failure.php::it can be ignored because of no assertions' flowId='1234']
-##teamcity[testIgnored name='it can be ignored because of no assertions' message='This test did not perform any assertions' details='' flowId='1234']
-##teamcity[testFinished name='it can be ignored because of no assertions' duration='100000' flowId='1234']
-##teamcity[testStarted name='it can be ignored because it is skipped' locationHint='pest_qn://tests/.tests/Failure.php::it can be ignored because it is skipped' flowId='1234']
-##teamcity[testIgnored name='it can be ignored because it is skipped' message='This test was ignored.' details='' flowId='1234']
-##teamcity[testFinished name='it can be ignored because it is skipped' duration='100000' flowId='1234']
-##teamcity[testStarted name='it can fail' locationHint='pest_qn://tests/.tests/Failure.php::it can fail' flowId='1234']
-##teamcity[testFailed name='it can fail' message='oh noo' details='at tests/.tests/Failure.php:18|nat src/Factories/TestCaseMethodFactory.php:105|nat src/Concerns/Testable.php:262|nat src/Support/ExceptionTrace.php:28|nat src/Concerns/Testable.php:262|nat src/Concerns/Testable.php:217|nat src/Kernel.php:79' flowId='1234']
-##teamcity[testFinished name='it can fail' duration='100000' flowId='1234']
-##teamcity[testStarted name='it is not done yet' locationHint='pest_qn://tests/.tests/Failure.php::it is not done yet' flowId='1234']
-##teamcity[testIgnored name='it is not done yet' message='This test was ignored.' details='' flowId='1234']
-##teamcity[testFinished name='it is not done yet' duration='100000' flowId='1234']
-##teamcity[testStarted name='build this one.' locationHint='pest_qn://tests/.tests/Failure.php::build this one.' flowId='1234']
-##teamcity[testIgnored name='build this one.' message='This test was ignored.' details='' flowId='1234']
-##teamcity[testFinished name='build this one.' duration='100000' flowId='1234']
-##teamcity[testSuiteFinished name='Tests/tests/Failure' flowId='1234']
-
-  Tests:    2 failed, 1 risky, 2 todos, 1 skipped (2 assertions)
-  Duration: 1.00s
-

tests/.snapshots/success.txt

@@ -896,6 +896,9 @@
    PASS  Tests\Visual\Help
   ✓ visual snapshot of help command output
 
+   PASS  Tests\Visual\Parallel
+  ✓ parallel
+
    PASS  Tests\Visual\SingleTestOrDirectory
   ✓ allows to run a single test
   ✓ allows to run a directory
@@ -914,4 +917,4 @@
    PASS  Tests\Visual\Version
   ✓ visual snapshot of help command output
 
-  Tests:    4 incomplete, 4 todos, 18 skipped, 633 passed (1552 assertions)
+  Tests:    4 incomplete, 4 todos, 18 skipped, 634 passed (1554 assertions)

tests/Hooks/BeforeAllTest.php

@@ -1,11 +1,12 @@
 <?php
 
+use Pest\Plugins\Parallel;
 use Pest\Support\Str;
 
 // HACK: we have to determine our $_SERVER['globalHook-]>calls baseline. This is because
 // two other tests are executed before this one due to filename ordering.
 $args = $_SERVER['argv'] ?? [];
-$single = (isset($args[1]) && Str::endsWith(__FILE__, $args[1])) || ($_SERVER['PEST_PARALLEL'] ?? false);
+$single = (isset($args[1]) && Str::endsWith(__FILE__, $args[1])) || Parallel::isInParallelProcess();
 $offset = $single ? 0 : 2;
 
 uses()->beforeAll(function () use ($offset) {

tests/Visual/Parallel.php

@@ -0,0 +1,18 @@
+<?php
+
+use Symfony\Component\Process\Process;
+
+$run = function () {
+    $process = new Process(['php', 'bin/pest', '--parallel', '--processes=3', '--exclude-group=integration'], dirname(__DIR__, 2),
+        ['COLLISION_PRINTER' => 'DefaultPrinter', 'COLLISION_IGNORE_DURATION' => 'true'],
+    );
+
+    $process->run();
+
+    return preg_replace('#\\x1b[[][^A-Za-z]*[A-Za-z]#', '', $process->getOutput());
+};
+
+test('parallel', function () use ($run) {
+    expect($run())->toContain('Running 650 tests using 3 processes')
+        ->toContain('Tests:    4 incomplete, 4 todos, 15 skipped, 627 passed (1546 assertions)');
+});