From d947375963dbabb05609b921e2be739ac1ec0f84 Mon Sep 17 00:00:00 2001 From: spiralbot Date: Fri, 10 Jan 2025 15:48:49 +0000 Subject: [PATCH] refactor: add typed on private property based on assigns (#1200) --- composer.json | 8 +- src/AbstractLocator.php | 2 +- src/Listener/CachedClassesLoader.php | 2 +- src/Listener/CachedEnumsLoader.php | 2 +- src/Listener/CachedInterfacesLoader.php | 2 +- tests/Attribute/TargetAttributeTest.php | 11 +-- tests/Attribute/TargetClassTest.php | 4 +- tests/Bootloader/TokenizerBootloaderTest.php | 10 +-- .../TokenizerListenerBootloaderTest.php | 10 +-- tests/ClassLocatorTest.php | 64 +++++++-------- tests/ConfigTest.php | 40 +++++----- tests/EnumLocatorTest.php | 38 ++++----- tests/InjectionsTest.php | 20 +---- tests/InterfaceLocatorTest.php | 22 +++--- tests/InvocationsTest.php | 78 +++++++++---------- tests/Listener/ClassLocatorByTargetTest.php | 4 +- tests/Listener/EnumLocatorByTargetTest.php | 4 +- .../Listener/InterfaceLocatorByTargetTest.php | 4 +- tests/Listener/ListenerInvokerTest.php | 2 +- tests/ReflectionFileTest.php | 48 ++++++------ tests/ScopedClassLocatorTest.php | 28 +++---- tests/ScopedEnumLocatorTest.php | 28 +++---- tests/ScopedInterfaceLocatorTest.php | 28 +++---- 23 files changed, 219 insertions(+), 240 deletions(-) diff --git a/composer.json b/composer.json index d5c3238..93e74b8 100644 --- a/composer.json +++ b/composer.json @@ -35,15 +35,15 @@ "require": { "php": ">=8.1", "ext-tokenizer": "*", - "spiral/core": "^3.14.9", - "spiral/logger": "^3.14.9", + "spiral/core": "^3.15", + "spiral/logger": "^3.15", "symfony/finder": "^5.3.7 || ^6.0 || ^7.0" }, "require-dev": { "mockery/mockery": "^1.6", "spiral/attributes": "^2.8|^3.0", - "spiral/boot": "^3.14.9", - "spiral/files": "^3.14.9", + "spiral/boot": "^3.15", + "spiral/files": "^3.15", "phpunit/phpunit": "^10.1", "vimeo/psalm": "^5.9" }, diff --git a/src/AbstractLocator.php b/src/AbstractLocator.php index 27b2dbb..8e5f15b 100644 --- a/src/AbstractLocator.php +++ b/src/AbstractLocator.php @@ -68,7 +68,7 @@ protected function availableReflections(): \Generator */ protected function classReflection(string $class): \ReflectionClass { - $loader = static function ($class) { + $loader = static function ($class): void { if ($class === LocatorException::class) { return; } diff --git a/src/Listener/CachedClassesLoader.php b/src/Listener/CachedClassesLoader.php index 7584d6b..782a61d 100644 --- a/src/Listener/CachedClassesLoader.php +++ b/src/Listener/CachedClassesLoader.php @@ -25,7 +25,7 @@ public function loadClasses(TokenizationListenerInterface $listener): bool return $this->doLoad( $listener, $this->locator->getClasses(...), - static fn (string $class) => new \ReflectionClass($class), + static fn (string $class): \ReflectionClass => new \ReflectionClass($class), ); } } diff --git a/src/Listener/CachedEnumsLoader.php b/src/Listener/CachedEnumsLoader.php index 4f92fda..0def233 100644 --- a/src/Listener/CachedEnumsLoader.php +++ b/src/Listener/CachedEnumsLoader.php @@ -27,7 +27,7 @@ public function loadEnums(TokenizationListenerInterface $listener): bool return $this->doLoad( $listener, $this->locator->getEnums(...), - static fn (string $enum) => new \ReflectionEnum($enum), + static fn (string $enum): \ReflectionEnum => new \ReflectionEnum($enum), ); } } diff --git a/src/Listener/CachedInterfacesLoader.php b/src/Listener/CachedInterfacesLoader.php index 957b1ec..b89574d 100644 --- a/src/Listener/CachedInterfacesLoader.php +++ b/src/Listener/CachedInterfacesLoader.php @@ -27,7 +27,7 @@ public function loadInterfaces(TokenizationListenerInterface $listener): bool return $this->doLoad( $listener, $this->locator->getInterfaces(...), - static fn (string $class) => new \ReflectionClass($class), + static fn (string $class): \ReflectionClass => new \ReflectionClass($class), ); } } diff --git a/tests/Attribute/TargetAttributeTest.php b/tests/Attribute/TargetAttributeTest.php index 74ceb85..a078777 100644 --- a/tests/Attribute/TargetAttributeTest.php +++ b/tests/Attribute/TargetAttributeTest.php @@ -20,16 +20,16 @@ final class TargetAttributeTest extends TestCase public function testToString(): void { $attribute = new TargetAttribute('foo'); - $this->assertSame('3dc18b19eed74479a03c069dec2e8724', (string) $attribute); + self::assertSame('3dc18b19eed74479a03c069dec2e8724', (string) $attribute); $attribute = new TargetAttribute('foo', 'bar'); - $this->assertSame('52ec767c53f3898bf6de6f6e88125dc8', (string) $attribute); + self::assertSame('52ec767c53f3898bf6de6f6e88125dc8', (string) $attribute); } public function testFilterAttrWithArgs(): void { $attribute = new TargetAttribute(attribute: WithTargetClassWithArgs::class); - $this->assertEquals([ + self::assertSame([ ClassWithAttributeWithArgsOnClass::class, ], \iterator_to_array($attribute->filter([new \ReflectionClass(ClassWithAttributeWithArgsOnClass::class)]))); } @@ -53,10 +53,7 @@ public function testFilter( $result = \iterator_to_array($attribute->filter([new \ReflectionClass($class)])); - $this->assertEquals( - $found ? [$class] : [], - $result, - ); + self::assertEquals($found ? [$class] : [], $result); } public static function filterDataProvider(): iterable diff --git a/tests/Attribute/TargetClassTest.php b/tests/Attribute/TargetClassTest.php index ebd824f..06c001f 100644 --- a/tests/Attribute/TargetClassTest.php +++ b/tests/Attribute/TargetClassTest.php @@ -12,9 +12,9 @@ final class TargetClassTest extends TestCase public function testToString(): void { $attribute = new TargetClass('foo'); - $this->assertSame('3319d33aad20ad375d27dcd03c879454', (string) $attribute); + self::assertSame('3319d33aad20ad375d27dcd03c879454', (string) $attribute); $attribute = new TargetClass('foo', 'bar'); - $this->assertSame('a95c8a2cfc901290939df93183ce98d6', (string) $attribute); + self::assertSame('a95c8a2cfc901290939df93183ce98d6', (string) $attribute); } } \ No newline at end of file diff --git a/tests/Bootloader/TokenizerBootloaderTest.php b/tests/Bootloader/TokenizerBootloaderTest.php index 37bfe09..150be0a 100644 --- a/tests/Bootloader/TokenizerBootloaderTest.php +++ b/tests/Bootloader/TokenizerBootloaderTest.php @@ -39,8 +39,8 @@ public function testCastingReadCacheEnvVariable(mixed $readCache, bool $expected $initConfig = $config->getConfig(TokenizerConfig::CONFIG); - $this->assertSame('runtime/cache/listeners', $initConfig['cache']['directory']); - $this->assertSame($expected, $initConfig['cache']['enabled']); + self::assertSame('runtime/cache/listeners', $initConfig['cache']['directory']); + self::assertSame($expected, $initConfig['cache']['enabled']); } #[DataProvider('boolValuesDataProvider')] @@ -62,7 +62,7 @@ public function testCastingLoadClassesEnvVariable(mixed $classes, bool $expected $bootloader = new TokenizerBootloader($config = new ConfigManager(new DirectoryLoader('config'))); $bootloader->init(m::spy(BinderInterface::class), $dirs, $env); - $this->assertSame($expected, $config->getConfig(TokenizerConfig::CONFIG)['load']['classes']); + self::assertSame($expected, $config->getConfig(TokenizerConfig::CONFIG)['load']['classes']); } #[DataProvider('boolValuesDataProvider')] @@ -84,7 +84,7 @@ public function testCastingLoadEnumsEnvVariable(mixed $enums, bool $expected): v $bootloader = new TokenizerBootloader($config = new ConfigManager(new DirectoryLoader('config'))); $bootloader->init(m::spy(BinderInterface::class), $dirs, $env); - $this->assertSame($expected, $config->getConfig(TokenizerConfig::CONFIG)['load']['enums']); + self::assertSame($expected, $config->getConfig(TokenizerConfig::CONFIG)['load']['enums']); } #[DataProvider('boolValuesDataProvider')] @@ -106,7 +106,7 @@ public function testCastingLoadInterfacesEnvVariable(mixed $interfaces, bool $ex $bootloader = new TokenizerBootloader($config = new ConfigManager(new DirectoryLoader('config'))); $bootloader->init(m::spy(BinderInterface::class), $dirs, $env); - $this->assertSame($expected, $config->getConfig(TokenizerConfig::CONFIG)['load']['interfaces']); + self::assertSame($expected, $config->getConfig(TokenizerConfig::CONFIG)['load']['interfaces']); } public static function boolValuesDataProvider(): \Traversable diff --git a/tests/Bootloader/TokenizerListenerBootloaderTest.php b/tests/Bootloader/TokenizerListenerBootloaderTest.php index 494d561..fb71697 100644 --- a/tests/Bootloader/TokenizerListenerBootloaderTest.php +++ b/tests/Bootloader/TokenizerListenerBootloaderTest.php @@ -47,10 +47,7 @@ public function testEnableCacheListenersThroughConfig(string $class, string $int $config = new TokenizerConfig(['cache' => ['directory' => 'cache', 'enabled' => true]]); - $this->assertSame( - $loader, - $bootloader->{$method}($factory, $config), - ); + self::assertSame($loader, $bootloader->{$method}($factory, $config)); } public function testAddDirectoryInBootloaderInit(): void @@ -60,10 +57,7 @@ public function testAddDirectoryInBootloaderInit(): void $kernel = TestCoreWithTokenizer::create(directories: ['root' => __DIR__], container: $container); $kernel->run(); - $this->assertTrue(\in_array( - \dirname(__DIR__) . '/Fixtures/Bootloader', - $container->get(TokenizerConfig::class)->getDirectories() - )); + self::assertContains(\dirname(__DIR__) . '/Fixtures/Bootloader', $container->get(TokenizerConfig::class)->getDirectories()); } } diff --git a/tests/ClassLocatorTest.php b/tests/ClassLocatorTest.php index e6c7717..f4cb0dc 100644 --- a/tests/ClassLocatorTest.php +++ b/tests/ClassLocatorTest.php @@ -20,15 +20,15 @@ public function testClassesAll(): void //Direct loading $classes = $tokenizer->classLocator()->getClasses(); - $this->assertArrayHasKey(self::class, $classes); - $this->assertArrayHasKey(ClassA::class, $classes); - $this->assertArrayHasKey(ClassB::class, $classes); - $this->assertArrayHasKey(ClassC::class, $classes); - $this->assertArrayHasKey(ClassD::class, $classes); + self::assertArrayHasKey(self::class, $classes); + self::assertArrayHasKey(ClassA::class, $classes); + self::assertArrayHasKey(ClassB::class, $classes); + self::assertArrayHasKey(ClassC::class, $classes); + self::assertArrayHasKey(ClassD::class, $classes); //Excluded - $this->assertArrayNotHasKey(\Spiral\Tests\Tokenizer\Classes\Excluded\ClassXX::class, $classes); - $this->assertArrayNotHasKey('Spiral\Tests\Tokenizer\Classes\Bad_Class', $classes); + self::assertArrayNotHasKey(\Spiral\Tests\Tokenizer\Classes\Excluded\ClassXX::class, $classes); + self::assertArrayNotHasKey('Spiral\Tests\Tokenizer\Classes\Bad_Class', $classes); } public function testClassesByClass(): void @@ -38,12 +38,12 @@ public function testClassesByClass(): void //By namespace $classes = $tokenizer->classLocator()->getClasses(ClassD::class); - $this->assertArrayHasKey(ClassD::class, $classes); + self::assertArrayHasKey(ClassD::class, $classes); - $this->assertArrayNotHasKey(self::class, $classes); - $this->assertArrayNotHasKey(ClassA::class, $classes); - $this->assertArrayNotHasKey(ClassB::class, $classes); - $this->assertArrayNotHasKey(ClassC::class, $classes); + self::assertArrayNotHasKey(self::class, $classes); + self::assertArrayNotHasKey(ClassA::class, $classes); + self::assertArrayNotHasKey(ClassB::class, $classes); + self::assertArrayNotHasKey(ClassC::class, $classes); } public function testClassesByInterface(): void @@ -53,12 +53,12 @@ public function testClassesByInterface(): void //By interface $classes = $tokenizer->classLocator()->getClasses(TestInterface::class); - $this->assertArrayHasKey(ClassB::class, $classes); - $this->assertArrayHasKey(ClassC::class, $classes); + self::assertArrayHasKey(ClassB::class, $classes); + self::assertArrayHasKey(ClassC::class, $classes); - $this->assertArrayNotHasKey(self::class, $classes); - $this->assertArrayNotHasKey(ClassA::class, $classes); - $this->assertArrayNotHasKey(ClassD::class, $classes); + self::assertArrayNotHasKey(self::class, $classes); + self::assertArrayNotHasKey(ClassA::class, $classes); + self::assertArrayNotHasKey(ClassD::class, $classes); } public function testClassesByTrait(): void @@ -68,12 +68,12 @@ public function testClassesByTrait(): void //By trait $classes = $tokenizer->classLocator()->getClasses(TestTrait::class); - $this->assertArrayHasKey(ClassB::class, $classes); - $this->assertArrayHasKey(ClassC::class, $classes); + self::assertArrayHasKey(ClassB::class, $classes); + self::assertArrayHasKey(ClassC::class, $classes); - $this->assertArrayNotHasKey(self::class, $classes); - $this->assertArrayNotHasKey(ClassA::class, $classes); - $this->assertArrayNotHasKey(ClassD::class, $classes); + self::assertArrayNotHasKey(self::class, $classes); + self::assertArrayNotHasKey(ClassA::class, $classes); + self::assertArrayNotHasKey(ClassD::class, $classes); } public function testClassesByClassA(): void @@ -83,12 +83,12 @@ public function testClassesByClassA(): void //By class $classes = $tokenizer->classLocator()->getClasses(ClassA::class); - $this->assertArrayHasKey(ClassA::class, $classes); - $this->assertArrayHasKey(ClassB::class, $classes); - $this->assertArrayHasKey(ClassC::class, $classes); - $this->assertArrayHasKey(ClassD::class, $classes); + self::assertArrayHasKey(ClassA::class, $classes); + self::assertArrayHasKey(ClassB::class, $classes); + self::assertArrayHasKey(ClassC::class, $classes); + self::assertArrayHasKey(ClassD::class, $classes); - $this->assertArrayNotHasKey(self::class, $classes); + self::assertArrayNotHasKey(self::class, $classes); } public function testClassesByClassB(): void @@ -96,11 +96,11 @@ public function testClassesByClassB(): void $tokenizer = $this->getTokenizer(); $classes = $tokenizer->classLocator()->getClasses(ClassB::class); - $this->assertArrayHasKey(ClassB::class, $classes); - $this->assertArrayHasKey(ClassC::class, $classes); + self::assertArrayHasKey(ClassB::class, $classes); + self::assertArrayHasKey(ClassC::class, $classes); - $this->assertArrayNotHasKey(self::class, $classes); - $this->assertArrayNotHasKey(ClassA::class, $classes); - $this->assertArrayNotHasKey(ClassD::class, $classes); + self::assertArrayNotHasKey(self::class, $classes); + self::assertArrayNotHasKey(ClassA::class, $classes); + self::assertArrayNotHasKey(ClassD::class, $classes); } } diff --git a/tests/ConfigTest.php b/tests/ConfigTest.php index 4331dca..9b84ac3 100644 --- a/tests/ConfigTest.php +++ b/tests/ConfigTest.php @@ -11,19 +11,19 @@ public function testDebugNotSet(): void { $config = new TokenizerConfig([]); - $this->assertFalse($config->isDebug()); + self::assertFalse($config->isDebug()); } public function testDebug(): void { $config = new TokenizerConfig(['debug' => false]); - $this->assertFalse($config->isDebug()); + self::assertFalse($config->isDebug()); $config = new TokenizerConfig(['debug' => true]); - $this->assertTrue($config->isDebug()); + self::assertTrue($config->isDebug()); $config = new TokenizerConfig(['debug' => 1]); - $this->assertTrue($config->isDebug()); + self::assertTrue($config->isDebug()); } public function testDirectories(): void @@ -31,7 +31,7 @@ public function testDirectories(): void $config = new TokenizerConfig([ 'directories' => ['a', 'b', 'c'], ]); - $this->assertSame(['a', 'b', 'c'], $config->getDirectories()); + self::assertSame(['a', 'b', 'c'], $config->getDirectories()); } public function testExcluded(): void @@ -39,7 +39,7 @@ public function testExcluded(): void $config = new TokenizerConfig([ 'exclude' => ['a', 'b', 'c'], ]); - $this->assertSame(['a', 'b', 'c'], $config->getExcludes()); + self::assertSame(['a', 'b', 'c'], $config->getExcludes()); } public function testNonExistScopeShouldReturnDefaultDirectories(): void @@ -55,7 +55,7 @@ public function testNonExistScopeShouldReturnDefaultDirectories(): void ], ]); - $this->assertSame([ + self::assertSame([ 'directories' => ['a'], 'exclude' => ['b'], ], $config->getScope('bar')); @@ -80,17 +80,17 @@ public function testExistsScopeShouldReturnDirectoriesFromIt(): void ], ]); - $this->assertSame([ + self::assertSame([ 'directories' => ['c'], 'exclude' => ['d'], ], $config->getScope('foo')); - $this->assertSame([ + self::assertSame([ 'directories' => ['c'], 'exclude' => ['b'], ], $config->getScope('bar')); - $this->assertSame([ + self::assertSame([ 'directories' => ['a'], 'exclude' => ['d'], ], $config->getScope('baz')); @@ -99,7 +99,7 @@ public function testExistsScopeShouldReturnDirectoriesFromIt(): void public function testGetsCacheDirectory(): void { $config = new TokenizerConfig(); - $this->assertNull($config->getCacheDirectory()); + self::assertNull($config->getCacheDirectory()); $config = new TokenizerConfig([ 'cache' => [ @@ -107,58 +107,58 @@ public function testGetsCacheDirectory(): void ], ]); - $this->assertSame('foo', $config->getCacheDirectory()); + self::assertSame('foo', $config->getCacheDirectory()); } public function testCacheEnabled(): void { $config = new TokenizerConfig(); - $this->assertFalse($config->isCacheEnabled()); + self::assertFalse($config->isCacheEnabled()); $config = new TokenizerConfig([ 'cache' => [ 'enabled' => true, ], ]); - $this->assertTrue($config->isCacheEnabled()); + self::assertTrue($config->isCacheEnabled()); } public function testLoadClassesEnabled(): void { $config = new TokenizerConfig(); - $this->assertTrue($config->isLoadClassesEnabled()); // by default + self::assertTrue($config->isLoadClassesEnabled()); // by default $config = new TokenizerConfig([ 'load' => [ 'classes' => false, ], ]); - $this->assertFalse($config->isLoadClassesEnabled()); + self::assertFalse($config->isLoadClassesEnabled()); } public function testLoadEnumsEnabled(): void { $config = new TokenizerConfig(); - $this->assertFalse($config->isLoadEnumsEnabled()); // by default + self::assertFalse($config->isLoadEnumsEnabled()); // by default $config = new TokenizerConfig([ 'load' => [ 'enums' => true, ], ]); - $this->assertTrue($config->isLoadEnumsEnabled()); + self::assertTrue($config->isLoadEnumsEnabled()); } public function testLoadInterfacesEnabled(): void { $config = new TokenizerConfig(); - $this->assertFalse($config->isLoadInterfacesEnabled()); // by default + self::assertFalse($config->isLoadInterfacesEnabled()); // by default $config = new TokenizerConfig([ 'load' => [ 'interfaces' => true, ], ]); - $this->assertTrue($config->isLoadInterfacesEnabled()); + self::assertTrue($config->isLoadInterfacesEnabled()); } } diff --git a/tests/EnumLocatorTest.php b/tests/EnumLocatorTest.php index 9b317e2..da91b8b 100644 --- a/tests/EnumLocatorTest.php +++ b/tests/EnumLocatorTest.php @@ -22,15 +22,15 @@ public function testEnumsAll(): void //Direct loading $enums = $tokenizer->enumLocator()->getEnums(); - $this->assertArrayHasKey(EnumA::class, $enums); - $this->assertArrayHasKey(EnumB::class, $enums); - $this->assertArrayHasKey(EnumC::class, $enums); - $this->assertArrayHasKey(EnumD::class, $enums); + self::assertArrayHasKey(EnumA::class, $enums); + self::assertArrayHasKey(EnumB::class, $enums); + self::assertArrayHasKey(EnumC::class, $enums); + self::assertArrayHasKey(EnumD::class, $enums); //Excluded - $this->assertArrayNotHasKey(EnumXX::class, $enums); - $this->assertArrayNotHasKey(BadEnum::class, $enums); - $this->assertArrayNotHasKey('Spiral\Tests\Tokenizer\Enums\Bad_Enum', $enums); + self::assertArrayNotHasKey(EnumXX::class, $enums); + self::assertArrayNotHasKey(BadEnum::class, $enums); + self::assertArrayNotHasKey('Spiral\Tests\Tokenizer\Enums\Bad_Enum', $enums); } public function testEnumsByEnum(): void @@ -40,11 +40,11 @@ public function testEnumsByEnum(): void //By namespace $enums = $tokenizer->enumLocator()->getEnums(EnumD::class); - $this->assertArrayHasKey(EnumD::class, $enums); + self::assertArrayHasKey(EnumD::class, $enums); - $this->assertArrayNotHasKey(EnumA::class, $enums); - $this->assertArrayNotHasKey(EnumB::class, $enums); - $this->assertArrayNotHasKey(EnumC::class, $enums); + self::assertArrayNotHasKey(EnumA::class, $enums); + self::assertArrayNotHasKey(EnumB::class, $enums); + self::assertArrayNotHasKey(EnumC::class, $enums); } public function testEnumsByInterface(): void @@ -54,11 +54,11 @@ public function testEnumsByInterface(): void //By interface $enums = $tokenizer->enumLocator()->getEnums(TestInterface::class); - $this->assertArrayHasKey(EnumB::class, $enums); - $this->assertArrayHasKey(EnumC::class, $enums); + self::assertArrayHasKey(EnumB::class, $enums); + self::assertArrayHasKey(EnumC::class, $enums); - $this->assertArrayNotHasKey(EnumA::class, $enums); - $this->assertArrayNotHasKey(EnumD::class, $enums); + self::assertArrayNotHasKey(EnumA::class, $enums); + self::assertArrayNotHasKey(EnumD::class, $enums); } public function testEnumsByTrait(): void @@ -68,10 +68,10 @@ public function testEnumsByTrait(): void //By trait $enums = $tokenizer->enumLocator()->getEnums(TestTrait::class); - $this->assertArrayHasKey(EnumB::class, $enums); - $this->assertArrayHasKey(EnumC::class, $enums); + self::assertArrayHasKey(EnumB::class, $enums); + self::assertArrayHasKey(EnumC::class, $enums); - $this->assertArrayNotHasKey(EnumA::class, $enums); - $this->assertArrayNotHasKey(EnumD::class, $enums); + self::assertArrayNotHasKey(EnumA::class, $enums); + self::assertArrayNotHasKey(EnumD::class, $enums); } } diff --git a/tests/InjectionsTest.php b/tests/InjectionsTest.php index b0ed128..0634ecb 100644 --- a/tests/InjectionsTest.php +++ b/tests/InjectionsTest.php @@ -26,10 +26,7 @@ public function testClassLocator(): void $container->bindSingleton(ClassesInterface::class, ClassLocator::class); - $this->assertInstanceOf( - ClassLocator::class, - $container->get(ClassesInterface::class) - ); + self::assertInstanceOf(ClassLocator::class, $container->get(ClassesInterface::class)); } public function testInvocationsLocator(): void @@ -42,10 +39,7 @@ public function testInvocationsLocator(): void $container->bindSingleton(InvocationsInterface::class, InvocationLocator::class); - $this->assertInstanceOf( - InvocationLocator::class, - $container->get(InvocationsInterface::class) - ); + self::assertInstanceOf(InvocationLocator::class, $container->get(InvocationsInterface::class)); } public function testEnumsLocator(): void @@ -58,10 +52,7 @@ public function testEnumsLocator(): void $container->bindSingleton(EnumsInterface::class, EnumLocator::class); - $this->assertInstanceOf( - EnumLocator::class, - $container->get(EnumsInterface::class) - ); + self::assertInstanceOf(EnumLocator::class, $container->get(EnumsInterface::class)); } public function testInterfacesLocator(): void @@ -74,9 +65,6 @@ public function testInterfacesLocator(): void $container->bindSingleton(InterfacesInterface::class, InterfaceLocator::class); - $this->assertInstanceOf( - InterfaceLocator::class, - $container->get(InterfacesInterface::class) - ); + self::assertInstanceOf(InterfaceLocator::class, $container->get(InterfacesInterface::class)); } } diff --git a/tests/InterfaceLocatorTest.php b/tests/InterfaceLocatorTest.php index 846447b..45690ad 100644 --- a/tests/InterfaceLocatorTest.php +++ b/tests/InterfaceLocatorTest.php @@ -20,15 +20,15 @@ public function testInterfacesAll(): void //Direct loading $classes = $tokenizer->interfaceLocator()->getInterfaces(); - $this->assertArrayHasKey(InterfaceA::class, $classes); - $this->assertArrayHasKey(InterfaceB::class, $classes); - $this->assertArrayHasKey(InterfaceC::class, $classes); - $this->assertArrayHasKey(InterfaceD::class, $classes); + self::assertArrayHasKey(InterfaceA::class, $classes); + self::assertArrayHasKey(InterfaceB::class, $classes); + self::assertArrayHasKey(InterfaceC::class, $classes); + self::assertArrayHasKey(InterfaceD::class, $classes); //Excluded - $this->assertArrayNotHasKey(InterfaceXX::class, $classes); - $this->assertArrayNotHasKey(BadInterface::class, $classes); - $this->assertArrayNotHasKey('Spiral\Tests\Tokenizer\Interfaces\Bad_Interface', $classes); + self::assertArrayNotHasKey(InterfaceXX::class, $classes); + self::assertArrayNotHasKey(BadInterface::class, $classes); + self::assertArrayNotHasKey('Spiral\Tests\Tokenizer\Interfaces\Bad_Interface', $classes); } @@ -39,10 +39,10 @@ public function testInterfacesByInterface(): void //By interface $classes = $tokenizer->interfaceLocator()->getInterfaces(TestInterface::class); - $this->assertArrayHasKey(InterfaceB::class, $classes); - $this->assertArrayHasKey(InterfaceC::class, $classes); + self::assertArrayHasKey(InterfaceB::class, $classes); + self::assertArrayHasKey(InterfaceC::class, $classes); - $this->assertArrayNotHasKey(InterfaceA::class, $classes); - $this->assertArrayNotHasKey(InterfaceD::class, $classes); + self::assertArrayNotHasKey(InterfaceA::class, $classes); + self::assertArrayNotHasKey(InterfaceD::class, $classes); } } diff --git a/tests/InvocationsTest.php b/tests/InvocationsTest.php index 914dc80..53bc606 100644 --- a/tests/InvocationsTest.php +++ b/tests/InvocationsTest.php @@ -19,152 +19,152 @@ protected function someFunction() public function testInstance(): void { $invocations = $this->getInvocations(); - $this->assertCount(2, $invocations); + self::assertCount(2, $invocations); $invocation1 = $invocations[0]; $invocation2 = $invocations[1]; - $this->assertInstanceOf(ReflectionInvocation::class, $invocation1); - $this->assertInstanceOf(ReflectionInvocation::class, $invocation2); + self::assertInstanceOf(ReflectionInvocation::class, $invocation1); + self::assertInstanceOf(ReflectionInvocation::class, $invocation2); } public function testClass(): void { $invocations = $this->getInvocations(); - $this->assertCount(2, $invocations); + self::assertCount(2, $invocations); $invocation1 = $invocations[0]; $invocation2 = $invocations[1]; - $this->assertSame(self::class, $invocation1->getClass()); - $this->assertSame(self::class, $invocation2->getClass()); + self::assertSame(self::class, $invocation1->getClass()); + self::assertSame(self::class, $invocation2->getClass()); } public function testName(): void { $invocations = $this->getInvocations(); - $this->assertCount(2, $invocations); + self::assertCount(2, $invocations); $invocation1 = $invocations[0]; $invocation2 = $invocations[1]; - $this->assertSame('sampleMethod', $invocation1->getName()); - $this->assertSame('sampleMethod', $invocation2->getName()); + self::assertSame('sampleMethod', $invocation1->getName()); + self::assertSame('sampleMethod', $invocation2->getName()); } public function testFilename(): void { $invocations = $this->getInvocations(); - $this->assertCount(2, $invocations); + self::assertCount(2, $invocations); $invocation1 = $invocations[0]; $invocation2 = $invocations[1]; - $this->assertSame(str_replace('\\', '/', __FILE__), $invocation1->getFilename()); - $this->assertSame(str_replace('\\', '/', __FILE__), $invocation2->getFilename()); + self::assertSame(str_replace('\\', '/', __FILE__), $invocation1->getFilename()); + self::assertSame(str_replace('\\', '/', __FILE__), $invocation2->getFilename()); } public function testLine(): void { $invocations = $this->getInvocations(); - $this->assertCount(2, $invocations); + self::assertCount(2, $invocations); $invocation1 = $invocations[0]; $invocation2 = $invocations[1]; - $this->assertSame(15, $invocation1->getLine()); - $this->assertSame(16, $invocation2->getLine()); + self::assertSame(15, $invocation1->getLine()); + self::assertSame(16, $invocation2->getLine()); } public function testLevel(): void { $invocations = $this->getInvocations(); - $this->assertCount(2, $invocations); + self::assertCount(2, $invocations); $invocation1 = $invocations[0]; $invocation2 = $invocations[1]; - $this->assertSame(0, $invocation1->getLevel()); - $this->assertSame(1, $invocation2->getLevel()); + self::assertSame(0, $invocation1->getLevel()); + self::assertSame(1, $invocation2->getLevel()); } public function testOperator(): void { $invocations = $this->getInvocations(); - $this->assertCount(2, $invocations); + self::assertCount(2, $invocations); $invocation1 = $invocations[0]; $invocation2 = $invocations[1]; - $this->assertSame('->', $invocation1->getOperator()); - $this->assertSame('::', $invocation2->getOperator()); + self::assertSame('->', $invocation1->getOperator()); + self::assertSame('::', $invocation2->getOperator()); } public function testIsMethod(): void { $invocations = $this->getInvocations(); - $this->assertCount(2, $invocations); + self::assertCount(2, $invocations); $invocation1 = $invocations[0]; $invocation2 = $invocations[1]; - $this->assertTrue($invocation1->isMethod()); - $this->assertTrue($invocation2->isMethod()); + self::assertTrue($invocation1->isMethod()); + self::assertTrue($invocation2->isMethod()); } public function testCountArguments(): void { $invocations = $this->getInvocations(); - $this->assertCount(2, $invocations); + self::assertCount(2, $invocations); $invocation1 = $invocations[0]; $invocation2 = $invocations[1]; - $this->assertSame(1, $invocation1->countArguments()); - $this->assertSame(1, $invocation2->countArguments()); + self::assertSame(1, $invocation1->countArguments()); + self::assertSame(1, $invocation2->countArguments()); } public function testSimpleArgument(): void { $invocations = $this->getInvocations(); - $this->assertCount(2, $invocations); + self::assertCount(2, $invocations); $invocation1 = $invocations[0]; $argument = $invocation1->getArgument(0); - $this->assertInstanceOf(ReflectionArgument::class, $argument); + self::assertInstanceOf(ReflectionArgument::class, $argument); - $this->assertSame(ReflectionArgument::STRING, $argument->getType()); - $this->assertSame("'hello world'", $argument->getValue()); - $this->assertSame("hello world", $argument->stringValue()); + self::assertSame(ReflectionArgument::STRING, $argument->getType()); + self::assertSame("'hello world'", $argument->getValue()); + self::assertSame("hello world", $argument->stringValue()); } public function testVariableArgument(): void { $invocations = $this->getInvocations(); - $this->assertCount(2, $invocations); + self::assertCount(2, $invocations); $invocation2 = $invocations[1]; $argument = $invocation2->getArgument(0); - $this->assertInstanceOf(ReflectionArgument::class, $argument); + self::assertInstanceOf(ReflectionArgument::class, $argument); - $this->assertSame(ReflectionArgument::EXPRESSION, $argument->getType()); - $this->assertSame('$result.\'plus\'', $argument->getValue()); + self::assertSame(ReflectionArgument::EXPRESSION, $argument->getType()); + self::assertSame('$result.\'plus\'', $argument->getValue()); } public function testSource(): void { $invocations = $this->getInvocations(); - $this->assertCount(2, $invocations); + self::assertCount(2, $invocations); $invocation1 = $invocations[0]; $invocation2 = $invocations[1]; - $this->assertSame('$this->sampleMethod(\'hello world\')', $invocation1->getSource()); - $this->assertSame('self::sampleMethod($result . \'plus\')', $invocation2->getSource()); + self::assertSame('$this->sampleMethod(\'hello world\')', $invocation1->getSource()); + self::assertSame('self::sampleMethod($result . \'plus\')', $invocation2->getSource()); } protected static function sampleMethod(string $string) diff --git a/tests/Listener/ClassLocatorByTargetTest.php b/tests/Listener/ClassLocatorByTargetTest.php index da6d5a6..cbaf509 100644 --- a/tests/Listener/ClassLocatorByTargetTest.php +++ b/tests/Listener/ClassLocatorByTargetTest.php @@ -90,7 +90,7 @@ public function testGetClasses( array $expected, ): void { $classes = \array_map( - fn (string $class) => new \ReflectionClass($class), + fn (string $class): \ReflectionClass => new \ReflectionClass($class), [ Targets\ConsoleCommand::class, Targets\Filter::class, @@ -124,6 +124,6 @@ public function testGetClasses( $attribute ); - $this->assertSame($expected, $classes); + self::assertSame($expected, $classes); } } diff --git a/tests/Listener/EnumLocatorByTargetTest.php b/tests/Listener/EnumLocatorByTargetTest.php index 0d9b943..239e149 100644 --- a/tests/Listener/EnumLocatorByTargetTest.php +++ b/tests/Listener/EnumLocatorByTargetTest.php @@ -66,7 +66,7 @@ public function testGetEnums( array $expected, ): void { $enums = \array_map( - fn (string $class) => new \ReflectionEnum($class), + fn (string $class): \ReflectionEnum => new \ReflectionEnum($class), [ Targets\EnumWithAttributeOnClass::class, Targets\EnumWithAllTargets::class, @@ -94,6 +94,6 @@ public function testGetEnums( $attribute ); - $this->assertSame($expected, $enums); + self::assertSame($expected, $enums); } } diff --git a/tests/Listener/InterfaceLocatorByTargetTest.php b/tests/Listener/InterfaceLocatorByTargetTest.php index 3311273..5a66071 100644 --- a/tests/Listener/InterfaceLocatorByTargetTest.php +++ b/tests/Listener/InterfaceLocatorByTargetTest.php @@ -88,7 +88,7 @@ public function testGetEnums( array $expected, ): void { $interfaces = \array_map( - fn (string $class) => new \ReflectionClass($class), + fn (string $class): \ReflectionClass => new \ReflectionClass($class), [ Targets\InterfaceWithAllTargets::class, Targets\InterfaceWithAttributeOnClass::class, @@ -120,6 +120,6 @@ public function testGetEnums( $attribute ); - $this->assertSame($expected, $interfaces); + self::assertSame($expected, $interfaces); } } diff --git a/tests/Listener/ListenerInvokerTest.php b/tests/Listener/ListenerInvokerTest.php index 529817e..f1a339c 100644 --- a/tests/Listener/ListenerInvokerTest.php +++ b/tests/Listener/ListenerInvokerTest.php @@ -29,7 +29,7 @@ public function testInvoke(): void $invoker = new ListenerInvoker(); $classes = \array_map( - fn(string $class) => new \ReflectionClass($class), + fn(string $class): \ReflectionClass => new \ReflectionClass($class), [ Targets\ConsoleCommand::class, Targets\Filter::class, diff --git a/tests/ReflectionFileTest.php b/tests/ReflectionFileTest.php index 333ccb8..e69df4c 100644 --- a/tests/ReflectionFileTest.php +++ b/tests/ReflectionFileTest.php @@ -12,11 +12,11 @@ public function testReflection(): void { $reflection = new ReflectionFile(__FILE__); - $this->assertContains(self::class, $reflection->getClasses()); - $this->assertContains(TestTrait::class, $reflection->getTraits()); - $this->assertContains(TestInterface::class, $reflection->getInterfaces()); + self::assertContains(self::class, $reflection->getClasses()); + self::assertContains(TestTrait::class, $reflection->getTraits()); + self::assertContains(TestInterface::class, $reflection->getInterfaces()); - $this->assertSame([__NAMESPACE__ . '\hello'], $reflection->getFunctions()); + self::assertSame([__NAMESPACE__ . '\hello'], $reflection->getFunctions()); $functionA = null; $functionB = null; @@ -31,31 +31,31 @@ public function testReflection(): void } } - $this->assertNotEmpty($functionA); - $this->assertNotEmpty($functionB); + self::assertInstanceOf(\Spiral\Tokenizer\Reflection\ReflectionInvocation::class, $functionA); + self::assertInstanceOf(\Spiral\Tokenizer\Reflection\ReflectionInvocation::class, $functionB); - $this->assertSame(2, count($functionA->getArguments())); - $this->assertSame(ReflectionArgument::VARIABLE, $functionA->getArgument(0)->getType()); - $this->assertSame('$this', $functionA->getArgument(0)->getValue()); + self::assertCount(2, $functionA->getArguments()); + self::assertSame(ReflectionArgument::VARIABLE, $functionA->getArgument(0)->getType()); + self::assertSame('$this', $functionA->getArgument(0)->getValue()); - $this->assertSame(ReflectionArgument::EXPRESSION, $functionA->getArgument(1)->getType()); - $this->assertSame('$a+$b', $functionA->getArgument(1)->getValue()); + self::assertSame(ReflectionArgument::EXPRESSION, $functionA->getArgument(1)->getType()); + self::assertSame('$a+$b', $functionA->getArgument(1)->getValue()); - $this->assertSame(2, $functionB->countArguments()); + self::assertSame(2, $functionB->countArguments()); - $this->assertSame(ReflectionArgument::STRING, $functionB->getArgument(0)->getType()); - $this->assertSame('"string"', $functionB->getArgument(0)->getValue()); - $this->assertSame('string', $functionB->getArgument(0)->stringValue()); + self::assertSame(ReflectionArgument::STRING, $functionB->getArgument(0)->getType()); + self::assertSame('"string"', $functionB->getArgument(0)->getValue()); + self::assertSame('string', $functionB->getArgument(0)->stringValue()); - $this->assertSame(ReflectionArgument::CONSTANT, $functionB->getArgument(1)->getType()); - $this->assertSame('123', $functionB->getArgument(1)->getValue()); + self::assertSame(ReflectionArgument::CONSTANT, $functionB->getArgument(1)->getType()); + self::assertSame('123', $functionB->getArgument(1)->getValue()); } public function testReflectionFileWithNamedParameters(): void { $reflection = new ReflectionFile(__DIR__ . '/Classes/ClassWithNamedParameter.php'); - $this->assertSame([ + self::assertSame([ \Spiral\Tests\Tokenizer\Classes\ClassWithNamedParameter::class, ], $reflection->getClasses()); } @@ -64,7 +64,7 @@ public function testReflectionFileAnonymousClass(): void { $reflection = new ReflectionFile(__DIR__ . '/Classes/ClassWithAnonymousClass.php'); - $this->assertSame([ + self::assertSame([ \Spiral\Tests\Tokenizer\Classes\ClassWithAnonymousClass::class, ], $reflection->getClasses()); } @@ -73,7 +73,7 @@ public function testReflectionFileWithHeredoc(): void { $reflection = new ReflectionFile(__DIR__ . '/Classes/ClassWithHeredoc.php'); - $this->assertSame([ + self::assertSame([ 'Spiral\Tests\Tokenizer\Classes\ClassWithHeredoc', ], $reflection->getClasses()); } @@ -82,7 +82,7 @@ public function testReflectionEnum(): void { $reflection = new ReflectionFile(__DIR__ . '/Classes/ClassD.php'); - $this->assertSame([ + self::assertSame([ \Spiral\Tests\Tokenizer\Classes\ClassD::class, ], $reflection->getEnums()); } @@ -91,7 +91,7 @@ public function testReflectionTypedEnum(): void { $reflection = new ReflectionFile(__DIR__ . '/Classes/ClassE.php'); - $this->assertSame([ + self::assertSame([ \Spiral\Tests\Tokenizer\Classes\ClassE::class, ], $reflection->getEnums()); } @@ -100,7 +100,7 @@ public function testReflectionInterface(): void { $reflection = new ReflectionFile(__DIR__ . '/Interfaces/InterfaceA.php'); - $this->assertSame([ + self::assertSame([ \Spiral\Tests\Tokenizer\Interfaces\InterfaceA::class, ], $reflection->getInterfaces()); } @@ -113,7 +113,7 @@ private function deadend() } } -function hello() +function hello(): void { } diff --git a/tests/ScopedClassLocatorTest.php b/tests/ScopedClassLocatorTest.php index 9892f02..c4ddd4c 100644 --- a/tests/ScopedClassLocatorTest.php +++ b/tests/ScopedClassLocatorTest.php @@ -32,29 +32,29 @@ public function testGetsClassesForExistsScope(): void { $classes = $this->container->get(ScopedClassesInterface::class)->getScopedClasses('foo'); - $this->assertArrayHasKey(ClassD::class, $classes); + self::assertArrayHasKey(ClassD::class, $classes); // Excluded - $this->assertArrayNotHasKey(self::class, $classes); - $this->assertArrayNotHasKey(ClassA::class, $classes); - $this->assertArrayNotHasKey(ClassB::class, $classes); - $this->assertArrayNotHasKey(ClassC::class, $classes); - $this->assertArrayNotHasKey(\Spiral\Tests\Tokenizer\Classes\Excluded\ClassXX::class, $classes); - $this->assertArrayNotHasKey('Spiral\Tests\Tokenizer\Classes\Bad_Class', $classes); + self::assertArrayNotHasKey(self::class, $classes); + self::assertArrayNotHasKey(ClassA::class, $classes); + self::assertArrayNotHasKey(ClassB::class, $classes); + self::assertArrayNotHasKey(ClassC::class, $classes); + self::assertArrayNotHasKey(\Spiral\Tests\Tokenizer\Classes\Excluded\ClassXX::class, $classes); + self::assertArrayNotHasKey('Spiral\Tests\Tokenizer\Classes\Bad_Class', $classes); } public function testGetsClassesForNotExistScope(): void { $classes = $this->container->get(ScopedClassesInterface::class)->getScopedClasses('bar'); - $this->assertArrayHasKey(self::class, $classes); - $this->assertArrayHasKey(ClassA::class, $classes); - $this->assertArrayHasKey(ClassB::class, $classes); - $this->assertArrayHasKey(ClassC::class, $classes); - $this->assertArrayHasKey(ClassD::class, $classes); + self::assertArrayHasKey(self::class, $classes); + self::assertArrayHasKey(ClassA::class, $classes); + self::assertArrayHasKey(ClassB::class, $classes); + self::assertArrayHasKey(ClassC::class, $classes); + self::assertArrayHasKey(ClassD::class, $classes); // Excluded - $this->assertArrayNotHasKey(\Spiral\Tests\Tokenizer\Classes\Excluded\ClassXX::class, $classes); - $this->assertArrayNotHasKey('Spiral\Tests\Tokenizer\Classes\Bad_Class', $classes); + self::assertArrayNotHasKey(\Spiral\Tests\Tokenizer\Classes\Excluded\ClassXX::class, $classes); + self::assertArrayNotHasKey('Spiral\Tests\Tokenizer\Classes\Bad_Class', $classes); } } diff --git a/tests/ScopedEnumLocatorTest.php b/tests/ScopedEnumLocatorTest.php index 4f48e2b..17e17f0 100644 --- a/tests/ScopedEnumLocatorTest.php +++ b/tests/ScopedEnumLocatorTest.php @@ -34,29 +34,29 @@ public function testGetsEnumsForExistsScope(): void { $classes = $this->container->get(ScopedEnumsInterface::class)->getScopedEnums('foo'); - $this->assertArrayHasKey(EnumD::class, $classes); + self::assertArrayHasKey(EnumD::class, $classes); // Excluded - $this->assertArrayNotHasKey(EnumA::class, $classes); - $this->assertArrayNotHasKey(EnumB::class, $classes); - $this->assertArrayNotHasKey(EnumC::class, $classes); - $this->assertArrayNotHasKey(EnumXX::class, $classes); - $this->assertArrayNotHasKey(BadEnum::class, $classes); - $this->assertArrayNotHasKey('Spiral\Tests\Tokenizer\Enums\Bad_Enum', $classes); + self::assertArrayNotHasKey(EnumA::class, $classes); + self::assertArrayNotHasKey(EnumB::class, $classes); + self::assertArrayNotHasKey(EnumC::class, $classes); + self::assertArrayNotHasKey(EnumXX::class, $classes); + self::assertArrayNotHasKey(BadEnum::class, $classes); + self::assertArrayNotHasKey('Spiral\Tests\Tokenizer\Enums\Bad_Enum', $classes); } public function testGetsEnumsForNotExistScope(): void { $classes = $this->container->get(ScopedEnumsInterface::class)->getScopedEnums('bar'); - $this->assertArrayHasKey(EnumA::class, $classes); - $this->assertArrayHasKey(EnumB::class, $classes); - $this->assertArrayHasKey(EnumC::class, $classes); - $this->assertArrayHasKey(EnumD::class, $classes); + self::assertArrayHasKey(EnumA::class, $classes); + self::assertArrayHasKey(EnumB::class, $classes); + self::assertArrayHasKey(EnumC::class, $classes); + self::assertArrayHasKey(EnumD::class, $classes); // Excluded - $this->assertArrayNotHasKey(EnumXX::class, $classes); - $this->assertArrayNotHasKey(BadEnum::class, $classes); - $this->assertArrayNotHasKey('Spiral\Tests\Tokenizer\Enums\Bad_Enum', $classes); + self::assertArrayNotHasKey(EnumXX::class, $classes); + self::assertArrayNotHasKey(BadEnum::class, $classes); + self::assertArrayNotHasKey('Spiral\Tests\Tokenizer\Enums\Bad_Enum', $classes); } } diff --git a/tests/ScopedInterfaceLocatorTest.php b/tests/ScopedInterfaceLocatorTest.php index ce0a93d..b49abd5 100644 --- a/tests/ScopedInterfaceLocatorTest.php +++ b/tests/ScopedInterfaceLocatorTest.php @@ -34,29 +34,29 @@ public function testGetsInterfacesForExistsScope(): void { $classes = $this->container->get(ScopedInterfacesInterface::class)->getScopedInterfaces('foo'); - $this->assertArrayHasKey(InterfaceD::class, $classes); + self::assertArrayHasKey(InterfaceD::class, $classes); // Excluded - $this->assertArrayNotHasKey(InterfaceA::class, $classes); - $this->assertArrayNotHasKey(InterfaceB::class, $classes); - $this->assertArrayNotHasKey(InterfaceC::class, $classes); - $this->assertArrayNotHasKey(InterfaceXX::class, $classes); - $this->assertArrayNotHasKey(BadInterface::class, $classes); - $this->assertArrayNotHasKey('Spiral\Tests\Tokenizer\Interfaces\Bad_Interface', $classes); + self::assertArrayNotHasKey(InterfaceA::class, $classes); + self::assertArrayNotHasKey(InterfaceB::class, $classes); + self::assertArrayNotHasKey(InterfaceC::class, $classes); + self::assertArrayNotHasKey(InterfaceXX::class, $classes); + self::assertArrayNotHasKey(BadInterface::class, $classes); + self::assertArrayNotHasKey('Spiral\Tests\Tokenizer\Interfaces\Bad_Interface', $classes); } public function testGetsInterfacesForNotExistScope(): void { $classes = $this->container->get(ScopedInterfacesInterface::class)->getScopedInterfaces('bar'); - $this->assertArrayHasKey(InterfaceA::class, $classes); - $this->assertArrayHasKey(InterfaceB::class, $classes); - $this->assertArrayHasKey(InterfaceC::class, $classes); - $this->assertArrayHasKey(InterfaceD::class, $classes); + self::assertArrayHasKey(InterfaceA::class, $classes); + self::assertArrayHasKey(InterfaceB::class, $classes); + self::assertArrayHasKey(InterfaceC::class, $classes); + self::assertArrayHasKey(InterfaceD::class, $classes); // Excluded - $this->assertArrayNotHasKey(InterfaceXX::class, $classes); - $this->assertArrayNotHasKey(BadInterface::class, $classes); - $this->assertArrayNotHasKey('Spiral\Tests\Tokenizer\Interfaces\Bad_Interface', $classes); + self::assertArrayNotHasKey(InterfaceXX::class, $classes); + self::assertArrayNotHasKey(BadInterface::class, $classes); + self::assertArrayNotHasKey('Spiral\Tests\Tokenizer\Interfaces\Bad_Interface', $classes); } }