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\Runner\Filter;

use function assert;
use Iterator;
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\Framework\Te

terIteratorTest extends TestCase
{
    public function testAcceptsTestsBasedOnTheirId(): void
    {
        $id = 'PHPUnit\TestFixture\BankAccountTest::testBalanceCannotBecomeNegative';

        foreach ($this->testSuiteIterator([$id]) as $test) {

stSuiteIterator;
use PHPUnit\TestFixture\BankAccountTest;

#[CoversClass(TestIdFilterIterator::class)]
#[CoversClass(TestSuiteIterator::class)]
#[Small]
#[Group('test-runner')]
#[Group('test-runner/filter')]
final class TestIdFil


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\Runner\Extension;

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

#[CoversClass(ExtensionFacade::class)]
#[Small]
#[Group('test-runner')]
final class ExtensionFacadeTest extends Te

d
    {
        $facade = new ExtensionFacade;

        $facade->replaceOutput();

        $this->assertTrue($facade->replacesOutput());
    }

    public function testDoesNotReplaceProgressOutputByDefault(): void
    {
        $facade = new ExtensionFacad

stCase
{
    public function testDoesNotReplaceOutputByDefault(): void
    {
        $facade = new ExtensionFacade;

        $this->assertFalse($facade->replacesOutput());
    }

    public function testOutputCanBeReplaced(): 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\Runner\Extension;

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

#[CoversClass(ParameterCollection::cl

 ParameterCollection::fromArray(['key' => 'value']);

        $this->assertTrue($parameters->has('key'));
    }

    public function testReportsWhetherParameterExists(): void
    {
        $parameters = ParameterCollection::fromArray(['key' => 'value']);

ass)]
#[CoversClass(ParameterDoesNotExistException::class)]
#[Small]
#[Group('test-runner')]
final class ParameterCollectionTest extends TestCase
{
    public function testCanBeCreatedFromArray(): void
    {
        $parameters =


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\Phpt;

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

#[CoversClass(PhptExternalFileCannotBeLoadedException::class)]
#[CoversClass(Uns

        $exception = new PhptExternalFileCannotBeLoadedException('FILE', '/path/to/missing.php');

        $this->assertSame(
            'Could not load --FILE_EXTERNAL-- /path/to/missing.php for PHPT file',
            $exception->getMessage(),

upportedPhptSectionException::class)]
#[Small]
#[Group('test-runner')]
#[Group('test-runner/phpt')]
final class ExceptionTest extends TestCase
{
    public function testPhptExternalFileCannotBeLoadedExceptionMessage(): 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\Phpt;

use function glob;
use function realpath;
use function str_replace;
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

pty-string, array{0: non-empty-string}>
     */
    public static function unsupportedSections(): array
    {
        $data = [];

        foreach (glob(__DIR__ . '/../../../_files/phpt/unsupported/*.phpt') as $file) {
            $data[str_replace([__DIR_

(Parser::class)]
#[CoversClass(PhptExternalFileCannotBeLoadedException::class)]
#[Small]
#[Group('test-runner')]
#[Group('test-runner/phpt')]
final class ParserTest extends TestCase
{
    /**
     * @return non-empty-array<non-em


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\Phpt;

use function file_exists;
use function sys_get_temp_dir;
use function tempnam;
use function unlink;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;
use PHPUnit\Framework\TestCase;

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

)) {
                @unlink($file);
            }
        }
    }

    public function testRenderReplacesFileAndDirConstants(): void
    {
        $renderer = new Renderer;

        $result = $renderer->render(
            '/path/to/test.phpt',

up('test-runner/phpt')]
final class RendererTest extends TestCase
{
    private array $tempFiles = [];

    protected function tearDown(): void
    {
        foreach ($this->tempFiles as $file) {
            if (file_exists($file


hp 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\Runner\Phpt;

use function realpath;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;
use PHPUnit\Framework\TestCase as FrameworkTestCase;

#[CoversClass(TestCase::cla

/_files/success.phpt');
        $testCase = new TestCase($filename);

        $this->assertSame($filename, $testCase->sortId());
    }

    public function testCountReturnsOne(): void
    {
        $filename = realpath(__DIR__ . '/../../../_files/success.p

ss)]
#[Small]
#[Group('test-runner')]
#[Group('test-runner/phpt')]
final class TestCaseTest extends FrameworkTestCase
{
    public function testSortIdReturnsFilename(): void
    {
        $filename = realpath(__DIR__ . '/../../..


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\Runner;

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(HookMethodCollection::class)]
#[Small]
#[Group('test-runner')]

        return [
            [
                HookMethodCollection::defaultBeforeClass()->add(new HookMethod('someMethod', 0)),
                ['someMethod', 'setUpBeforeClass'],
            ],
            [
                HookMethodCollection::default

#[Group('test-runner/hook-methods')]
final class HookMethodCollectionTest extends TestCase
{
    /**
     * @return iterable<array{HookMethodCollection, list<string>}>
     */
    public static function provider(): iterable
    {


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\Baseline;

use function array_keys;
use function realpath;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;
use PHPUnit\Framework\TestCase;

#[CoversClass(Baseline::class)]
#[Small]
#[Group('test-runner')]
#[Group('test-runner/issue-baseline')]
final class Ba

   $this->assertCount(1, $issues);
        $this->assertArrayHasKey($this->issue()->file(), $issues);

        $lines = $issues[$this->issue()->file()];

        $this->assertCount(1, $lines);
        $this->assertArrayHasKey(10, $lines);

        $line =

selineTest extends TestCase
{
    public function testGroupsIssuesByFileAndLine(): void
    {
        $baseline = new Baseline;

        $baseline->add($this->issue());

        $issues = $baseline->groupedByFileAndLine();


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\Runner\Baseline;

use function realpath;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;
use PHPUnit\Framework\TestCase;
use PHPUnit\Runner\FileDoesNotExistException;

#[CoversClass(Issue::class)]
#[CoversClass(Fil

): void
    {
        $this->assertSame(
            realpath(__DIR__ . '/../../../_files/baseline/FileWithIssues.php'),
            $this->issue()->file(),
        );
    }

    public function testHasLine(): void
    {
        $this->assertSame(10, $this

eDoesNotExistException::class)]
#[CoversClass(FileDoesNotHaveLineException::class)]
#[Small]
#[Group('test-runner')]
#[Group('test-runner/issue-baseline')]
final class IssueTest extends TestCase
{
    public function testHasFile(


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\Runner\Baseline;

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

#[CoversClass(Reader::class)]
#[Small]
#[Group('test-runner')]
#[Group('test-runner/issue-ba

s->assertTrue($baseline->has($this->issue()));
        $this->assertTrue($baseline->has($this->anotherIssue()));
        $this->assertTrue($baseline->has($this->yetAnotherIssue()));
    }

    public function testCannotReadBaselineFromFileThatDoesNotExist(

seline')]
final class ReaderTest extends TestCase
{
    public function testReadsBaselineFromFileWithValidXml(): void
    {
        $baseline = (new Reader)->read(__DIR__ . '/../../../_files/baseline/expected.xml');

        $thi


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\Baseline;

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(RelativePathCalculator::class)]
#[Small]
#[Group('test-runner')]
#[Group('test-runner/issue-baseline')] /

tring, string, string}>
     */
    public static function dataGetRelativePath(): array
    {
        return [
            [
                '/usr/var/www',
                '/usr/var/www/test.php',
                'test.php',
            ],
            [

**
 * @see Copied from https://github.com/phpstan/phpstan-src/blob/1.10.33/src/File/ParentDirectoryRelativePathHelper.php
 */
final class RelativePathCalculatorTest extends TestCase
{
    /**
     * @return non-empty-list<array{s


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\Runner\Baseline;

use const DIRECTORY_SEPARATOR;
use function getcwd;
use function ltrim;
use function realpath;
use function str_replace;
use function unlink;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\Attributes\Group;

 string $target;

    /**
     * @return iterable<array{string}>
     */
    public static function baselinePathProvider(): iterable
    {
        $absoluteBaselinePath = __DIR__ . '/../../../_files/baseline/expected.xml';

        yield [$absoluteBaseline

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

#[CoversClass(Writer::class)]
#[Small]
#[Group('test-runner')]
#[Group('test-runner/issue-baseline')]
final class WriterTest extends TestCase
{
    private


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\Runner\IssueTriggerResolver;

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

#[CoversClass(Resolution::class)]
#[Small]
#[Group('test-runner')]
final class ResolutionTest extends T

on testHasCalleeReturnsFalseWhenCalleeIsNull(): void
    {
        $resolution = new Resolution(null, null);

        $this->assertFalse($resolution->hasCallee());
    }

    public function testCalleeReturnsSetValue(): void
    {
        $resolution = new

estCase
{
    public function testHasCalleeReturnsTrueWhenCalleeIsSet(): void
    {
        $resolution = new Resolution('/path/to/callee.php', null);

        $this->assertTrue($resolution->hasCallee());
    }

    public functi


 that was distributed with this source code.
 */
namespace PHPUnit\Runner\DeprecationCollector;

use function hrtime;
use PHPUnit\Event\Code\IssueTrigger\IssueTrigger;
use PHPUnit\Event\Code\TestDoxBuilder;
use PHPUnit\Event\Code\TestMethod;
use PHPUnit\Event\Telemetry\CpuTime;
use PHPUnit\Event\Telemetry\Duration;
use PHPUnit\Event\Telemetry\GarbageCollectorStatus;
use PHPUnit\Event\Telemetry\HRTime;
use PHPUnit\Event\Telemetry\Info;
use PHPUnit\Event\Telemetry\MemoryUsage;
use PHPUnit\Event\Telemetry\Snap

HPUnit\Framework\TestCase;
use PHPUnit\Metadata\MetadataCollection;
use PHPUnit\TestRunner\IssueFilter;
use PHPUnit\TextUI\Configuration\FilterDirectoryCollection;
use PHPUnit\TextUI\Configuration\FilterFileCollection;
use PHPUnit\TextUI\Configuration\Sour

shot;
use PHPUnit\Event\Test\DeprecationTriggered;
use PHPUnit\Event\TestData\TestDataCollection;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;
use P


 that was distributed with this source code.
 */
namespace PHPUnit\Runner\ResultCache;

use const DIRECTORY_SEPARATOR;
use function file_put_contents;
use function is_file;
use function json_encode;
use function sys_get_temp_dir;
use function tempnam;
use function uniqid;
use function unlink;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;
use PHPUnit\Framework\TestCase;
use PHPUnit\Framework\TestStatus\TestStatus;
use PHPUnit\Run

Clean = [];

    protected function tearDown(): void
    {
        foreach ($this->filesToClean as $file) {
            if (is_file($file)) {
                @unlink($file);
            }
        }
    }

    public function testConstructorAppendsDefaultFi

ner\DirectoryDoesNotExistException;

#[CoversClass(DefaultResultCache::class)]
#[Small]
#[Group('test-runner')]
#[Group('test-runner/result-cache')]
final class DefaultResultCacheTest extends TestCase
{
    private array $filesTo


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\Runner\ResultCache;

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

#[CoversClass(NullResultCache::class)]
#[Small]
#[Group('test-runne

sAndMethodName(self::class, 'testOne');

        $cache->setStatus($id, TestStatus::failure('failure'));

        $this->assertTrue($cache->status($id)->isUnknown());
    }

    public function testStatusReturnsUnknown(): void
    {
        $cache = new Nu

r')]
#[Group('test-runner/result-cache')]
final class NullResultCacheTest extends TestCase
{
    public function testSetStatusIsNoOp(): void
    {
        $cache = new NullResultCache;
        $id    = ResultCacheId::fromTestClas


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\ResultCache;

use const DIRECTORY_SEPARATOR;
use function sys_get_temp_dir;
use Exception;
use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Event\Code\ThrowableBuilder;
use PHPUnit\Event\Facade;
use PHPUnit\Event\Test\ConsideredRisky;
use PHPUnit\Event\Test\MarkedIncomplete;
use PHPUnit\Event\Test\Prepared;
use PHPUnit\Event\Test\

er/result-cache')]
final class ResultCacheHandlerTest extends AbstractEventTestCase
{
    public function testMarkedIncompleteRecordsIncompleteStatus(): void
    {
        $cache   = new DefaultResultCache(sys_get_temp_dir() . DIRECTORY_SEPARATOR . 'phpuni

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

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


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\Runner\ResultCache;

use PHPUnit\Event\Code\Phpt;
use PHPUnit\Event\Code\TestDox;
use PHPUnit\Event\Code\TestMethod;
use PHPUnit\Event\TestData\TestDataCollection;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\Attributes\Gr

up('test-runner/result-cache')]
final class ResultCacheIdTest extends TestCase
{
    /**
     * @return iterable<array{string, ResultCacheId}>
     */
    public static function provideResultCacheIds(): iterable
    {
        yield ['PHPUnit\Runner\ResultC

oup;
use PHPUnit\Framework\Attributes\Small;
use PHPUnit\Framework\Reorderable;
use PHPUnit\Framework\TestCase;
use PHPUnit\Metadata\MetadataCollection;

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


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\Runner\ResultCache;

use const DIRECTORY_SEPARATOR;
use function sys_get_temp_dir;
use Exception;
use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Event\Code\ThrowableBuilder;
use PHPUnit\Event\Facade;
use PHPUnit\Event\Test\ConsideredRisky;
use PHPUnit\Event\Test\MarkedIncomplete;
use P

sideredRiskySubscriber::class)]
#[CoversClass(TestSkippedSubscriber::class)]
#[Small]
#[Group('test-runner')]
#[Group('test-runner/result-cache')]
final class SubscriberTest extends AbstractEventTestCase
{
    public function testMarkedIncompleteSubscriber

HPUnit\Event\Test\Skipped;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversClass(TestMarkedIncompleteSubscriber::class)]
#[CoversClass(TestCon


hot;
use PHPUnit\Event\Test\ConsideredRisky;
use PHPUnit\Event\Test\DeprecationTriggered;
use PHPUnit\Event\Test\Errored;
use PHPUnit\Event\Test\Failed;
use PHPUnit\Event\Test\Finished;
use PHPUnit\Event\Test\MarkedIncomplete;
use PHPUnit\Event\Test\NoticeTriggered;
use PHPUnit\Event\Test\Passed;
use PHPUnit\Event\Test\PhpDeprecationTriggered;
use PHPUnit\Event\Test\PhpNoticeTriggered;
use PHPUnit\Event\Test\PhpunitDeprecationTriggered;
use PHPUnit\Event\Test\PhpunitErrorTriggered;
use PHPUnit\Event\Test\Ph

it\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;
use PHPUnit\Framework\TestCase;
use PHPUnit\Metadata\MetadataCollection;
use PHPUnit\TestFixture\InheritanceA;
use PHPUnit\TestFixture\Test

punitWarningTriggered;
use PHPUnit\Event\Test\PhpWarningTriggered;
use PHPUnit\Event\Test\Prepared;
use PHPUnit\Event\Test\Skipped;
use PHPUnit\Event\Test\WarningTriggered;
use PHPUnit\Event\TestData\TestDataCollection;
use PHPUn


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 const PHP_EOL;
use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

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

Info();
        $test          = $this->testValueObject();
        $message       = 'message';

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

        $this->assertSame($telemetr

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


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 PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

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

       $test          = $this->testValueObject();
        $message       = 'message';
        $ignoredByTest = false;

        $event = new PhpunitWarningTriggered(
            $telemetryInfo,
            $test,
            $message,
            $ignoredBy

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


ass)]
#[UsesClass(Before::class)]
#[UsesClass(BeforeClass::class)]
#[UsesClass(CoversClass::class)]
#[UsesClass(CoversFunction::class)]
#[UsesClass(CoversMethod::class)]
#[UsesClass(CoversNothing::class)]
#[UsesClass(DataProvider::class)]
#[UsesClass(DataProviderClosure::class)]
#[UsesClass(DependsOnClass::class)]
#[UsesClass(DependsOnMethod::class)]
#[UsesClass(DisableReturnValueGenerationForTestDoubles::class)]
#[UsesClass(DoesNotPerformAssertions::class)]
#[UsesClass(Group::class)]
#[UsesClass(Metadata::

class)]
#[UsesClass(PostCondition::class)]
#[UsesClass(PreCondition::class)]
#[UsesClass(PreserveGlobalState::class)]
#[UsesClass(RequiresFunction::class)]
#[UsesClass(RequiresMethod::class)]
#[UsesClass(RequiresOperatingSystem::


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\Metadata;

use PharIo\Version\VersionConstraintParser;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;
use PHPUnit\Framework\Attributes\UsesClass;
use PHPUnit\Framewor

quirement::class)]
#[CoversClass(ConstraintRequirement::class)]
#[CoversClass(Requirement::class)]
#[UsesClass(VersionComparisonOperator::class)]
#[Small]
#[Group('metadata')]
final class RequirementTest extends TestCase
{
    /**
     * @return non-empty-

k\TestCase;
use PHPUnit\Metadata\Version\ComparisonRequirement;
use PHPUnit\Metadata\Version\ConstraintRequirement;
use PHPUnit\Metadata\Version\Requirement;
use PHPUnit\Util\VersionComparisonOperator;

#[CoversClass(ComparisonRe


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(PostConditionErrored::class)]
#[

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

        $event = new PostConditionErrored(
            $telemet

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


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(AfterTestMethodFailed::class)]
#

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

        $event = new AfterTestMethodFailed(
            $tele

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


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(PostConditionCalled::class)]
#[Small]
#[Group('

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

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

        $this->assertSame($telem

event-system')]
#[Group('event-system/events')]
final class PostConditionCalledTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $telemetryInfo = $this->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\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(ErrorTriggered::class)]
#[Small]
#[Group('event-system')]
#[Group('event-syste

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

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

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


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(PhpNoticeTriggered::class)]
#[Small]
#[Group('event-system')]
#[Group('event-s

s->testValueObject();
        $message           = 'message';
        $file              = 'file';
        $line              = 1;
        $suppressed        = false;
        $ignoredByBaseline = false;

        $event = new PhpNoticeTriggered(

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


 that was distributed with this source code.
 */
namespace PHPUnit\Metadata\Parser;

use PHPUnit\Framework\Attributes\After;
use PHPUnit\Framework\Attributes\AfterClass;
use PHPUnit\Framework\Attributes\AllowMockObjectsWithoutExpectations;
use PHPUnit\Framework\Attributes\BackupGlobals;
use PHPUnit\Framework\Attributes\BackupStaticProperties;
use PHPUnit\Framework\Attributes\Before;
use PHPUnit\Framework\Attributes\BeforeClass;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\C

oversNamespace;
use PHPUnit\Framework\Attributes\CoversNothing;
use PHPUnit\Framework\Attributes\CoversTrait;
use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\Attributes\DataProviderExternal;
use PHPUnit\Framework\Attributes\Depends;
us

oversClassesThatExtendClass;
use PHPUnit\Framework\Attributes\CoversClassesThatImplementInterface;
use PHPUnit\Framework\Attributes\CoversFunction;
use PHPUnit\Framework\Attributes\CoversMethod;
use PHPUnit\Framework\Attributes\C


 that was distributed with this source code.
 */
namespace PHPUnit\Metadata\Api;

use function array_shift;
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;
use PHPUnit\TestFixture\CoversClassOnClassTest;
use PHPUnit\TestFixture\CoversNothingOnClassTest;
use PHPUnit\TestFixture\Metadata\Attribute\CoversTest;
use

SebastianBergmann\CodeCoverage\Test\Target\ClassesThatImplementInterface;
use SebastianBergmann\CodeCoverage\Test\Target\Function_;
use SebastianBergmann\CodeCoverage\Test\Target\Method;
use SebastianBergmann\CodeCoverage\Test\Target\Namespace_;
use Sebast

PHPUnit\TestFixture\Metadata\Attribute\UsesTest;
use PHPUnit\TestFixture\NoCoverageAttributesTest;
use SebastianBergmann\CodeCoverage\Test\Target\Class_;
use SebastianBergmann\CodeCoverage\Test\Target\ClassesThatExtendClass;
use


 that was distributed with this source code.
 */
namespace PHPUnit\Metadata\Api;

use function array_keys;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;
use PHPUnit\Framework\TestCase;
use PHPUnit\Runner\HookMethod;
use PHPUnit\Runner\HookMethodCollection;
use PHPUnit\TestFixture\TestWithHookMethodsPrioritizedTest;
use PHPUnit\TestFixture\TestWithHookMethodsTest;
use PHPUnit\TestFixture\TestWithoutHookMethodsTest;

#[CoversClass

sertEquals(
            [
                'beforeClass'   => HookMethodCollection::defaultBeforeClass(),
                'before'        => HookMethodCollection::defaultBefore(),
                'preCondition'  => HookMethodCollection::defaultPreCondition(

(HookMethods::class)]
#[Small]
#[Group('metadata')]
#[Group('metadata/api')]
final class HookMethodsTest extends TestCase
{
    public function testReturnsDefaultHookMethodsForClassThatDoesNotExist(): void
    {
        $this->as


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

use PHPUnit\Event\Code\TestDoxBuilder;
use PHPUnit\Event\Code\TestMethod;
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\Framework\TestStatus\TestStatus;
u

no_test_results(): void
    {
        $this->assertStringEqualsFile(
            __DIR__ . '/expectations/html/empty.html',
            (new HtmlRenderer)->render([]),
        );
    }

    public function test_Successful_test_method_is_marked_as_success()

se PHPUnit\Metadata\MetadataCollection;

#[CoversClass(HtmlRenderer::class)]
#[Group('testdox')]
#[Small]
final class HtmlRendererTest extends TestCase
{
    public function test_Empty_input_renders_a_complete_HTML_document_with_


: void
    {
        $this->assertStringEqualsFile(
            __DIR__ . '/expectations/plain-text/empty.txt',
            (new PlainTextRenderer)->render([]),
        );
    }

    public function test_Successful_test_method_is_marked_with_x(): void

se PHPUnit\Metadata\MetadataCollection;

#[CoversClass(PlainTextRenderer::class)]
#[Group('testdox')]
#[Small]
final class PlainTextRendererTest extends TestCase
{
    public function test_Empty_input_renders_to_an_empty_string()


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

use function iterator_to_array;
use PHPUnit\Event\Code\TestDoxBuilder;
use PHPUnit\Event\Code\TestMethod;
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\Fr

nTest extends TestCase
{
    public function test_An_empty_collection_can_be_created(): void
    {
        $collection = TestResultCollection::fromArray([]);

        $this->assertSame([], $collection->asArray());
        $this->assertSame([], iterator_to_

amework\TestStatus\TestStatus;
use PHPUnit\Metadata\MetadataCollection;

#[CoversClass(TestResultCollection::class)]
#[CoversClass(TestResultCollectionIterator::class)]
#[Group('testdox')]
#[Small]
final class TestResultCollectio


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(PhpWarningTriggered::class)]
#[Small]
#[Group('event-system')]
#[Group('event-

his->testValueObject();
        $message           = 'message';
        $file              = 'file';
        $line              = 1;
        $suppressed        = false;
        $ignoredByBaseline = false;

        $event = new PhpWarningTriggered(

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


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 const PHP_EOL;
use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

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

ryInfo();
        $test          = $this->testValueObject();
        $message       = 'message';

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

        $this->assertSame($telem

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


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\Application;

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

#[CoversClass(Started::class)]

);
        $runtime       = new Runtime;

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

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

#[Small]
#[Group('event-system')]
#[Group('event-system/events')]
final class StartedTest extends AbstractEventTestCase
{
    public function testConstructorSetsValues(): void
    {
        $telemetryInfo = $this->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\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(NoticeTriggered::class)]
#[Small]
#[Group('event-system')]
#[Group('event-syst

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

        $event = new NoticeTriggered(
            $telemet

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


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\Test;

use const PHP_EOL;
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(PhpDeprecationTriggered::class)]
#[Small]
#[Group('event-system')]
#[Group('eve

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

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


 that was distributed with this source code.
 */
namespace PHPUnit\Metadata\Api;

use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;
use PHPUnit\Framework\InvalidDataProviderException;
use PHPUnit\Framework\TestCase;
use PHPUnit\TestFixture\DuplicateKeyDataProvidersTest;
use PHPUnit\TestFixture\DuplicateKeyDataProviderTest;
use PHPUnit\TestFixture\MultipleDataProviderTest;
use PHPUnit\TestFixture\TestWithAttributeDataProviderTest;
us

roviders are being merged.
     */
    public function testMultipleDataProviders(): void
    {
        $dataSets = $this->getRawDataFromProvidedData(
            (new DataProvider)->providedData(MultipleDataProviderTest::class, 'testOne'),
        );

e PHPUnit\TestFixture\VariousIterableDataProviderTest;

#[CoversClass(DataProvider::class)]
#[Small]
#[Group('metadata')]
#[Group('metadata/api')]
final class DataProviderTest extends TestCase
{
    /**
     * Check if all data p


 that was distributed with this source code.
 */
namespace PHPUnit\Metadata\Api;

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

#[CoversClass(Requirements::class)]
#[Small]
#[Group('metadata')]
#[Group('metadata/api')]
final class RequirementsTest extends TestCase
{
    /**
     * @return n

  'Function testFunc() is required.',
            ]],
            ['testTen',            [
                'PHP extension testExt is required.',
            ]],
            ['testAlwaysSkip',     [
                'PHPUnit >= 1111111.0.0 is required.',

on-empty-list<array{string, list<string>}>
     */
    public static function missingRequirementsProvider(): array
    {
        return [
            ['testOne',            []],
            ['testNine',           [


 that was distributed with this source code.
 */
namespace PHPUnit\Logging\TestDox;

use DateTimeImmutable;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;
use PHPUnit\Framework\TestCase;
use PHPUnit\TestFixture\BackedEnumeration;
use PHPUnit\TestFixture\Enumeration;
use PHPUnit\TestFixture\TestDox\TestDoxAttributeOnTestClassTest;
use PHPUnit\TestFixture\TestDoxTest;
use stdClass;

#[

unction classNameProvider(): array
    {
        return [
            [
                'Foo',
                'FooTest',
            ],
            [
                'Test Foo',
                'TestFoo',
            ],
            [
                'Test

CoversClass(NamePrettifier::class)]
#[Group('testdox')]
#[Small]
final class NamePrettifierTest extends TestCase
{
    /**
     * @return non-empty-list<array{0: non-empty-string, 1: non-empty-string}>
     */
    public static f


>isDataProvider());
        $this->assertFalse($metadata->isDataProviderClosure());
        $this->assertFalse($metadata->isDependsOnClass());
        $this->assertFalse($metadata->isDependsOnMethod());
        $this->assertFalse($metadata->isDisableReturnValueGenerationForTestDoubles());
        $this->assertFalse($metadata->isDoesNotPerformAssertions());
        $this->assertFalse($metadata->isExcludeGlobalVariableFromBackup());
        $this->assertFalse($metadata->isExcludeStaticPropertyFromBackup());

HPUnitWarnings());
        $this->assertFalse($metadata->isRunInSeparateProcess());
        $this->assertFalse($metadata->isRunTestsInSeparateProcesses());
        $this->assertFalse($metadata->isTest());
        $this->assertFalse($metadata->isPreConditio

       $this->assertFalse($metadata->isGroup());
        $this->assertFalse($metadata->isIgnoreDeprecations());
        $this->assertFalse($metadata->isIgnorePhpunitDeprecations());
        $this->assertFalse($metadata->isIgnoreP


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\Test;

use const PHP_EOL;
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)]
#[Small]
#[Group('event-system')]
#[Group('event-

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

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


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

use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;
use PHPUnit\Framework\TestCase;
use PHPUnit\TestFixture\LargeGroupAttributesTest;
use PHPUnit\TestFixture\MediumGroupAttributesTest;
use PHPUnit\TestFixtur

Test extends TestCase
{
    /**
     * @return non-empty-list<array{list<string>, class-string, string, bool}>
     */
    public static function provider(): array
    {
        return [
            [
                [
                ],
                No

e\NoGroupsMetadataTest;
use PHPUnit\TestFixture\SmallGroupAnnotationsTest;
use PHPUnit\TestFixture\SmallGroupAttributesTest;

#[CoversClass(Groups::class)]
#[Small]
#[Group('metadata')]
#[Group('metadata/api')]
final class Groups


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\Logging\TestDox;

use PHPUnit\Event\Code\TestDoxBuilder;
use PHPUnit\Event\Code\TestMethod;
use PHPUnit\Event\Code\Throwable;
use PHPUnit\Event\TestData\TestDataCollection;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\

ase
{
    public function test_Test_method_status_and_throwable_are_exposed_when_a_throwable_is_present(): void
    {
        $testMethod = $this->testMethod();
        $status     = TestStatus::error('boom');
        $throwable  = new Throwable(

Small;
use PHPUnit\Framework\TestCase;
use PHPUnit\Framework\TestStatus\TestStatus;
use PHPUnit\Metadata\MetadataCollection;

#[CoversClass(TestResult::class)]
#[Group('testdox')]
#[Small]
final class TestResultTest extends TestC


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 const PHP_EOL;
use PHPUnit\Event\AbstractEventTestCase;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Small;

#[CoversClass(PhpunitDeprecationTriggered::class)]
#[

s->telemetryInfo();
        $test          = $this->testValueObject();
        $message       = 'message';

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

        $this->as

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


nValueGenerationForTestDoublesTest;
use PHPUnit\TestFixture\Metadata\Attribute\DoesNotPerformAssertionsTest;
use PHPUnit\TestFixture\Metadata\Attribute\DuplicateSmallAttributeTest;
use PHPUnit\TestFixture\Metadata\Attribute\DuplicateTestAttributeTest;
use PHPUnit\TestFixture\Metadata\Attribute\Example;
use PHPUnit\TestFixture\Metadata\Attribute\ExampleTrait;
use PHPUnit\TestFixture\Metadata\Attribute\GroupTest;
use PHPUnit\TestFixture\Metadata\Attribute\IgnoreDeprecationsClassTest;
use PHPUnit\TestFixture\M

e\Metadata\Attribute\IgnorePhpunitWarningsTest;
use PHPUnit\TestFixture\Metadata\Attribute\LargeTest;
use PHPUnit\TestFixture\Metadata\Attribute\MediumTest;
use PHPUnit\TestFixture\Metadata\Attribute\NonPhpunitAttributeTest;
use PHPUnit\TestFixture\Metadat

etadata\Attribute\IgnoreDeprecationsMethodTest;
use PHPUnit\TestFixture\Metadata\Attribute\IgnorePhpunitDeprecationsClassTest;
use PHPUnit\TestFixture\Metadata\Attribute\IgnorePhpunitDeprecationsMethodTest;
use PHPUnit\TestFixtur