e(strict_types=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\TestRunner;

use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversClass(ExecutionStarted::class)]
#[Small]
#[Group('event-sy

ite     = $this->testSuiteValueObject();

        $event = new ExecutionStarted($telemetryInfo, $testSuite);

        $this->assertSame($telemetryInfo, $event->telemetryInfo());
        $this->assertSame($testSuite, $event->testSuite());
    }

    public

stem')]
#[Group('event-system/events')]
final class ExecutionStartedTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $telemetryInfo = $this->telemetryInfo();
        $testSu


e(strict_types=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\TestRunner;

use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversClass(ExtensionBootstrapped::class)]
#[Small]
#[Group('eve

   $className     = 'the-className';
        $parameters    = ['foo' => 'bar'];

        $event = new ExtensionBootstrapped(
            $telemetryInfo,
            $className,
            $parameters,
        );

        $this->assertSame($telemetryInfo,

nt-system')]
#[Group('event-system/events')]
final class ExtensionBootstrappedTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $telemetryInfo = $this->telemetryInfo();


s=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\TestRunner;

use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversClass(ExtensionLoadedFromPhar::class)]
#[Small]
#[Group('event-system')

ame      = 'extension.phar';
        $name          = 'example-extension';
        $version       = '1.2.3';

        $event = new ExtensionLoadedFromPhar(
            $telemetryInfo,
            $filename,
            $name,
            $version,

]
#[Group('event-system/events')]
final class ExtensionLoadedFromPharTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $telemetryInfo = $this->telemetryInfo();
        $filen


?php declare(strict_types=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\TestRunner;

use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversClass(Finished::class)]
#[Small]
#[Group('event

w Finished($telemetryInfo);

        $this->assertSame($telemetryInfo, $event->telemetryInfo());
    }

    public function testCanBeRepresentedAsString(): void
    {
        $event = new Finished($this->telemetryInfo());

        $this->assertSame('Test R

-system')]
#[Group('event-system/events')]
final class FinishedTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $telemetryInfo = $this->telemetryInfo();

        $event = ne


declare(strict_types=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\TestRunner;

use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversClass(GarbageCollectionDisabled::class)]
#[Small]
#[

yInfo();

        $event = new GarbageCollectionDisabled($telemetryInfo);

        $this->assertSame($telemetryInfo, $event->telemetryInfo());
    }

    public function testCanBeRepresentedAsString(): void
    {
        $event = new GarbageCollectionDisab

Group('event-system')]
#[Group('event-system/events')]
final class GarbageCollectionDisabledTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $telemetryInfo = $this->telemetr


declare(strict_types=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\TestRunner;

use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversClass(GarbageCollectionEnabled::class)]
#[Small]
#[G

nfo();

        $event = new GarbageCollectionEnabled($telemetryInfo);

        $this->assertSame($telemetryInfo, $event->telemetryInfo());
    }

    public function testCanBeRepresentedAsString(): void
    {
        $event = new GarbageCollectionEnabled(

roup('event-system')]
#[Group('event-system/events')]
final class GarbageCollectionEnabledTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $telemetryInfo = $this->telemetryI


declare(strict_types=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\TestRunner;

use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversClass(GarbageCollectionTriggered::class)]
#[Small]
#

tryInfo();

        $event = new GarbageCollectionTriggered($telemetryInfo);

        $this->assertSame($telemetryInfo, $event->telemetryInfo());
    }

    public function testCanBeRepresentedAsString(): void
    {
        $event = new GarbageCollectionTr

[Group('event-system')]
#[Group('event-system/events')]
final class GarbageCollectionTriggeredTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $telemetryInfo = $this->teleme


e(strict_types=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\TestRunner;

use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversClass(NoticeTriggered::class)]
#[Small]
#[Group('event-sys

      = 'message';

        $event = new NoticeTriggered(
            $telemetryInfo,
            $message,
        );

        $this->assertSame($telemetryInfo, $event->telemetryInfo());
        $this->assertSame($message, $event->message());
    }

    p

tem')]
#[Group('event-system/events')]
final class NoticeTriggeredTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $telemetryInfo = $this->telemetryInfo();
        $message


?php declare(strict_types=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\TestRunner;

use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversClass(Started::class)]
#[Small]
#[Group('event-

Started($telemetryInfo);

        $this->assertSame($telemetryInfo, $event->telemetryInfo());
    }

    public function testCanBeRepresentedAsString(): void
    {
        $event = new Started($this->telemetryInfo());

        $this->assertSame('Test Runne

system')]
#[Group('event-system/events')]
final class StartedTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $telemetryInfo = $this->telemetryInfo();

        $event = new


s=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\TestRunner;

use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversClass(StaticAnalysisForCodeCoverageFinished::class)]
#[Small]
#[Group('

emetryInfo();
        $cacheHits     = 1;
        $cacheMisses   = 2;

        $event = new StaticAnalysisForCodeCoverageFinished(
            $telemetryInfo,
            $cacheHits,
            $cacheMisses,
        );

        $this->assertSame($telemetr

event-system')]
#[Group('event-system/events')]
final class StaticAnalysisForCodeCoverageFinishedTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $telemetryInfo = $this->tel


declare(strict_types=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\TestRunner;

use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversClass(StaticAnalysisForCodeCoverageStarted::class)]

Info = $this->telemetryInfo();

        $event = new StaticAnalysisForCodeCoverageStarted(
            $telemetryInfo,
        );

        $this->assertSame($telemetryInfo, $event->telemetryInfo());
    }

    public function testCanBeRepresentedAsString()

#[Small]
#[Group('event-system')]
#[Group('event-system/events')]
final class StaticAnalysisForCodeCoverageStartedTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $telemetry


e(strict_types=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\TestRunner;

use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversClass(WarningTriggered::class)]
#[Small]
#[Group('event-sy

e       = 'message';

        $event = new WarningTriggered(
            $telemetryInfo,
            $message,
        );

        $this->assertSame($telemetryInfo, $event->telemetryInfo());
        $this->assertSame($message, $event->message());
    }

stem')]
#[Group('event-system/events')]
final class WarningTriggeredTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $telemetryInfo = $this->telemetryInfo();
        $messag


art of PHPUnit.
 *
 * (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 PHPUnit\Event\TestRunner\Issue;

use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Event\Code\IssueTrigger\IssueTrigger;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversClass(DeprecationTriggered::class)]
#[Sma

emetryInfo();
        $message           = 'message';
        $file              = 'file';
        $line              = 1;
        $suppressed        = false;
        $ignoredByBaseline = false;
        $trigger           = IssueTrigger::from(null, null);

ll]
#[Group('event-system')]
#[Group('event-system/events')]
final class DeprecationTriggeredTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $telemetryInfo     = $this->tel


s=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\TestRunner\Issue;

use const PHP_EOL;
use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Event\TestRunner\ErrorTriggered;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversC

lemetryInfo = $this->telemetryInfo();
        $message       = 'message';
        $file          = 'file';
        $line          = 1;
        $suppressed    = false;

        $event = new ErrorTriggered(
            $telemetryInfo,
            $message,

lass(ErrorTriggered::class)]
#[Small]
#[Group('event-system')]
#[Group('event-system/events')]
final class ErrorTriggeredTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $te


art of PHPUnit.
 *
 * (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 PHPUnit\Event\TestRunner\Issue;

use const PHP_EOL;
use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversClass(NoticeTriggered::class)]
#[Small]
#[Group('event-system')]
#[Group

