@averay/codeformat 0.2.1 → 0.2.3

package/vendor/friendsofphp/php-cs-fixer/src/Fixer/PhpUnit/PhpUnitDedicateAssertInternalTypeFixer.php

@@ -0,0 +1,204 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of PHP CS Fixer.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *     Dariusz Rumiński <dariusz.ruminski@gmail.com>
+ *
+ * This source file is subject to the MIT license that is bundled
+ * with this source code in the file LICENSE.
+ */
+
+namespace PhpCsFixer\Fixer\PhpUnit;
+
+use PhpCsFixer\Fixer\AbstractPhpUnitFixer;
+use PhpCsFixer\Fixer\ConfigurableFixerInterface;
+use PhpCsFixer\Fixer\ConfigurableFixerTrait;
+use PhpCsFixer\FixerConfiguration\FixerConfigurationResolver;
+use PhpCsFixer\FixerConfiguration\FixerConfigurationResolverInterface;
+use PhpCsFixer\FixerConfiguration\FixerOptionBuilder;
+use PhpCsFixer\FixerDefinition\CodeSample;
+use PhpCsFixer\FixerDefinition\FixerDefinition;
+use PhpCsFixer\FixerDefinition\FixerDefinitionInterface;
+use PhpCsFixer\Tokenizer\Token;
+use PhpCsFixer\Tokenizer\Tokens;
+use PhpCsFixer\Tokenizer\TokensAnalyzer;
+
+/**
+ * @author Filippo Tessarotto <zoeslam@gmail.com>
+ *
+ * @implements ConfigurableFixerInterface<_AutogeneratedInputConfiguration, _AutogeneratedComputedConfiguration>
+ *
+ * @phpstan-type _AutogeneratedInputConfiguration array{
+ *  target?: '7.5'|'newest',
+ * }
+ * @phpstan-type _AutogeneratedComputedConfiguration array{
+ *  target: '7.5'|'newest',
+ * }
+ */
+final class PhpUnitDedicateAssertInternalTypeFixer extends AbstractPhpUnitFixer implements ConfigurableFixerInterface
+{
+    /** @use ConfigurableFixerTrait<_AutogeneratedInputConfiguration, _AutogeneratedComputedConfiguration> */
+    use ConfigurableFixerTrait;
+
+    /**
+     * @var array<string, string>
+     */
+    private array $typeToDedicatedAssertMap = [
+        'array' => 'assertIsArray',
+        'boolean' => 'assertIsBool',
+        'bool' => 'assertIsBool',
+        'double' => 'assertIsFloat',
+        'float' => 'assertIsFloat',
+        'integer' => 'assertIsInt',
+        'int' => 'assertIsInt',
+        'null' => 'assertNull',
+        'numeric' => 'assertIsNumeric',
+        'object' => 'assertIsObject',
+        'real' => 'assertIsFloat',
+        'resource' => 'assertIsResource',
+        'string' => 'assertIsString',
+        'scalar' => 'assertIsScalar',
+        'callable' => 'assertIsCallable',
+        'iterable' => 'assertIsIterable',
+    ];
+
+    public function getDefinition(): FixerDefinitionInterface
+    {
+        return new FixerDefinition(
+            'PHPUnit assertions like `assertIsArray` should be used over `assertInternalType`.',
+            [
+                new CodeSample(
+                    '<?php
+final class MyTest extends \PHPUnit\Framework\TestCase
+{
+    public function testMe()
+    {
+        $this->assertInternalType("array", $var);
+        $this->assertInternalType("boolean", $var);
+    }
+}
+'
+                ),
+                new CodeSample(
+                    '<?php
+final class MyTest extends \PHPUnit\Framework\TestCase
+{
+    public function testMe()
+    {
+        $this->assertInternalType("array", $var);
+        $this->assertInternalType("boolean", $var);
+    }
+}
+',
+                    ['target' => PhpUnitTargetVersion::VERSION_7_5]
+                ),
+            ],
+            null,
+            'Risky when PHPUnit methods are overridden or when project has PHPUnit incompatibilities.'
+        );
+    }
+
+    public function isRisky(): bool
+    {
+        return true;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * Must run after NoBinaryStringFixer, NoUselessConcatOperatorFixer, PhpUnitDedicateAssertFixer.
+     */
+    public function getPriority(): int
+    {
+        return -16;
+    }
+
+    protected function createConfigurationDefinition(): FixerConfigurationResolverInterface
+    {
+        return new FixerConfigurationResolver([
+            (new FixerOptionBuilder('target', 'Target version of PHPUnit.'))
+                ->setAllowedTypes(['string'])
+                ->setAllowedValues([PhpUnitTargetVersion::VERSION_7_5, PhpUnitTargetVersion::VERSION_NEWEST])
+                ->setDefault(PhpUnitTargetVersion::VERSION_NEWEST)
+                ->getOption(),
+        ]);
+    }
+
+    protected function applyPhpUnitClassFix(Tokens $tokens, int $startIndex, int $endIndex): void
+    {
+        $anonymousClassIndices = [];
+        $tokenAnalyzer = new TokensAnalyzer($tokens);
+
+        for ($index = $startIndex; $index < $endIndex; ++$index) {
+            if (!$tokens[$index]->isGivenKind(T_CLASS) || !$tokenAnalyzer->isAnonymousClass($index)) {
+                continue;
+            }
+
+            $openingBraceIndex = $tokens->getNextTokenOfKind($index, ['{']);
+            $closingBraceIndex = $tokens->findBlockEnd(Tokens::BLOCK_TYPE_CURLY_BRACE, $openingBraceIndex);
+
+            $anonymousClassIndices[$closingBraceIndex] = $openingBraceIndex;
+        }
+
+        for ($index = $endIndex - 1; $index > $startIndex; --$index) {
+            if (isset($anonymousClassIndices[$index])) {
+                $index = $anonymousClassIndices[$index];
+
+                continue;
+            }
+
+            if (!$tokens[$index]->isGivenKind(T_STRING)) {
+                continue;
+            }
+
+            $functionName = strtolower($tokens[$index]->getContent());
+
+            if ('assertinternaltype' !== $functionName && 'assertnotinternaltype' !== $functionName) {
+                continue;
+            }
+
+            $bracketTokenIndex = $tokens->getNextMeaningfulToken($index);
+
+            if (!$tokens[$bracketTokenIndex]->equals('(')) {
+                continue;
+            }
+
+            $expectedTypeTokenIndex = $tokens->getNextMeaningfulToken($bracketTokenIndex);
+            $expectedTypeToken = $tokens[$expectedTypeTokenIndex];
+
+            if (!$expectedTypeToken->isGivenKind(T_CONSTANT_ENCAPSED_STRING)) {
+                continue;
+            }
+
+            $expectedType = trim($expectedTypeToken->getContent(), '\'"');
+
+            if (!isset($this->typeToDedicatedAssertMap[$expectedType])) {
+                continue;
+            }
+
+            $commaTokenIndex = $tokens->getNextMeaningfulToken($expectedTypeTokenIndex);
+
+            if (!$tokens[$commaTokenIndex]->equals(',')) {
+                continue;
+            }
+
+            $newAssertion = $this->typeToDedicatedAssertMap[$expectedType];
+
+            if ('assertnotinternaltype' === $functionName) {
+                $newAssertion = str_replace('Is', 'IsNot', $newAssertion);
+                $newAssertion = str_replace('Null', 'NotNull', $newAssertion);
+            }
+
+            $nextMeaningfulTokenIndex = $tokens->getNextMeaningfulToken($commaTokenIndex);
+
+            $tokens->overrideRange($index, $nextMeaningfulTokenIndex - 1, [
+                new Token([T_STRING, $newAssertion]),
+                new Token('('),
+            ]);
+        }
+    }
+}

package/vendor/friendsofphp/php-cs-fixer/src/Fixer/PhpUnit/PhpUnitExpectationFixer.php

@@ -0,0 +1,289 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of PHP CS Fixer.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *     Dariusz Rumiński <dariusz.ruminski@gmail.com>
+ *
+ * This source file is subject to the MIT license that is bundled
+ * with this source code in the file LICENSE.
+ */
+
+namespace PhpCsFixer\Fixer\PhpUnit;
+
+use PhpCsFixer\Fixer\AbstractPhpUnitFixer;
+use PhpCsFixer\Fixer\ConfigurableFixerInterface;
+use PhpCsFixer\Fixer\ConfigurableFixerTrait;
+use PhpCsFixer\Fixer\WhitespacesAwareFixerInterface;
+use PhpCsFixer\FixerConfiguration\FixerConfigurationResolver;
+use PhpCsFixer\FixerConfiguration\FixerConfigurationResolverInterface;
+use PhpCsFixer\FixerConfiguration\FixerOptionBuilder;
+use PhpCsFixer\FixerDefinition\CodeSample;
+use PhpCsFixer\FixerDefinition\FixerDefinition;
+use PhpCsFixer\FixerDefinition\FixerDefinitionInterface;
+use PhpCsFixer\Tokenizer\Analyzer\ArgumentsAnalyzer;
+use PhpCsFixer\Tokenizer\Analyzer\WhitespacesAnalyzer;
+use PhpCsFixer\Tokenizer\Token;
+use PhpCsFixer\Tokenizer\Tokens;
+
+/**
+ * @author Dariusz Rumiński <dariusz.ruminski@gmail.com>
+ *
+ * @implements ConfigurableFixerInterface<_AutogeneratedInputConfiguration, _AutogeneratedComputedConfiguration>
+ *
+ * @phpstan-type _AutogeneratedInputConfiguration array{
+ *  target?: '5.2'|'5.6'|'8.4'|'newest',
+ * }
+ * @phpstan-type _AutogeneratedComputedConfiguration array{
+ *  target: '5.2'|'5.6'|'8.4'|'newest',
+ * }
+ */
+final class PhpUnitExpectationFixer extends AbstractPhpUnitFixer implements ConfigurableFixerInterface, WhitespacesAwareFixerInterface
+{
+    /** @use ConfigurableFixerTrait<_AutogeneratedInputConfiguration, _AutogeneratedComputedConfiguration> */
+    use ConfigurableFixerTrait;
+
+    /**
+     * @var array<string, string>
+     */
+    private array $methodMap = [];
+
+    public function getDefinition(): FixerDefinitionInterface
+    {
+        return new FixerDefinition(
+            'Usages of `->setExpectedException*` methods MUST be replaced by `->expectException*` methods.',
+            [
+                new CodeSample(
+                    '<?php
+final class MyTest extends \PHPUnit_Framework_TestCase
+{
+    public function testFoo()
+    {
+        $this->setExpectedException("RuntimeException", "Msg", 123);
+        foo();
+    }
+
+    public function testBar()
+    {
+        $this->setExpectedExceptionRegExp("RuntimeException", "/Msg.*/", 123);
+        bar();
+    }
+}
+'
+                ),
+                new CodeSample(
+                    '<?php
+final class MyTest extends \PHPUnit_Framework_TestCase
+{
+    public function testFoo()
+    {
+        $this->setExpectedException("RuntimeException", null, 123);
+        foo();
+    }
+
+    public function testBar()
+    {
+        $this->setExpectedExceptionRegExp("RuntimeException", "/Msg.*/", 123);
+        bar();
+    }
+}
+',
+                    ['target' => PhpUnitTargetVersion::VERSION_8_4]
+                ),
+                new CodeSample(
+                    '<?php
+final class MyTest extends \PHPUnit_Framework_TestCase
+{
+    public function testFoo()
+    {
+        $this->setExpectedException("RuntimeException", null, 123);
+        foo();
+    }
+
+    public function testBar()
+    {
+        $this->setExpectedExceptionRegExp("RuntimeException", "/Msg.*/", 123);
+        bar();
+    }
+}
+',
+                    ['target' => PhpUnitTargetVersion::VERSION_5_6]
+                ),
+                new CodeSample(
+                    '<?php
+final class MyTest extends \PHPUnit_Framework_TestCase
+{
+    public function testFoo()
+    {
+        $this->setExpectedException("RuntimeException", "Msg", 123);
+        foo();
+    }
+
+    public function testBar()
+    {
+        $this->setExpectedExceptionRegExp("RuntimeException", "/Msg.*/", 123);
+        bar();
+    }
+}
+',
+                    ['target' => PhpUnitTargetVersion::VERSION_5_2]
+                ),
+            ],
+            null,
+            'Risky when PHPUnit classes are overridden or not accessible, or when project has PHPUnit incompatibilities.'
+        );
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * Must run after PhpUnitNoExpectationAnnotationFixer.
+     */
+    public function getPriority(): int
+    {
+        return 0;
+    }
+
+    public function isRisky(): bool
+    {
+        return true;
+    }
+
+    protected function configurePostNormalisation(): void
+    {
+        $this->methodMap = [
+            'setExpectedException' => 'expectExceptionMessage',
+        ];
+
+        if (PhpUnitTargetVersion::fulfills($this->configuration['target'], PhpUnitTargetVersion::VERSION_5_6)) {
+            $this->methodMap['setExpectedExceptionRegExp'] = 'expectExceptionMessageRegExp';
+        }
+
+        if (PhpUnitTargetVersion::fulfills($this->configuration['target'], PhpUnitTargetVersion::VERSION_8_4)) {
+            $this->methodMap['setExpectedExceptionRegExp'] = 'expectExceptionMessageMatches';
+            $this->methodMap['expectExceptionMessageRegExp'] = 'expectExceptionMessageMatches';
+        }
+    }
+
+    protected function createConfigurationDefinition(): FixerConfigurationResolverInterface
+    {
+        return new FixerConfigurationResolver([
+            (new FixerOptionBuilder('target', 'Target version of PHPUnit.'))
+                ->setAllowedTypes(['string'])
+                ->setAllowedValues([PhpUnitTargetVersion::VERSION_5_2, PhpUnitTargetVersion::VERSION_5_6, PhpUnitTargetVersion::VERSION_8_4, PhpUnitTargetVersion::VERSION_NEWEST])
+                ->setDefault(PhpUnitTargetVersion::VERSION_NEWEST)
+                ->getOption(),
+        ]);
+    }
+
+    protected function applyPhpUnitClassFix(Tokens $tokens, int $startIndex, int $endIndex): void
+    {
+        foreach (Token::getObjectOperatorKinds() as $objectOperator) {
+            $this->applyPhpUnitClassFixWithObjectOperator($tokens, $startIndex, $endIndex, $objectOperator);
+        }
+    }
+
+    private function applyPhpUnitClassFixWithObjectOperator(Tokens $tokens, int $startIndex, int $endIndex, int $objectOperator): void
+    {
+        $argumentsAnalyzer = new ArgumentsAnalyzer();
+
+        $oldMethodSequence = [
+            [T_VARIABLE, '$this'],
+            [$objectOperator],
+            [T_STRING],
+        ];
+
+        for ($index = $startIndex; $startIndex < $endIndex; ++$index) {
+            $match = $tokens->findSequence($oldMethodSequence, $index);
+
+            if (null === $match) {
+                return;
+            }
+
+            [$thisIndex, , $index] = array_keys($match);
+
+            if (!isset($this->methodMap[$tokens[$index]->getContent()])) {
+                continue;
+            }
+
+            $openIndex = $tokens->getNextTokenOfKind($index, ['(']);
+            $closeIndex = $tokens->findBlockEnd(Tokens::BLOCK_TYPE_PARENTHESIS_BRACE, $openIndex);
+            $commaIndex = $tokens->getPrevMeaningfulToken($closeIndex);
+            if ($tokens[$commaIndex]->equals(',')) {
+                $tokens->removeTrailingWhitespace($commaIndex);
+                $tokens->clearAt($commaIndex);
+            }
+
+            $arguments = $argumentsAnalyzer->getArguments($tokens, $openIndex, $closeIndex);
+            $argumentsCnt = \count($arguments);
+
+            $argumentsReplacements = ['expectException', $this->methodMap[$tokens[$index]->getContent()], 'expectExceptionCode'];
+
+            $indent = $this->whitespacesConfig->getLineEnding().WhitespacesAnalyzer::detectIndent($tokens, $thisIndex);
+
+            $isMultilineWhitespace = false;
+
+            for ($cnt = $argumentsCnt - 1; $cnt >= 1; --$cnt) {
+                $argStart = array_keys($arguments)[$cnt];
+                $argBefore = $tokens->getPrevMeaningfulToken($argStart);
+
+                if (!isset($argumentsReplacements[$cnt])) {
+                    throw new \LogicException(\sprintf('Unexpected index %d to find replacement method.', $cnt));
+                }
+
+                if ('expectExceptionMessage' === $argumentsReplacements[$cnt]) {
+                    $paramIndicatorIndex = $tokens->getNextMeaningfulToken($argBefore);
+                    $afterParamIndicatorIndex = $tokens->getNextMeaningfulToken($paramIndicatorIndex);
+
+                    if (
+                        $tokens[$paramIndicatorIndex]->equals([T_STRING, 'null'], false)
+                        && $tokens[$afterParamIndicatorIndex]->equals(')')
+                    ) {
+                        if ($tokens[$argBefore + 1]->isWhitespace()) {
+                            $tokens->clearTokenAndMergeSurroundingWhitespace($argBefore + 1);
+                        }
+                        $tokens->clearTokenAndMergeSurroundingWhitespace($argBefore);
+                        $tokens->clearTokenAndMergeSurroundingWhitespace($paramIndicatorIndex);
+
+                        continue;
+                    }
+                }
+
+                $isMultilineWhitespace = $isMultilineWhitespace || ($tokens[$argStart]->isWhitespace() && !$tokens[$argStart]->isWhitespace(" \t"));
+                $tokensOverrideArgStart = [
+                    new Token([T_WHITESPACE, $indent]),
+                    new Token([T_VARIABLE, '$this']),
+                    new Token([T_OBJECT_OPERATOR, '->']),
+                    new Token([T_STRING, $argumentsReplacements[$cnt]]),
+                    new Token('('),
+                ];
+                $tokensOverrideArgBefore = [
+                    new Token(')'),
+                    new Token(';'),
+                ];
+
+                if ($isMultilineWhitespace) {
+                    $tokensOverrideArgStart[] = new Token([T_WHITESPACE, $indent.$this->whitespacesConfig->getIndent()]);
+                    array_unshift($tokensOverrideArgBefore, new Token([T_WHITESPACE, $indent]));
+                }
+
+                if ($tokens[$argStart]->isWhitespace()) {
+                    $tokens->overrideRange($argStart, $argStart, $tokensOverrideArgStart);
+                } else {
+                    $tokens->insertAt($argStart, $tokensOverrideArgStart);
+                }
+
+                $tokens->overrideRange($argBefore, $argBefore, $tokensOverrideArgBefore);
+            }
+
+            $methodName = 'expectException';
+            if ('expectExceptionMessageRegExp' === $tokens[$index]->getContent()) {
+                $methodName = $this->methodMap[$tokens[$index]->getContent()];
+            }
+            $tokens[$index] = new Token([T_STRING, $methodName]);
+        }
+    }
+}

package/vendor/friendsofphp/php-cs-fixer/src/Fixer/PhpUnit/PhpUnitFqcnAnnotationFixer.php

@@ -0,0 +1,86 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of PHP CS Fixer.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *     Dariusz Rumiński <dariusz.ruminski@gmail.com>
+ *
+ * This source file is subject to the MIT license that is bundled
+ * with this source code in the file LICENSE.
+ */
+
+namespace PhpCsFixer\Fixer\PhpUnit;
+
+use PhpCsFixer\Fixer\AbstractPhpUnitFixer;
+use PhpCsFixer\FixerDefinition\CodeSample;
+use PhpCsFixer\FixerDefinition\FixerDefinition;
+use PhpCsFixer\FixerDefinition\FixerDefinitionInterface;
+use PhpCsFixer\Preg;
+use PhpCsFixer\Tokenizer\Token;
+use PhpCsFixer\Tokenizer\Tokens;
+
+/**
+ * @author Roland Franssen <franssen.roland@gmail.com>
+ */
+final class PhpUnitFqcnAnnotationFixer extends AbstractPhpUnitFixer
+{
+    public function getDefinition(): FixerDefinitionInterface
+    {
+        return new FixerDefinition(
+            'PHPUnit annotations should be a FQCNs including a root namespace.',
+            [new CodeSample(
+                '<?php
+final class MyTest extends \PHPUnit_Framework_TestCase
+{
+    /**
+     * @expectedException InvalidArgumentException
+     * @covers Project\NameSpace\Something
+     * @coversDefaultClass Project\Default
+     * @uses Project\Test\Util
+     */
+    public function testSomeTest()
+    {
+    }
+}
+'
+            )]
+        );
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * Must run before NoUnusedImportsFixer, PhpdocOrderByValueFixer.
+     */
+    public function getPriority(): int
+    {
+        return -9;
+    }
+
+    protected function applyPhpUnitClassFix(Tokens $tokens, int $startIndex, int $endIndex): void
+    {
+        $prevDocCommentIndex = $tokens->getPrevTokenOfKind($startIndex, [[T_DOC_COMMENT]]);
+
+        if (null !== $prevDocCommentIndex) {
+            $startIndex = $prevDocCommentIndex;
+        }
+
+        $this->fixPhpUnitClass($tokens, $startIndex, $endIndex);
+    }
+
+    private function fixPhpUnitClass(Tokens $tokens, int $startIndex, int $endIndex): void
+    {
+        for ($index = $startIndex; $index < $endIndex; ++$index) {
+            if ($tokens[$index]->isGivenKind(T_DOC_COMMENT)) {
+                $tokens[$index] = new Token([T_DOC_COMMENT, Preg::replace(
+                    '~^(\s*\*\s*@(?:expectedException|covers|coversDefaultClass|uses)\h+)(?!(?:self|static)::)(\w.*)$~m',
+                    '$1\\\$2',
+                    $tokens[$index]->getContent()
+                )]);
+            }
+        }
+    }
+}

package/vendor/friendsofphp/php-cs-fixer/src/Fixer/PhpUnit/PhpUnitInternalClassFixer.php

@@ -0,0 +1,117 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of PHP CS Fixer.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *     Dariusz Rumiński <dariusz.ruminski@gmail.com>
+ *
+ * This source file is subject to the MIT license that is bundled
+ * with this source code in the file LICENSE.
+ */
+
+namespace PhpCsFixer\Fixer\PhpUnit;
+
+use PhpCsFixer\Fixer\AbstractPhpUnitFixer;
+use PhpCsFixer\Fixer\ConfigurableFixerInterface;
+use PhpCsFixer\Fixer\ConfigurableFixerTrait;
+use PhpCsFixer\Fixer\WhitespacesAwareFixerInterface;
+use PhpCsFixer\FixerConfiguration\AllowedValueSubset;
+use PhpCsFixer\FixerConfiguration\FixerConfigurationResolver;
+use PhpCsFixer\FixerConfiguration\FixerConfigurationResolverInterface;
+use PhpCsFixer\FixerConfiguration\FixerOptionBuilder;
+use PhpCsFixer\FixerDefinition\CodeSample;
+use PhpCsFixer\FixerDefinition\FixerDefinition;
+use PhpCsFixer\FixerDefinition\FixerDefinitionInterface;
+use PhpCsFixer\Tokenizer\Tokens;
+use PhpCsFixer\Tokenizer\TokensAnalyzer;
+
+/**
+ * @author Gert de Pagter <BackEndTea@gmail.com>
+ *
+ * @implements ConfigurableFixerInterface<_AutogeneratedInputConfiguration, _AutogeneratedComputedConfiguration>
+ *
+ * @phpstan-type _AutogeneratedInputConfiguration array{
+ *  types?: list<'abstract'|'final'|'normal'>,
+ * }
+ * @phpstan-type _AutogeneratedComputedConfiguration array{
+ *  types: list<'abstract'|'final'|'normal'>,
+ * }
+ */
+final class PhpUnitInternalClassFixer extends AbstractPhpUnitFixer implements WhitespacesAwareFixerInterface, ConfigurableFixerInterface
+{
+    /** @use ConfigurableFixerTrait<_AutogeneratedInputConfiguration, _AutogeneratedComputedConfiguration> */
+    use ConfigurableFixerTrait;
+
+    public function getDefinition(): FixerDefinitionInterface
+    {
+        return new FixerDefinition(
+            'All PHPUnit test classes should be marked as internal.',
+            [
+                new CodeSample("<?php\nclass MyTest extends TestCase {}\n"),
+                new CodeSample(
+                    "<?php\nclass MyTest extends TestCase {}\nfinal class FinalTest extends TestCase {}\nabstract class AbstractTest extends TestCase {}\n",
+                    ['types' => ['final']]
+                ),
+            ]
+        );
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * Must run before FinalInternalClassFixer, PhpdocSeparationFixer.
+     */
+    public function getPriority(): int
+    {
+        return 68;
+    }
+
+    protected function createConfigurationDefinition(): FixerConfigurationResolverInterface
+    {
+        $types = ['normal', 'final', 'abstract'];
+
+        return new FixerConfigurationResolver([
+            (new FixerOptionBuilder('types', 'What types of classes to mark as internal.'))
+                ->setAllowedValues([new AllowedValueSubset($types)])
+                ->setAllowedTypes(['string[]'])
+                ->setDefault(['normal', 'final'])
+                ->getOption(),
+        ]);
+    }
+
+    protected function applyPhpUnitClassFix(Tokens $tokens, int $startIndex, int $endIndex): void
+    {
+        $classIndex = $tokens->getPrevTokenOfKind($startIndex, [[T_CLASS]]);
+
+        if (!$this->isAllowedByConfiguration($tokens, $classIndex)) {
+            return;
+        }
+
+        $this->ensureIsDocBlockWithAnnotation(
+            $tokens,
+            $classIndex,
+            'internal',
+            ['internal'],
+            [],
+        );
+    }
+
+    private function isAllowedByConfiguration(Tokens $tokens, int $index): bool
+    {
+        $tokensAnalyzer = new TokensAnalyzer($tokens);
+        $modifiers = $tokensAnalyzer->getClassyModifiers($index);
+
+        if (isset($modifiers['final'])) {
+            return \in_array('final', $this->configuration['types'], true);
+        }
+
+        if (isset($modifiers['abstract'])) {
+            return \in_array('abstract', $this->configuration['types'], true);
+        }
+
+        return \in_array('normal', $this->configuration['types'], true);
+    }
+}