= 'message';
        $file              = 'file';
        $line              = 1;
        $suppressed        = false;
        $ignoredByBaseline = false;

        $event = new NoticeTriggered(
            $telemetryInfo,
            $message,
            $

('event-system/events')]
final class NoticeTriggeredTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $telemetryInfo     = $this->telemetryInfo();
        $message


art of PHPUnit.
 *
 * (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 PHPUnit\Event\TestRunner\Issue;

use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Event\Code\IssueTrigger\IssueTrigger;
use PHPUnit\Event\TestRunner\PhpDeprecationTriggered;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Sma

Values(): void
    {
        $telemetryInfo     = $this->telemetryInfo();
        $message           = 'message';
        $file              = 'file';
        $line              = 1;
        $suppressed        = false;
        $ignoredByBaseline = false;

ll;

#[CoversClass(PhpDeprecationTriggered::class)]
#[Small]
#[Group('event-system')]
#[Group('event-system/events')]
final class PhpDeprecationTriggeredTest extends AbstractEventTestCase
{
    public function testConstructorSets


art of PHPUnit.
 *
 * (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 PHPUnit\Event\TestRunner\Issue;

use const PHP_EOL;
use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Event\TestRunner\PhpNoticeTriggered;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversClass(PhpNoticeTriggere

  = $this->telemetryInfo();
        $message           = 'message';
        $file              = 'file';
        $line              = 1;
        $suppressed        = false;
        $ignoredByBaseline = false;

        $event = new PhpNoticeTriggered(

d::class)]
#[Small]
#[Group('event-system')]
#[Group('event-system/events')]
final class PhpNoticeTriggeredTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $telemetryInfo


art of PHPUnit.
 *
 * (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 PHPUnit\Event\TestRunner\Issue;

use const PHP_EOL;
use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Event\TestRunner\PhpWarningTriggered;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversClass(PhpWarningTrigge

     = $this->telemetryInfo();
        $message           = 'message';
        $file              = 'file';
        $line              = 1;
        $suppressed        = false;
        $ignoredByBaseline = false;

        $event = new PhpWarningTriggered(

red::class)]
#[Small]
#[Group('event-system')]
#[Group('event-system/events')]
final class PhpWarningTriggeredTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $telemetryInfo


 that was distributed with this source code.
 */
namespace PHPUnit\Event\Code;

use Exception;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;
use PHPUnit\Framework\Attributes\TestDox;
use PHPUnit\Framework\ExpectationFailedException;
use PHPUnit\Framework\TestCase;
use SebastianBergmann\Comparator\ComparisonFailure;
use stdClass;

#[CoversClass(ComparisonFailureBuilder::class)]
#[Sma

*/
    public static function provider(): array
    {
        return [
            'type of expected value: string, string representation of expected value: not available, type of actual value: string, string representation of actual value: not available'

ll]
#[Group('event-system')]
#[Group('event-system/value-objects')]
final class ComparisonFailureBuilderTest extends TestCase
{
    /**
     * @return array<string, array{string, string, string, ExpectationFailedException}>


art of PHPUnit.
 *
 * (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 PHPUnit\Event\TestSuite;

use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;
use PHPUnit\Framework\TestCase;
use PHPUnit\Framework\TestSuite as FrameworkTestSuite;
use PHPUnit\Runner\Filter\Factory;
use PHPUnit\TextUI\CliArgu

oversClass(TestSuiteBuilder::class)]
#[Small]
#[Group('event-system')]
#[Group('event-system/value-objects')]
final class TestSuiteBuilderTest extends TestCase
{
    public function test_Builds_TestSuite_value_object_for_test_suite_loaded_from_XML_configur

ments\Builder as CliArgumentsBuilder;
use PHPUnit\TextUI\Configuration\Merger as ConfigurationMerger;
use PHPUnit\TextUI\XmlConfiguration\Loader as XmlConfigurationLoader;
use PHPUnit\TextUI\XmlConfiguration\TestSuiteMapper;

#[C


tian@phpunit.de>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
namespace PHPUnit\Event\TestSuite;

use PHPUnit\Event\Code\TestCollection;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\CoversClassesThatExtendClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;
use PHPUnit\Framework\TestCase;

#[CoversClass(TestSuite::class)]
#[CoversClassesThatExtendClass(

leTest';
        $size      = 0;
        $tests     = TestCollection::fromArray([]);
        $file      = 'ExampleTest.php';
        $line      = 1;

        $testSuite = new TestSuiteForTestClass($className, $size, $tests, $file, $line);

        $this->a

TestSuite::class)]
#[Small]
#[Group('event-system')]
#[Group('event-system/value-objects')]
final class TestSuiteTest extends TestCase
{
    public function testCanBeTestSuiteForTestClass(): void
    {
        $className = 'Examp


 that was distributed with this source code.
 */
namespace PHPUnit\Event\Telemetry;

use InvalidArgumentException;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;
use PHPUnit\Framework\Attributes\TestDox;
use PHPUnit\Framework\TestCase;

#[CoversClass(Duration::class)]
#[Small]
#[Group('event-system')]
#[Group('event-system/value-objects')]
final class DurationTest extends TestCase
{

    /**
     * @return array<string, array{0: int, 1: int, 2: string}>
     */
    public static function provideDurationAndStringRepresentation(): array
    {
        return [
            'less than a minute' => [


tian@phpunit.de>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
namespace PHPUnit\Event\Telemetry;

use InvalidArgumentException;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;
use PHPUnit\Framework\TestCase;

#[CoversClass(HRTime::class)]
#[Small]
#[Group('event-system')]
#[Group('event-system/val

         'seconds-greater' => [
                11,
                1,
                10,
                1,
            ],
            'seconds-and-nanoseconds-greater' => [
                11,
                1,
                10,
                0,

ue-objects')]
final class HRTimeTest extends TestCase
{
    /**
     * @return array<string, array{0: int, 1: int, 2: int, 3: int}>
     */
    public static function provideStartGreaterThanEnd(): array
    {
        return [


s=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\Telemetry;

use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;
use PHPUnit\Framework\TestCase;

#[CoversClass(MemoryUsage::class)]
#[Small

        return [
            'int-less-than-zero'    => [-1],
            'int-zero'              => [0],
            'int-greater-than-zero' => [1],
        ];
    }

    #[DataProvider('provideValidBytes')]
    public function testFromBytesReturnsMemory

]
#[Group('event-system')]
#[Group('event-system/value-objects')]
final class MemoryUsageTest extends TestCase
{
    /**
     * @return array<string, array{int}>
     */
    public static function provideValidBytes(): array
    {


e(strict_types=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\Telemetry;

use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;
use PHPUnit\Framework\TestCase;

#[CoversClass(SystemCpuTimeMeter::class)]
#[Small]
#[Group('event-system')]

->userCpuTime());
    }

    public function testSystemCpuTimeReturnsCpuTime(): void
    {
        $this->assertInstanceOf(CpuTime::class, new SystemCpuTimeMeter()->systemCpuTime());
    }

    public function testUserCpuTimeIsMonotonicallyNonDecreasing():

#[Group('event-system/value-objects')]
final class SystemCpuTimeMeterTest extends TestCase
{
    public function testUserCpuTimeReturnsCpuTime(): void
    {
        $this->assertInstanceOf(CpuTime::class, new SystemCpuTimeMeter()


tian@phpunit.de>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
namespace PHPUnit\Event\Telemetry;

use function hrtime;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;
use PHPUnit\Framework\TestCase;

#[CoversClass(System::class)]
#[Small]
#[Group('event-system')]
#[Group('event-system/value-objects')]
final class SystemTest extends TestCase
{

ime $time;

            public function __construct(HRTime $time)
            {
                $this->time = $time;
            }

            public function current(): HRTime
            {
                return $this->time;
            }
        };

    public function testSnapshotReturnsSnapshot(): void
    {
        $time = HRTime::fromSecondsAndNanoseconds(...hrtime(false));

        $clock = new readonly class($time) implements StopWatch
        {
            private HRT


 * (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 PHPUnit\Event\Runtime;

use const PHP_OS;
use const PHP_OS_FAMILY;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;
use PHPUnit\Framework\TestCase;

#[CoversClass(OperatingSystem::class)]
#[Small]
#[Group('event-system')]
#[Group('event-syste

xtends TestCase
{
    public function testCanBeRepresentedAsString(): void
    {
        $this->assertSame(PHP_OS, (new OperatingSystem)->operatingSystem());
    }

    public function testHasOperatingSystemFamily(): void
    {
        $this->assertSame(PH

m/value-objects')]
final class OperatingSystemTest e


e(strict_types=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\Runtime;

use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;
use PHPUnit\Framework\Attributes\UsesClass;
use PHPUnit\Framework\TestCase;

#[CoversClass(Runtime::class)]
#[U

asOperatingSystem(): void
    {
        $operatingSystem = new OperatingSystem;

        $this->assertSame($operatingSystem->operatingSystem(), (new Runtime)->operatingSystem()->operatingSystem());
    }

    public function test_has_PHP(): void
    {

sesClass(OperatingSystem::class)]
#[UsesClass(PHP::class)]
#[UsesClass(PHPUnit::class)]
#[Small]
#[Group('event-system')]
#[Group('event-system/value-objects')]
final class RuntimeTest extends TestCase
{
    public function testH


       $this->assertFalse($issueTrigger->isDirect());
        $this->assertFalse($issueTrigger->isIndirect());
        $this->assertTrue($issueTrigger->isUnknown());
        $this->assertSame('unknown', $issueTrigger->callerAsString());
        $this->assertSame('unknown', $issueTrigger->calleeAsString());
        $this->assertSame('unknown if issue was triggered in first-party code or third-party code', $issueTrigger->asString());
    }

    #[TestDox('(null, Code::Test) is classified as "unknown"')]
    p

t());
        $this->assertFalse($issueTrigger->isIndirect());
        $this->assertTrue($issueTrigger->isUnknown());
        $this->assertSame('test code', $issueTrigger->callerAsString());
        $this->assertSame('unknown', $issueTrigger->calleeAsStrin

ublic function testCalleeIsUnknownAndCallerIsTest(): void
    {
        $issueTrigger = IssueTrigger::from(null, Code::Test);

        $this->assertFalse($issueTrigger->isSelf());
        $this->assertFalse($issueTrigger->isDirec


 * (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 PHPUnit\Event\Code;

use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;
use PHPUnit\Framework\TestCase;

#[CoversClass(Phpt::class)]
#[CoversClass(Test::class)]
#[Small]
#[Group('event-system')]
#[Group('event-system/value-objects')]
final clas

stConstructorSetsValues(): void
    {
        $file = 'test.phpt';

        $test = new Phpt($file);

        $this->assertSame($file, $test->file());
        $this->assertSame($file, $test->id());
        $this->assertSame($file, $test->name());
        $

s PhptTest extends TestCase
{
    public function te


art of PHPUnit.
 *
 * (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 PHPUnit\Event\TestData;

use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;
use PHPUnit\Framework\Attributes\UsesClass;
use PHPUnit\Framework\TestCase;

#[CoversClass(TestDataCollection::class)]
#[CoversClass(TestDataCollecti

CollectionTest extends TestCase
{
    public function testMayBeEmpty(): void
    {
        $collection = TestDataCollection::fromArray([]);

        $this->assertCount(0, $collection);
        $this->assertFalse($collection->hasDataFromDataProvider());

onIterator::class)]
#[UsesClass(TestData::class)]
#[UsesClass(DataFromDataProvider::class)]
#[UsesClass(DataFromTestDependency::class)]
#[Small]
#[Group('event-system')]
#[Group('event-system/value-objects')]
final class TestData


s=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\TestData;

use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\CoversClassesThatExtendClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;
use PHPUnit\Framework\TestCase;

#[CoversClass(TestData::cla

    {
        $name                  = 'data-set-name';
        $dataAsString          = 'data-as-string';
        $dataAsStringForOutput = 'data-as-string-for-output';

        $data = DataFromDataProvider::from(
            $name,
            $dataAsStri

ss)]
#[CoversClassesThatExtendClass(TestData::class)]
#[Small]
#[Group('event-system')]
#[Group('event-system/value-objects')]
final class TestDataTest extends TestCase
{
    public function testDataCanBeFromDataProvider(): void


e(strict_types=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event;

use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;
use PHPUnit\Framework\TestCase;

#[CoversClass(CollectingDispatcher::class)]
#[Small]
#[Group('event-system')]
#[Group(

ddMapping(Test\DeprecationTriggeredSubscriber::class, Test\DeprecationTriggered::class);

        $dispatcher = new CollectingDispatcher(new DirectDispatcher($typeMap));

        $this->assertEmpty($dispatcher->flush());
    }

    public function testColl

'event-system/dispatcher')]
final class CollectingDispatcherTest extends TestCase
{
    public function testHasNoCollectedEventsWhenFlushedImmediatelyAfterCreation(): void
    {
        $typeMap = new TypeMap;
        $typeMap->a


art of PHPUnit.
 *
 * (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 PHPUnit\Event;

use PHPUnit\Event\Tracer\Tracer;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;
use PHPUnit\Framework\TestCase;
use PHPUnit\TestFixture\DummyEvent;
use PHPUnit\TestFixture\DummySubscriber;
use RuntimeExcep

 void
    {
        $event   = new DummyEvent;
        $typeMap = $this->typeMap();

        $dispatcher = new DirectDispatcher($typeMap);

        $subscriber = $this->createMock(DummySubscriber::class);

        $subscriber
            ->expects($this->o

tion;

#[CoversClass(DirectDispatcher::class)]
#[Small]
#[Group('event-system')]
#[Group('event-system/dispatcher')]
final class DirectDispatcherTest extends TestCase
{
    public function testDispatchesEventToKnownSubscribers():


art of PHPUnit.
 *
 * (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 PHPUnit\Event\Code;

use Exception;
use PHPUnit\Event\NoPreviousThrowableException;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;
use PHPUnit\Framework\TestCase;
use PHPUnit\Util\Filter;

#[CoversClass(Throwable::class)]

d
    {
        $e = new Exception('message', 123, null);
        $t = ThrowableBuilder::from($e);

        $this->assertSame(Exception::class, $t->className());
        $this->assertSame('message', $t->message());
        $this->assertSame("Exception: mes

#[CoversClass(ThrowableBuilder::class)]
#[Small]
#[Group('event-system')]
#[Group('event-system/value-objects')]
final class ThrowableTest extends TestCase
{
    public function testCanBeCreatedForThrowableWithoutPrevious(): voi


s=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\Telemetry;

use function hrtime;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;
use PHPUnit\Framework\TestCase;

#[CoversClass(Snapshot::class)]
#[Small]
#[Group('event-system')]
#[

       $memoryUsage            = MemoryUsage::fromBytes(2000);
        $peakMemoryUsage        = MemoryUsage::fromBytes(3000);
        $garbageCollectorStatus = new GarbageCollectorStatus(0, 0, 0, 0, 0.0, 0.0, 0.0, 0.0, false, false, false, 0);
        $us

Group('event-system/value-objects')]
final class SnapshotTest extends TestCase
{
    public function testConstructorSetsValues(): void
    {
        $time                   = HRTime::fromSecondsAndNanoseconds(...hrtime(false));


e(strict_types=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\Telemetry;

use function hrtime;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;
use PHPUnit\Framework\TestCase;

#[CoversClass(SystemStopWatch::class)]
#[Small]
#[Group

= HRTime::fromSecondsAndNanoseconds(...hrtime(false));

        $current = $clock->current();

        $after = HRTime::fromSecondsAndNanoseconds(...hrtime(false));

        $durationBetweenCurrentAndBefore = $current->duration($before);

        $this->as

('event-system')]
#[Group('event-system/value-objects')]
final class SystemStopWatchTest extends TestCase
{
    public function testNowReturnsDateTimeImmutable(): void
    {
        $clock = new SystemStopWatch;

        $before


art of PHPUnit.
 *
 * (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 PHPUnit\Event\Code\IssueTrigger;

use Generator;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\Attributes\Small;
use PHPUnit\Framework\Attributes\TestDox;
use PHPUnit\Framework\TestCase;

#[CoversClass(Code::class)]
#[Small]
final

 #[TestDox('$code is categorized')]
    public function testCodeIsCategorizedAtHighLevel(Code $code): void
    {
        $this->assertTrue($code->isFirstPartyOrTest() || $code->isThirdPartyOrPhpunitOrPhp());
        $this->assertFalse($code->isFirstPartyOr

class CodeTest extends TestCase
{
    public static function enumCases(): Generator
    {
        foreach (Code::cases() as $code) {
            yield $code->value => [$code];
        }
    }

    #[DataProvider('enumCases')]


tian@phpunit.de>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
namespace PHPUnit\Event\Code;

use function sprintf;
use PHPUnit\Event\TestData\DataFromDataProvider;
use PHPUnit\Event\TestData\TestDataCollection;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;
use PHPUnit\Framework\TestCase;
use PHPUnit\Metadata\MetadataCollection;

#[CoversClas

        $className  = 'FooTest';
        $methodName = 'testBar';
        $file       = 'FooTest.php';
        $line       = 1;
        $testDox    = TestDoxBuilder::fromClassNameAndMethodName('Foo', 'bar');
        $testData   = TestDataCollection::fromAr

s(TestMethod::class)]
#[CoversClass(Test::class)]
#[Small]
#[Group('event-system')]
#[Group('event-system/value-objects')]
final class TestMethodTest extends TestCase
{
    public function testConstructorSetsValues(): void
    {


tian@phpunit.de>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
namespace PHPUnit\Event;

use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;
use PHPUnit\Framework\TestCase;
use PHPUnit\TestFixture\AnotherDummySubscriber;
use PHPUnit\TestFixture\DummyEvent;
use PHPUnit\TestFixture\DummySubscriber;
use PHPUnit\TestFixture\MockObject\AnInterface;
use

{
        $subscriber     = $this->createStub(DummySubscriber::class);
        $subscriberType = DummySubscriber::class;
        $event          = new DummyEvent;
        $eventType      = DummyEvent::class;

        $map = new TypeMap;

        $this->ass

PHPUnit\TestFixture\MockObject\FinalClass;

#[CoversClass(TypeMap::class)]
#[Small]
#[Group('event-system')]
final class TypeMapTest extends TestCase
{
    public function testMapsKnownSubscriberInterfaceToEventClass(): void


tian@phpunit.de>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
namespace PHPUnit\Event\Telemetry;

use InvalidArgumentException;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;
use PHPUnit\Framework\TestCase;

#[CoversClass(CpuTime::class)]
#[Small]
#[Group('event-system')]
#[Group('event-system/value-objects')]
final class CpuTimeTest extends

        $this->assertSame($seconds, $cpuTime->seconds());
        $this->assertSame($nanoseconds, $cpuTime->nanoseconds());
    }

    public function testSecondsMustNotBeNegative(): void
    {
        $this->expectException(InvalidArgumentException::clas

TestCase
{
    public function testCanBeCreatedFromSecondsAndNanoseconds(): void
    {
        $seconds     = 123;
        $nanoseconds = 999999999;

        $cpuTime = CpuTime::fromSecondsAndNanoseconds($seconds, $nanoseconds);


art of PHPUnit.
 *
 * (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 PHPUnit\Event\Telemetry;

use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;
use PHPUnit\Framework\TestCase;

#[CoversClass(GarbageCollectorStatus::class)]
#[Small]
#[Group('event-system')]
#[Group('event-system/value-objects

d
    {
        $this->assertSame(2, $this->garbageCollectorStatus()->collected());
    }

    public function testHasThreshold(): void
    {
        $this->assertSame(3, $this->garbageCollectorStatus()->threshold());
    }

    public function testHasRoot

')]
final class GarbageCollectorStatusTest extends TestCase
{
    public function testHasRuns(): void
    {
        $this->assertSame(1, $this->garbageCollectorStatus()->runs());
    }

    public function testHasCollected(): voi


?php declare(strict_types=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\Code;

use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;
use PHPUnit\Framework\TestCase;

#[CoversClass(ComparisonFailure::class)]
#[Small]
#[Group('event-syste

iff     = 'diff';

        $comparisonFailure = new ComparisonFailure($expected, $actual, $diff);

        $this->assertSame($expected, $comparisonFailure->expected());
        $this->assertSame($actual, $comparisonFailure->actual());
        $this->assert

m')]
#[Group('event-system/value-objects')]
final class ComparisonFailureTest extends TestCase
{
    public function testConstructorSetsValues(): void
    {
        $expected = 'expected';
        $actual   = 'actual';
        $d


tian@phpunit.de>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
namespace PHPUnit\Event\Telemetry;

use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;
use PHPUnit\Framework\TestCase;

#[CoversClass(Info::class)]
#[Small]
#[Group('event-system')]
#[Group('event-system/value-objects')]
final class InfoTest extends TestCase
{
    public function testH

e());
    }

    public function testHasPeakMemoryUsage(): void
    {
        $this->assertInstanceOf(MemoryUsage::class, $this->info()->peakMemoryUsage());
    }

    public function testHasDurationSinceStart(): void
    {
        $this->assertSame(0, $th

asTime(): void
    {
        $this->assertInstanceOf(HRTime::class, $this->info()->time());
    }

    public function testHasMemoryUsage(): void
    {
        $this->assertInstanceOf(MemoryUsage::class, $this->info()->memoryUsag


s=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\Runtime;

use const PHP_EXTRA_VERSION;
use const PHP_MAJOR_VERSION;
use const PHP_MINOR_VERSION;
use const PHP_RELEASE_VERSION;
use const PHP_SAPI;
use const PHP_VERSION;
use const PHP_VERSION_ID;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Frame

ase
{
    public function testHasVersion(): void
    {
        $this->assertSame(PHP_VERSION, (new PHP)->version());
    }

    public function testHasVersionId(): void
    {
        $this->assertSame(PHP_VERSION_ID, (new PHP)->versionId());
    }

    pub

work\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;
use PHPUnit\Framework\TestCase;

#[CoversClass(PHP::class)]
#[Small]
#[Group('event-system')]
#[Group('event-system/value-objects')]
final class PHPTest extends TestC


art of PHPUnit.
 *
 * (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 PHPUnit\Event;

use PHPUnit\Event\Tracer\Tracer;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;
use PHPUnit\Framework\TestCase;
use PHPUnit\TestFixture\DummySubscriber;

#[CoversClass(DeferringDispatcher::class)]
#[Small]

ck(SubscribableDispatcher::class);

        $subscribableDispatcher
            ->expects($this->never())
            ->method('dispatch')
            ->seal();

        $deferringDispatcher = new DeferringDispatcher($subscribableDispatcher);

        $def

#[Group('event-system')]
#[Group('event-system/dispatcher')]
final class DeferringDispatcherTest extends TestCase
{
    public function testCollectsEventsUntilFlush(): void
    {
        $subscribableDispatcher = $this->createMo


* This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\Runtime;

use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;
use PHPUnit\Framework\TestCase;
use PHPUnit\Runner\Version;

#[CoversClass(PHPUnit::class)]
#[Small]
#[Group('event-system')]
#[Group(

st extends TestCase
{
    public function testHasVersionId(): void
    {
        $this->assertSame(Version::id(), (new PHPUnit)->versionId());
    }

    public function testHasReleaseSeries(): void
    {
        $this->assertSame(Version::series(), (new P

'event-system/value-objects')]
final class PHPUnitTe


s=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\Code;

use PHPUnit\Event\TestData\TestDataCollection;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;
use PHPUnit\Framework\TestCase;
use PHPUnit\Metadata\MetadataCollection;

#[Cove

eatedFromArray(): void
    {
        $test  = $this->test();
        $tests = TestCollection::fromArray([$test]);

        $this->assertSame([$test], $tests->asArray());
    }

    public function testIsCountable(): void
    {
        $test  = $this->test(

rsClass(TestCollection::class)]
#[CoversClass(TestCollectionIterator::class)]
#[Small]
#[Group('event-system')]
#[Group('event-system/value-objects')]
final class TestCollectionTest extends TestCase
{
    public function testIsCr


e(strict_types=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\TestSuite;

use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversClass(Filtered::class)]
#[Small]
#[Group('event-system')]
#

testSuiteValueObject();

        $event = new Filtered(
            $telemetryInfo,
            $testSuite,
        );

        $this->assertSame($telemetryInfo, $event->telemetryInfo());
        $this->assertSame($testSuite, $event->testSuite());
    }

[Group('event-system/events')]
final class FilteredTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $telemetryInfo = $this->telemetryInfo();
        $testSuite     = $this->


s=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\Test;

use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Event\Code;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversClass(PostConditionFinished::class)]
#[Small]
#[Group

        $test          = $this->testValueObject();
        $calledMethods = $this->calledMethods();

        $event = new PostConditionFinished(
            $telemetryInfo,
            $test,
            ...$calledMethods,
        );

        $this->assert

('event-system')]
#[Group('event-system/events')]
final class PostConditionFinishedTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $telemetryInfo = $this->telemetryInfo();


s=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\Test;

use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Event\Code;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversClass(PreConditionCalled::class)]
#[Small]
#[Group('e

  $test          = $this->testValueObject();
        $calledMethod  = $this->calledMethod();

        $event = new PreConditionCalled(
            $telemetryInfo,
            $test,
            $calledMethod,
        );

        $this->assertSame($telemetr

vent-system')]
#[Group('event-system/events')]
final class PreConditionCalledTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $telemetryInfo = $this->telemetryInfo();


s=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\Test;

use Exception;
use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Event\Code;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversClass(PreConditionErrored::class)]
#[S

tryInfo();
        $test          = $this->testValueObject();
        $calledMethod  = $this->calledMethod();
        $throwable     = Code\ThrowableBuilder::from(new Exception('message'));

        $event = new PreConditionErrored(
            $telemetryI

mall]
#[Group('event-system')]
#[Group('event-system/events')]
final class PreConditionErroredTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $telemetryInfo = $this->teleme


s=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\Test;

use Exception;
use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Event\Code;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversClass(PreConditionFailed::class)]
#[Sm

yInfo();
        $test          = $this->testValueObject();
        $calledMethod  = $this->calledMethod();
        $throwable     = Code\ThrowableBuilder::from(new Exception('message'));

        $event = new PreConditionFailed(
            $telemetryInfo

all]
#[Group('event-system')]
#[Group('event-system/events')]
final class PreConditionFailedTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $telemetryInfo = $this->telemetr


s=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\Test;

use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Event\Code;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversClass(PreConditionFinished::class)]
#[Small]
#[Group(

      $test          = $this->testValueObject();
        $calledMethods = $this->calledMethods();

        $event = new PreConditionFinished(
            $telemetryInfo,
            $test,
            ...$calledMethods,
        );

        $this->assertSam

'event-system')]
#[Group('event-system/events')]
final class PreConditionFinishedTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $telemetryInfo = $this->telemetryInfo();


s=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\Test;

use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Event\Code\ClassMethod;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversClass(DataProviderMethodCalled::class)]
#

this->telemetryInfo();
        $testMethod         = new ClassMethod('ClassTest', 'testOne');
        $dataProviderMethod = new ClassMethod('ClassTest', 'dataProvider');

        $event = new DataProviderMethodCalled(
            $telemetryInfo,

[Small]
#[Group('event-system')]
#[Group('event-system/events')]
final class DataProviderMethodCalledTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $telemetryInfo      = $


s=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\Test;

use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Event\Code\ClassMethod;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversClass(DataProviderMethodFinished::class)]

 = $this->telemetryInfo();
        $testMethod         = new ClassMethod('ClassTest', 'testOne');
        $dataProviderMethod = new ClassMethod('ClassTest', 'dataProvider');

        $event = new DataProviderMethodFinished(
            $telemetryInfo,

#[Small]
#[Group('event-system')]
#[Group('event-system/events')]
final class DataProviderMethodFinishedTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $telemetryInfo


e(strict_types=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\Test;

use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversClass(Finished::class)]
#[Small]
#[Group('event-system')]
#[Grou

alueObject();

        $event = new Finished(
            $telemetryInfo,
            $test,
            1,
        );

        $this->assertSame($telemetryInfo, $event->telemetryInfo());
        $this->assertSame($test, $event->test());
        $this->ass

p('event-system/events')]
final class FinishedTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $telemetryInfo = $this->telemetryInfo();
        $test          = $this->testV


s=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\Test;

use const PHP_EOL;
use Exception;
use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Event\Code\ThrowableBuilder;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversCl

    $telemetryInfo = $this->telemetryInfo();
        $test          = $this->testValueObject();
        $throwable     = ThrowableBuilder::from(new Exception('message'));

        $event = new PreparationErrored(
            $telemetryInfo,
            $te

ass(PreparationErrored::class)]
#[Small]
#[Group('event-system')]
#[Group('event-system/events')]
final class PreparationErroredTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {


  $telemetryInfo = $this->telemetryInfo();
        $test          = $this->testValueObject();
        $throwable     = ThrowableBuilder::from(new Exception('message'));

        $event = new PreparationFailed(
            $telemetryInfo,
            $test,

ass(PreparationFailed::class)]
#[Small]
#[Group('event-system')]
#[Group('event-system/events')]
final class PreparationFailedTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {


e(strict_types=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\Test;

use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversClass(PreparationStarted::class)]
#[Small]
#[Group('event-system

      = $this->testValueObject();

        $event = new PreparationStarted(
            $telemetryInfo,
            $test,
        );

        $this->assertSame($telemetryInfo, $event->telemetryInfo());
        $this->assertSame($test, $event->test());

')]
#[Group('event-system/events')]
final class PreparationStartedTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $telemetryInfo = $this->telemetryInfo();
        $test


e(strict_types=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\Test;

use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversClass(Prepared::class)]
#[Small]
#[Group('event-system')]
#[Grou

alueObject();

        $event = new Prepared(
            $telemetryInfo,
            $test,
        );

        $this->assertSame($telemetryInfo, $event->telemetryInfo());
        $this->assertSame($test, $event->test());
    }

    public function testCa

p('event-system/events')]
final class PreparedTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $telemetryInfo = $this->telemetryInfo();
        $test          = $this->testV


s=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\Test;

use Exception;
use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Event\Code;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversClass(Errored::class)]
#[Small]
#[Grou

          = $this->testValueObject();
        $throwable     = $this->throwable();

        $event = new Errored(
            $telemetryInfo,
            $test,
            $throwable,
        );

        $this->assertSame($telemetryInfo, $event->telemetry

p('event-system')]
#[Group('event-system/events')]
final class ErroredTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $telemetryInfo = $this->telemetryInfo();
        $test


art of PHPUnit.
 *
 * (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 PHPUnit\Event\Test;

use Exception;
use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Event\Code;
use PHPUnit\Event\Code\ComparisonFailure;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversClass(Failed::class)]

o();
        $test              = $this->testValueObject();
        $throwable         = $this->throwable();
        $comparisonFailure = $this->comparisonFailure();

        $event = new Failed(
            $telemetryInfo,
            $test,
            $

#[Small]
#[Group('event-system')]
#[Group('event-system/events')]
final class FailedTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $telemetryInfo     = $this->telemetryInf


s=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\Test;

use Exception;
use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Event\Code;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversClass(MarkedIncomplete::class)]
#[Smal

o();
        $test          = $this->testValueObject();
        $throwable     = $this->throwable();

        $event = new MarkedIncomplete(
            $telemetryInfo,
            $test,
            $throwable,
        );

        $this->assertSame($telem

l]
#[Group('event-system')]
#[Group('event-system/events')]
final class MarkedIncompleteTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $telemetryInfo = $this->telemetryInf


declare(strict_types=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\Test;

use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversClass(Passed::class)]
#[Small]
#[Group('event-system')]
#[

tValueObject();

        $event = new Passed(
            $telemetryInfo,
            $test,
        );

        $this->assertSame($telemetryInfo, $event->telemetryInfo());
        $this->assertSame($test, $event->test());
    }

    public function testCa

Group('event-system/events')]
final class PassedTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $telemetryInfo = $this->telemetryInfo();
        $test          = $this->tes


e(strict_types=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\Test;

use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversClass(Skipped::class)]
#[Small]
#[Group('event-system')]
#[Group

ueObject();
        $message       = 'skipped';

        $event = new Skipped(
            $telemetryInfo,
            $test,
            $message,
        );

        $this->assertSame($telemetryInfo, $event->telemetryInfo());
        $this->assertSame($t

('event-system/events')]
final class SkippedTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $telemetryInfo = $this->telemetryInfo();
        $test          = $this->testVal


s=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\Test;

use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversClass(ConsideredRisky::class)]
#[Small]
#[Group('event-system')]
#[Group('eve

ValueObject();

        $message = 'message';

        $event = new ConsideredRisky(
            $telemetryInfo,
            $test,
            $message,
        );

        $this->assertSame($telemetryInfo, $event->telemetryInfo());
        $this->assertS

nt-system/events')]
final class ConsideredRiskyTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $telemetryInfo = $this->telemetryInfo();
        $test          = $this->test


s=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\Test;

use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Event\Code;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversClass(BeforeFirstTestMethodCalled::class)]
#[Small]
#

etryInfo();
        $testClassName = 'Test';
        $calledMethod  = $this->calledMethod();

        $event = new BeforeFirstTestMethodCalled(
            $telemetryInfo,
            $testClassName,
            $calledMethod,
        );

        $this->as

[Group('event-system')]
#[Group('event-system/events')]
final class BeforeFirstTestMethodCalledTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $telemetryInfo = $this->telem


s=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\Test;

use Exception;
use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Event\Code;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversClass(BeforeFirstTestMethodErrored::cl

fo = $this->telemetryInfo();
        $testClassName = 'Test';
        $calledMethod  = $this->calledMethod();
        $throwable     = Code\ThrowableBuilder::from(new Exception('message'));

        $event = new BeforeFirstTestMethodErrored(
            $t

ass)]
#[Small]
#[Group('event-system')]
#[Group('event-system/events')]
final class BeforeFirstTestMethodErroredTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $telemetryIn


s=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\Test;

use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Event\Code;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversClass(BeforeTestMethodCalled::class)]
#[Small]
#[Grou

;
        $test          = $this->testValueObject();
        $calledMethod  = $this->calledMethod();

        $event = new BeforeTestMethodCalled(
            $telemetryInfo,
            $test,
            $calledMethod,
        );

        $this->assertSa

p('event-system')]
#[Group('event-system/events')]
final class BeforeTestMethodCalledTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $telemetryInfo = $this->telemetryInfo()


s=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\Test;

use Exception;
use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Event\Code;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversClass(BeforeTestMethodErrored::class)]

->telemetryInfo();
        $test          = $this->testValueObject();
        $calledMethod  = $this->calledMethod();
        $throwable     = Code\ThrowableBuilder::from(new Exception('message'));

        $event = new BeforeTestMethodErrored(

#[Small]
#[Group('event-system')]
#[Group('event-system/events')]
final class BeforeTestMethodErroredTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $telemetryInfo = $this


s=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\Test;

use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Event\Code;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversClass(BeforeTestMethodFinished::class)]
#[Small]
#[Gr

fo();
        $test          = $this->testValueObject();
        $calledMethods = $this->calledMethods();

        $event = new BeforeTestMethodFinished(
            $telemetryInfo,
            $test,
            ...$calledMethods,
        );

        $thi

oup('event-system')]
#[Group('event-system/events')]
final class BeforeTestMethodFinishedTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $telemetryInfo = $this->telemetryIn


s=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\Test;

use Exception;
use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Event\Code;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversClass(PostConditionFailed::class)]
#[S

tryInfo();
        $test          = $this->testValueObject();
        $calledMethod  = $this->calledMethod();
        $throwable     = Code\ThrowableBuilder::from(new Exception('message'));

        $event = new PostConditionFailed(
            $telemetryI

mall]
#[Group('event-system')]
#[Group('event-system/events')]
final class PostConditionFailedTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $telemetryInfo = $this->teleme


art of PHPUnit.
 *
 * (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 PHPUnit\Event\TestRunner\Issue;

use const PHP_EOL;
use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversClass(WarningTriggered::class)]
#[Small]
#[Group('event-system')]
#[Grou

  = 'message';
        $file              = 'file';
        $line              = 1;
        $suppressed        = false;
        $ignoredByBaseline = false;

        $event = new WarningTriggered(
            $telemetryInfo,
            $message,

p('event-system/events')]
final class WarningTriggeredTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $telemetryInfo     = $this->telemetryInfo();
        $message


declare(strict_types=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\TestSuite;

use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversClass(Loaded::class)]
#[Small]
#[Group('event-system'

->testSuiteValueObject();

        $event = new Loaded($telemetryInfo, $testSuite);

        $this->assertSame($telemetryInfo, $event->telemetryInfo());
        $this->assertSame($testSuite, $event->testSuite());
    }

    public function testCanBeReprese

)]
#[Group('event-system/events')]
final class LoadedTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $telemetryInfo = $this->telemetryInfo();
        $testSuite     = $this


s=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\TestSuite;

use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversClass(Sorted::class)]
#[Small]
#[Group('event-system')]
#[Group('event-s

      $executionOrderDefects = 5;
        $resolveDependencies   = true;

        $event = new Sorted(
            $telemetryInfo,
            $executionOrder,
            $executionOrderDefects,
            $resolveDependencies,
        );

        $this-

ystem/events')]
final class SortedTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $telemetryInfo         = $this->telemetryInfo();
        $executionOrder        = 9001;


declare(strict_types=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\TestSuite;

use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversClass(Started::class)]
#[Small]
#[Group('event-system

is->testSuiteValueObject();

        $event = new Started($telemetryInfo, $testSuite);

        $this->assertSame($telemetryInfo, $event->telemetryInfo());
        $this->assertSame($testSuite, $event->testSuite());
    }

    public function testCanBeRepr

')]
#[Group('event-system/events')]
final class StartedTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $telemetryInfo = $this->telemetryInfo();
        $testSuite     = $th


s=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\Test;

use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversClass(AdditionalInformationProvided::class)]
#[Small]
#[Group('event-system')

        $test                  = $this->testValueObject();
        $additionalInformation = 'additional information';

        $event = new AdditionalInformationProvided(
            $telemetryInfo,
            $test,
            $additionalInformation,

]
#[Group('event-system/events')]
final class AdditionalInformationProvidedTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $telemetryInfo         = $this->telemetryInfo();


s=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\Test;

use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Event\Code\ClassMethod;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversClass(CustomTestMethodInvocationUsed::cla

nfo              = $this->telemetryInfo();
        $test                       = $this->testValueObject();
        $customTestMethodInvocation = $this->calledMethod();

        $event = new CustomTestMethodInvocationUsed(
            $telemetryInfo,

ss)]
#[Small]
#[Group('event-system')]
#[Group('event-system/events')]
final class CustomTestMethodInvocationUsedTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $telemetryI


e(strict_types=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\Test;

use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversClass(PrintedUnexpectedOutput::class)]
#[Small]
#[Group('event-s

 $output        = 'output';

        $event = new PrintedUnexpectedOutput(
            $telemetryInfo,
            $output,
        );

        $this->assertSame($telemetryInfo, $event->telemetryInfo());
        $this->assertSame($output, $event->output())

ystem')]
#[Group('event-system/events')]
final class PrintedUnexpectedOutputTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $telemetryInfo = $this->telemetryInfo();


s=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\Test;

use Exception;
use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Event\Code;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversClass(AfterLastTestMethodFailed::class

this->telemetryInfo();
        $testClassName = 'Test';
        $calledMethod  = $this->calledMethod();
        $throwable     = Code\ThrowableBuilder::from(new Exception('message'));

        $event = new AfterLastTestMethodFailed(
            $telemetryI

)]
#[Small]
#[Group('event-system')]
#[Group('event-system/events')]
final class AfterLastTestMethodFailedTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $telemetryInfo = $


s=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\Test;

use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Event\Code;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversClass(AfterLastTestMethodFinished::class)]
#[Small]
#

etryInfo();
        $testClassName = 'Test';
        $calledMethods = $this->calledMethods();

        $event = new AfterLastTestMethodFinished(
            $telemetryInfo,
            $testClassName,
            ...$calledMethods,
        );

        $thi

[Group('event-system')]
#[Group('event-system/events')]
final class AfterLastTestMethodFinishedTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $telemetryInfo = $this->telem


s=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\Test;

use Exception;
use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Event\Code;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversClass(AfterTestMethodErrored::class)]

telemetryInfo();
        $test          = $this->testValueObject();
        $calledMethod  = $this->calledMethod();
        $throwable     = Code\ThrowableBuilder::from(new Exception('message'));

        $event = new AfterTestMethodErrored(
            $t

#[Small]
#[Group('event-system')]
#[Group('event-system/events')]
final class AfterTestMethodErroredTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $telemetryInfo = $this->


s=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\Test;

use Exception;
use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Event\Code;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversClass(BeforeFirstTestMethodFailed::cla

 = $this->telemetryInfo();
        $testClassName = 'Test';
        $calledMethod  = $this->calledMethod();
        $throwable     = Code\ThrowableBuilder::from(new Exception('message'));

        $event = new BeforeFirstTestMethodFailed(
            $tele

ss)]
#[Small]
#[Group('event-system')]
#[Group('event-system/events')]
final class BeforeFirstTestMethodFailedTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $telemetryInfo


s=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\Test;

use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Event\Code;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversClass(BeforeFirstTestMethodFinished::class)]
#[Small]

elemetryInfo();
        $testClassName = 'Test';
        $calledMethods = $this->calledMethods();

        $event = new BeforeFirstTestMethodFinished(
            $telemetryInfo,
            $testClassName,
            ...$calledMethods,
        );

#[Group('event-system')]
#[Group('event-system/events')]
final class BeforeFirstTestMethodFinishedTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $telemetryInfo = $this->t


s=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\Test;

use Exception;
use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Event\Code;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversClass(BeforeTestMethodFailed::class)]

telemetryInfo();
        $test          = $this->testValueObject();
        $calledMethod  = $this->calledMethod();
        $throwable     = Code\ThrowableBuilder::from(new Exception('message'));

        $event = new BeforeTestMethodFailed(
            $t

#[Small]
#[Group('event-system')]
#[Group('event-system/events')]
final class BeforeTestMethodFailedTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $telemetryInfo = $this->


e(strict_types=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\TestSuite;

use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversClass(Finished::class)]
#[Small]
#[Group('event-system')]
#

testSuiteValueObject();

        $event = new Finished(
            $telemetryInfo,
            $testSuite,
        );

        $this->assertSame($telemetryInfo, $event->telemetryInfo());
        $this->assertSame($testSuite, $event->testSuite());
    }

[Group('event-system/events')]
final class FinishedTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $telemetryInfo = $this->telemetryInfo();
        $testSuite     = $this->


e(strict_types=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\TestSuite;

use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversClass(Skipped::class)]
#[Small]
#[Group('event-system')]
#[

stSuiteValueObject();
        $message       = 'the-message';

        $event = new Skipped($telemetryInfo, $testSuite, $message);

        $this->assertSame($telemetryInfo, $event->telemetryInfo());
        $this->assertSame($testSuite, $event->testSuite(

Group('event-system/events')]
final class SkippedTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $telemetryInfo = $this->telemetryInfo();
        $testSuite     = $this->te


e(strict_types=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\Test;

use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversClass(ComparatorRegistered::class)]
#[Small]
#[Group('event-syst

sName     = 'ClassName';

        $event = new ComparatorRegistered(
            $telemetryInfo,
            $className,
        );

        $this->assertSame($telemetryInfo, $event->telemetryInfo());
        $this->assertSame($className, $event->className

em')]
#[Group('event-system/events')]
final class ComparatorRegisteredTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $telemetryInfo = $this->telemetryInfo();
        $clas


s=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\Test;

use Exception;
use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Event\Code;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversClass(AfterLastTestMethodErrored::clas

 $this->telemetryInfo();
        $testClassName = 'Test';
        $calledMethod  = $this->calledMethod();
        $throwable     = Code\ThrowableBuilder::from(new Exception('message'));

        $event = new AfterLastTestMethodErrored(
            $telemet

s)]
#[Small]
#[Group('event-system')]
#[Group('event-system/events')]
final class AfterLastTestMethodErroredTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $telemetryInfo =


s=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\Test;

use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Event\Code;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversClass(AfterTestMethodCalled::class)]
#[Small]
#[Group

        $test          = $this->testValueObject();
        $calledMethod  = $this->calledMethod();

        $event = new AfterTestMethodCalled(
            $telemetryInfo,
            $test,
            $calledMethod,
        );

        $this->assertSame(

('event-system')]
#[Group('event-system/events')]
final class AfterTestMethodCalledTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $telemetryInfo = $this->telemetryInfo();


s=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\Test;

use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Event\Code;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversClass(AfterTestMethodFinished::class)]
#[Small]
#[Gro

();
        $test          = $this->testValueObject();
        $calledMethods = $this->calledMethods();

        $event = new AfterTestMethodFinished(
            $telemetryInfo,
            $test,
            ...$calledMethods,
        );

        $this->

up('event-system')]
#[Group('event-system/events')]
final class AfterTestMethodFinishedTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $telemetryInfo = $this->telemetryInfo


declare(strict_types=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\Application;

use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversClass(Finished::class)]
#[Small]
#[Group('event-sys

 0;

        $event = new Finished($telemetryInfo, $shellExitCode);

        $this->assertSame($telemetryInfo, $event->telemetryInfo());
        $this->assertSame($shellExitCode, $event->shellExitCode());
    }

    public function testCanBeRepresentedAsSt

tem')]
#[Group('event-system/events')]
final class FinishedTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $telemetryInfo = $this->telemetryInfo();
        $shellExitCode =


s=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Event\Test;

use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Event\Code;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversClass(AfterLastTestMethodCalled::class)]
#[Small]
#[G

Info();
        $testClassName = 'Test';
        $calledMethod  = $this->calledMethod();

        $event = new AfterLastTestMethodCalled(
            $telemetryInfo,
            $testClassName,
            $calledMethod,
        );

        $this->assertSa

roup('event-system')]
#[Group('event-system/events')]
final class AfterLastTestMethodCalledTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $telemetryInfo = $this->telemetry


art of PHPUnit.
 *
 * (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 PHPUnit\Event\Test;

use const PHP_EOL;
use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversClass(WarningTriggered::class)]
#[Small]
#[Group('event-system')]
#[Group('event-sys

estValueObject();
        $message           = 'message';
        $file              = 'file';
        $line              = 1;
        $suppressed        = false;
        $ignoredByBaseline = false;

        $event = new WarningTriggered(
            $tele

tem/events')]
final class WarningTriggeredTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $telemetryInfo     = $this->telemetryInfo();
        $test              = $this->t


clare(strict_types=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Runner;

use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;
use PHPUnit\Framework\TestCase;

#[CoversClass(ErrorHandler::class)]
#[Small]
#[Group('test-runner')]
final class

ion testCanRegisterAndRestoreForNonTestCaseContext(): void
    {
        $errorHandler = ErrorHandler::instance();
        $errorHandler->registerForNonTestCaseContext();
        $errorHandler->restoreForNonTestCaseContext();

        $this->assertTrue(tru

ErrorHandlerTest extends TestCase
{
    public funct


;
use PHPUnit\Event\Test\ErrorTriggered;
use PHPUnit\Event\Test\NoticeTriggered;
use PHPUnit\Event\Test\PhpDeprecationTriggered;
use PHPUnit\Event\Test\PhpNoticeTriggered;
use PHPUnit\Event\Test\PhpWarningTriggered;
use PHPUnit\Event\Test\WarningTriggered;
use PHPUnit\Event\TestData\TestDataCollection;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;
use PHPUnit\Framework\TestCase;
use PHPUnit\Metadata\MetadataCollection;
use PHPUn

ssueFilterTest extends TestCase
{
    public function testProcessesDeprecationByDefault(): void
    {
        $filter = new IssueFilter($this->source());

        $this->assertTrue(
            $filter->shouldBeProcessed($this->deprecationEvent()),

it\TextUI\Configuration\FilterDirectoryCollection;
use PHPUnit\TextUI\Configuration\FilterFileCollection;
use PHPUnit\TextUI\Configuration\Source;

#[CoversClass(IssueFilter::class)]
#[Small]
#[Group('test-runner')]
final class I


Framework\DataProviderTestSuite;
use PHPUnit\Framework\TestCase;
use PHPUnit\Framework\TestStatus\TestStatus;
use PHPUnit\Framework\TestSuite;
use PHPUnit\Runner\ResultCache\DefaultResultCache;
use PHPUnit\Runner\ResultCache\ResultCacheId;
use PHPUnit\TestFixture\LargeGroupAttributesTest;
use PHPUnit\TestFixture\MediumGroupAttributesTest;
use PHPUnit\TestFixture\NonReorderableTest;
use PHPUnit\TestFixture\SmallGroupAttributesTest;
use PHPUnit\TestFixture\SmallTestWithDataProvider;
use ReflectionClass;

#[Co

tesTest('testOne');
        $small  = new SmallGroupAttributesTest('testOne');
        $medium = new MediumGroupAttributesTest('testOne');

        $suite = TestSuite::empty('test');
        $suite->setTests([$large, $small, $medium]);

        $sorter = n

versClass(TestSuiteSorter::class)]
#[CoversClass(DataProviderTestSuite::class)]
#[Small]
final class TestSuiteSorterTest extends TestCase
{
    public function testSortsBySize(): void
    {
        $large  = new LargeGroupAttribu


e(strict_types=1);
/*
 * This file is part of PHPUnit.
 *
 * (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 PHPUnit\Runner\Filter;

use Exception;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;
use PHPUnit\Framework\TestCase;
use PHPUnit\Framework\TestSuite;
use PHPUnit\TestFixture\BankAcc

c function testCaseSensitiveMatch(): void
    {
        $this->assertTrue($this->createFilter('NotMatchingPattern')->accept());
    }

    /**
     * @throws Exception
     */
    public function testCaseInsensitiveMatch(): void
    {
        $this->assert

ountTest;

#[CoversClass(ExcludeNameFilterIterator::class)]
#[Small]
#[Group('test-runner')]
#[Group('test-runner/filter')]
class ExcludeNameFilterIteratorTest extends TestCase
{
    /**
     * @throws Exception
     */
    publi


tian@phpunit.de>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
namespace PHPUnit\Runner\Filter;

use Exception;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;
use PHPUnit\Framework\TestCase;
use PHPUnit\Framework\TestSuite;
use PHPUnit\TestFixture\BankAccountTest;

#[CoversClass(IncludeNameFilterIterator::class)]
#[CoversClass(NameFilterIterat

    {
        $this->assertTrue($this->createFilter('BankAccountTest')->accept());
    }

    /**
     * @throws Exception
     */
    public function testCaseInsensitiveMatch(): void
    {
        $this->assertTrue($this->createFilter('bankaccounttest')->

or::class)]
#[Small]
#[Group('test-runner')]
#[Group('test-runner/filter')]
final class IncludeNameFilterIteratorTest extends TestCase
{
    /**
     * @throws Exception
     */
    public function testCaseSensitiveMatch(): void


tian@phpunit.de>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
namespace PHPUnit\Runner\Filter;

use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;
use PHPUnit\Framework\Attributes\TestDox;
use PHPUnit\Framework\TestCase;

#[CoversClass(MethodNameFilterCompiler::class)]
#[Small]
#[Group('test-runner')

thodNamePortion(): array
    {
        return [
            'plain method name'                                            => ['testFoo', '{testFoo}i'],
            'with numeric data set index'                                  => ['testFoo#0', '{testFoo}i

]
#[Group('test-runner/filter')]
final class MethodNameFilterCompilerTest extends TestCase
{
    /**
     * @return non-empty-list<array{non-empty-string, non-empty-string}>
     */
    public static function provideFiltersWithMe