Optimize tests

tests/Feature/Gd/ConvertPngGif.php

@@ -6,7 +6,9 @@ namespace Intervention\Image\Tests\Feature\Gd;
 
 use Intervention\Image\ImageManager;
 use Intervention\Image\Tests\GdTestCase;
+use PHPUnit\Framework\Attributes\RequiresPhpExtension;
 
+#[RequiresPhpExtension('gd')]
 class ConvertPngGif extends GdTestCase
 {
     public function testConversionKeepsTransparency(): void

tests/Feature/Imagick/ConvertPngGif.php

@@ -6,7 +6,9 @@ namespace Intervention\Image\Tests\Feature\Imagick;
 
 use Intervention\Image\ImageManager;
 use Intervention\Image\Tests\ImagickTestCase;
+use PHPUnit\Framework\Attributes\RequiresPhpExtension;
 
+#[RequiresPhpExtension('imagick')]
 class ConvertPngGif extends ImagickTestCase
 {
     public function testConversionKeepsTransparency(): void

tests/Unit/Colors/Cmyk/ChannelTest.php

@@ -4,78 +4,79 @@ declare(strict_types=1);
 
 namespace Intervention\Image\Tests\Unit\Colors\Cmyk;
 
-use PHPUnit\Framework\Attributes\CoversClass;
-use PHPUnit\Framework\Attributes\RequiresPhpExtension;
-use Intervention\Image\Colors\Cmyk\Channels\Cyan as Channel;
+use Intervention\Image\Colors\Cmyk\Channels\Cyan;
+use Intervention\Image\Colors\Cmyk\Channels\Key;
+use Intervention\Image\Colors\Cmyk\Channels\Magenta;
+use Intervention\Image\Colors\Cmyk\Channels\Yellow;
 use Intervention\Image\Exceptions\ColorException;
 use Intervention\Image\Tests\BaseTestCase;
+use PHPUnit\Framework\Attributes\CoversClass;
 
-#[RequiresPhpExtension('gd')]
-#[CoversClass(\Intervention\Image\Colors\Cmyk\Channels\Cyan::class)]
-#[CoversClass(\Intervention\Image\Colors\Cmyk\Channels\Magenta::class)]
-#[CoversClass(\Intervention\Image\Colors\Cmyk\Channels\Yellow::class)]
-#[CoversClass(\Intervention\Image\Colors\Cmyk\Channels\Key::class)]
+#[CoversClass(Cyan::class)]
+#[CoversClass(Magenta::class)]
+#[CoversClass(Yellow::class)]
+#[CoversClass(Key::class)]
 final class ChannelTest extends BaseTestCase
 {
     public function testConstructor(): void
     {
-        $channel = new Channel(0);
-        $this->assertInstanceOf(Channel::class, $channel);
+        $channel =  new Cyan(0);
+        $this->assertInstanceOf(Cyan::class, $channel);
 
-        $channel = new Channel(value: 0);
-        $this->assertInstanceOf(Channel::class, $channel);
+        $channel =  new Cyan(value: 0);
+        $this->assertInstanceOf(Cyan::class, $channel);
 
-        $channel = new Channel(normalized: 0);
-        $this->assertInstanceOf(Channel::class, $channel);
+        $channel =  new Cyan(normalized: 0);
+        $this->assertInstanceOf(Cyan::class, $channel);
 
         $this->expectException(ColorException::class);
-        new Channel();
+         new Cyan();
 
         $this->expectException(ColorException::class);
-        new Channel(normalized: 2);
+         new Cyan(normalized: 2);
     }
 
     public function testConstructorFail(): void
     {
         $this->expectException(ColorException::class);
-        new Channel(200);
+         new Cyan(200);
     }
 
     public function testToInt(): void
     {
-        $channel = new Channel(10);
+        $channel =  new Cyan(10);
         $this->assertEquals(10, $channel->toInt());
     }
 
     public function testToString(): void
     {
-        $channel = new Channel(10);
+        $channel =  new Cyan(10);
         $this->assertEquals("10", $channel->toString());
         $this->assertEquals("10", (string) $channel);
     }
 
     public function testValue(): void
     {
-        $channel = new Channel(10);
+        $channel =  new Cyan(10);
         $this->assertEquals(10, $channel->value());
     }
 
     public function testNormalize(): void
     {
-        $channel = new Channel(100);
+        $channel =  new Cyan(100);
         $this->assertEquals(1, $channel->normalize());
-        $channel = new Channel(0);
+        $channel =  new Cyan(0);
         $this->assertEquals(0, $channel->normalize());
-        $channel = new Channel(20);
+        $channel =  new Cyan(20);
         $this->assertEquals(.2, $channel->normalize());
     }
 
     public function testValidate(): void
     {
         $this->expectException(ColorException::class);
-        new Channel(101);
+         new Cyan(101);
 
         $this->expectException(ColorException::class);
-        new Channel(-1);
+         new Cyan(-1);
     }
 }

tests/Unit/Colors/Cmyk/ColorTest.php

@@ -5,7 +5,6 @@ declare(strict_types=1);
 namespace Intervention\Image\Tests\Unit\Colors\Cmyk;
 
 use PHPUnit\Framework\Attributes\CoversClass;
-use PHPUnit\Framework\Attributes\RequiresPhpExtension;
 use Intervention\Image\Colors\Cmyk\Channels\Cyan;
 use Intervention\Image\Colors\Cmyk\Channels\Key;
 use Intervention\Image\Colors\Cmyk\Channels\Magenta;
@@ -15,8 +14,7 @@ use Intervention\Image\Colors\Cmyk\Colorspace;
 use Intervention\Image\Exceptions\ColorException;
 use Intervention\Image\Tests\BaseTestCase;
 
-#[RequiresPhpExtension('gd')]
-#[CoversClass(\Intervention\Image\Colors\Cmyk\Color::class)]
+#[CoversClass(Color::class)]
 final class ColorTest extends BaseTestCase
 {
     public function testConstructor(): void

tests/Unit/Colors/Cmyk/ColorspaceTest.php

@@ -16,7 +16,7 @@ use Intervention\Image\Colors\Hsl\Color as HslColor;
 use Intervention\Image\Colors\Cmyk\Colorspace;
 use Intervention\Image\Tests\BaseTestCase;
 
-#[CoversClass(\Intervention\Image\Colors\Cmyk\Colorspace::class)]
+#[CoversClass(Colorspace::class)]
 final class ColorspaceTest extends BaseTestCase
 {
     public function testColorFromNormalized(): void

tests/Unit/Colors/Cmyk/Decoders/StringColorDecoderTest.php

@@ -5,14 +5,12 @@ declare(strict_types=1);
 namespace Intervention\Image\Tests\Unit\Colors\Cmyk\Decoders;
 
 use PHPUnit\Framework\Attributes\CoversClass;
-use PHPUnit\Framework\Attributes\RequiresPhpExtension;
 use Intervention\Image\Colors\Cmyk\Color;
 use Intervention\Image\Colors\Cmyk\Decoders\StringColorDecoder;
 use Intervention\Image\Exceptions\DecoderException;
 use Intervention\Image\Tests\BaseTestCase;
 
-#[RequiresPhpExtension('gd')]
-#[CoversClass(\Intervention\Image\Colors\Cmyk\Decoders\StringColorDecoder::class)]
+#[CoversClass(StringColorDecoder::class)]
 final class StringColorDecoderTest extends BaseTestCase
 {
     public function testDecode(): void

tests/Unit/Colors/Hsl/ChannelTest.php

@@ -11,9 +11,9 @@ use Intervention\Image\Colors\Hsl\Channels\Luminance;
 use Intervention\Image\Exceptions\ColorException;
 use Intervention\Image\Tests\BaseTestCase;
 
-#[CoversClass(\Intervention\Image\Colors\Hsl\Channels\Hue::class)]
-#[CoversClass(\Intervention\Image\Colors\Hsl\Channels\Saturation::class)]
-#[CoversClass(\Intervention\Image\Colors\Hsl\Channels\Luminance::class)]
+#[CoversClass(Hue::class)]
+#[CoversClass(Saturation::class)]
+#[CoversClass(Luminance::class)]
 final class ChannelTest extends BaseTestCase
 {
     public function testConstructor(): void

tests/Unit/Colors/Hsl/Channels/SaturationTest.php

@@ -6,7 +6,9 @@ namespace Intervention\Image\Tests\Unit\Colors\Hsl\Channels;
 
 use Intervention\Image\Colors\Hsl\Channels\Saturation;
 use Intervention\Image\Tests\BaseTestCase;
+use PHPUnit\Framework\Attributes\CoversClass;
 
+#[CoversClass(Saturation::class)]
 final class SaturationTest extends BaseTestCase
 {
     public function testMinMax(): void

tests/Unit/Colors/Hsl/ColorTest.php

@@ -13,7 +13,7 @@ use Intervention\Image\Colors\Hsl\Colorspace;
 use Intervention\Image\Exceptions\ColorException;
 use Intervention\Image\Tests\BaseTestCase;
 
-#[CoversClass(\Intervention\Image\Colors\Hsl\Color::class)]
+#[CoversClass(Color::class)]
 final class ColorTest extends BaseTestCase
 {
     public function testConstructor(): void

tests/Unit/Colors/Hsl/ColorspaceTest.php

@@ -15,7 +15,7 @@ use Intervention\Image\Colors\Hsv\Color as HsvColor;
 use Intervention\Image\Colors\Hsl\Colorspace;
 use Intervention\Image\Tests\BaseTestCase;
 
-#[CoversClass(\Intervention\Image\Colors\Hsl\Colorspace::class)]
+#[CoversClass(Colorspace::class)]
 final class ColorspaceTest extends BaseTestCase
 {
     public function testColorFromNormalized(): void

tests/Unit/Colors/Hsl/Decoders/StringColorDecoderTest.php

@@ -6,14 +6,12 @@ namespace Intervention\Image\Tests\Unit\Colors\Hsl\Decoders;
 
 use Generator;
 use PHPUnit\Framework\Attributes\CoversClass;
-use PHPUnit\Framework\Attributes\RequiresPhpExtension;
 use Intervention\Image\Colors\Hsl\Color;
 use Intervention\Image\Colors\Hsl\Decoders\StringColorDecoder;
 use Intervention\Image\Tests\BaseTestCase;
 use PHPUnit\Framework\Attributes\DataProvider;
 
-#[RequiresPhpExtension('gd')]
-#[CoversClass(\Intervention\Image\Colors\Hsl\Decoders\StringColorDecoder::class)]
+#[CoversClass(StringColorDecoder::class)]
 final class StringColorDecoderTest extends BaseTestCase
 {
     #[DataProvider('decodeDataProvier')]

tests/Unit/Colors/Hsv/ChannelTest.php

@@ -5,17 +5,15 @@ declare(strict_types=1);
 namespace Intervention\Image\Tests\Unit\Colors\Hsv;
 
 use PHPUnit\Framework\Attributes\CoversClass;
-use PHPUnit\Framework\Attributes\RequiresPhpExtension;
 use Intervention\Image\Colors\Hsv\Channels\Hue;
 use Intervention\Image\Colors\Hsv\Channels\Saturation;
 use Intervention\Image\Colors\Hsv\Channels\Value;
 use Intervention\Image\Exceptions\ColorException;
 use Intervention\Image\Tests\BaseTestCase;
 
-#[RequiresPhpExtension('gd')]
-#[CoversClass(\Intervention\Image\Colors\Hsv\Channels\Hue::class)]
-#[CoversClass(\Intervention\Image\Colors\Hsv\Channels\Saturation::class)]
-#[CoversClass(\Intervention\Image\Colors\Hsv\Channels\Value::class)]
+#[CoversClass(Hue::class)]
+#[CoversClass(Saturation::class)]
+#[CoversClass(Value::class)]
 final class ChannelTest extends BaseTestCase
 {
     public function testConstructor(): void

tests/Unit/Colors/Hsv/Channels/SaturationTest.php

@@ -6,7 +6,9 @@ namespace Intervention\Image\Tests\Unit\Colors\Hsv\Channels;
 
 use Intervention\Image\Colors\Hsv\Channels\Saturation;
 use Intervention\Image\Tests\BaseTestCase;
+use PHPUnit\Framework\Attributes\CoversClass;
 
+#[CoversClass(Saturation::class)]
 final class SaturationTest extends BaseTestCase
 {
     public function testMinMax(): void

tests/Unit/Colors/Hsv/Channels/ValueTest.php

@@ -6,7 +6,9 @@ namespace Intervention\Image\Tests\Unit\Colors\Hsv\Channels;
 
 use Intervention\Image\Colors\Hsv\Channels\Value;
 use Intervention\Image\Tests\BaseTestCase;
+use PHPUnit\Framework\Attributes\CoversClass;
 
+#[CoversClass(Value::class)]
 final class ValueTest extends BaseTestCase
 {
     public function testMinMax(): void

tests/Unit/Colors/Hsv/ColorTest.php

@@ -13,7 +13,7 @@ use Intervention\Image\Colors\Hsv\Colorspace;
 use Intervention\Image\Exceptions\ColorException;
 use Intervention\Image\Tests\BaseTestCase;
 
-#[CoversClass(\Intervention\Image\Colors\Hsv\Color::class)]
+#[CoversClass(Color::class)]
 final class ColorTest extends BaseTestCase
 {
     public function testConstructor(): void

tests/Unit/Colors/Hsv/ColorspaceTest.php

@@ -15,7 +15,7 @@ use Intervention\Image\Colors\Hsl\Color as HslColor;
 use Intervention\Image\Colors\Hsv\Colorspace;
 use Intervention\Image\Tests\BaseTestCase;
 
-#[CoversClass(\Intervention\Image\Colors\Hsv\Colorspace::class)]
+#[CoversClass(Colorspace::class)]
 final class ColorspaceTest extends BaseTestCase
 {
     public function testColorFromNormalized(): void

tests/Unit/Colors/Hsv/Decoders/StringColorDecoderTest.php

@@ -6,14 +6,12 @@ namespace Intervention\Image\Tests\Unit\Colors\Hsv\Decoders;
 
 use Generator;
 use PHPUnit\Framework\Attributes\CoversClass;
-use PHPUnit\Framework\Attributes\RequiresPhpExtension;
 use Intervention\Image\Colors\Hsv\Color;
 use Intervention\Image\Colors\Hsv\Decoders\StringColorDecoder;
 use Intervention\Image\Tests\BaseTestCase;
 use PHPUnit\Framework\Attributes\DataProvider;
 
-#[RequiresPhpExtension('gd')]
-#[CoversClass(\Intervention\Image\Colors\Hsv\Decoders\StringColorDecoder::class)]
+#[CoversClass(StringColorDecoder::class)]
 final class StringColorDecoderTest extends BaseTestCase
 {
     #[DataProvider('decodeDataProvier')]

tests/Unit/Colors/Rgb/ChannelTest.php

@@ -4,16 +4,17 @@ declare(strict_types=1);
 
 namespace Intervention\Image\Tests\Unit\Colors\Rgb;
 
+use Intervention\Image\Colors\Rgb\Channels\Blue;
+use Intervention\Image\Colors\Rgb\Channels\Green;
 use PHPUnit\Framework\Attributes\CoversClass;
-use PHPUnit\Framework\Attributes\RequiresPhpExtension;
 use Intervention\Image\Colors\Rgb\Channels\Red as Channel;
+use Intervention\Image\Colors\Rgb\Channels\Red;
 use Intervention\Image\Exceptions\ColorException;
 use Intervention\Image\Tests\BaseTestCase;
 
-#[RequiresPhpExtension('gd')]
-#[CoversClass(\Intervention\Image\Colors\Rgb\Channels\Red::class)]
-#[CoversClass(\Intervention\Image\Colors\Rgb\Channels\Green::class)]
-#[CoversClass(\Intervention\Image\Colors\Rgb\Channels\Blue::class)]
+#[CoversClass(Red::class)]
+#[CoversClass(Green::class)]
+#[CoversClass(Blue::class)]
 final class ChannelTest extends BaseTestCase
 {
     public function testConstructor(): void

tests/Unit/Colors/Rgb/Channels/AlphaTest.php

@@ -8,7 +8,7 @@ use PHPUnit\Framework\Attributes\CoversClass;
 use Intervention\Image\Colors\Rgb\Channels\Alpha;
 use Intervention\Image\Tests\BaseTestCase;
 
-#[CoversClass(\Intervention\Image\Colors\Rgb\Channels\Alpha::class)]
+#[CoversClass(Alpha::class)]
 final class AlphaTest extends BaseTestCase
 {
     public function testToString(): void

tests/Unit/Colors/Rgb/ColorTest.php

@@ -5,7 +5,6 @@ declare(strict_types=1);
 namespace Intervention\Image\Tests\Unit\Colors\Rgb;
 
 use PHPUnit\Framework\Attributes\CoversClass;
-use PHPUnit\Framework\Attributes\RequiresPhpExtension;
 use Intervention\Image\Colors\Cmyk\Color as CmykColor;
 use Intervention\Image\Colors\Cmyk\Colorspace as CmykColorspace;
 use Intervention\Image\Colors\Rgb\Channels\Red;
@@ -16,8 +15,7 @@ use Intervention\Image\Colors\Rgb\Colorspace as RgbColorspace;
 use Intervention\Image\Exceptions\ColorException;
 use Intervention\Image\Tests\BaseTestCase;
 
-#[RequiresPhpExtension('gd')]
-#[CoversClass(\Intervention\Image\Colors\Rgb\Color::class)]
+#[CoversClass(Color::class)]
 final class ColorTest extends BaseTestCase
 {
     public function testConstructor(): void

tests/Unit/Colors/Rgb/ColorspaceTest.php

@@ -16,7 +16,7 @@ use Intervention\Image\Colors\Rgb\Channels\Alpha;
 use Intervention\Image\Colors\Rgb\Colorspace;
 use Intervention\Image\Tests\BaseTestCase;
 
-#[CoversClass(\Intervention\Image\Colors\Rgb\Colorspace::class)]
+#[CoversClass(Colorspace::class)]
 final class ColorspaceTest extends BaseTestCase
 {
     public function testColorFromNormalized(): void

tests/Unit/Colors/Rgb/Decoders/HexColorDecoderTest.php

@@ -6,14 +6,12 @@ namespace Intervention\Image\Tests\Unit\Colors\Rgb\Decoders;
 
 use Generator;
 use PHPUnit\Framework\Attributes\CoversClass;
-use PHPUnit\Framework\Attributes\RequiresPhpExtension;
 use Intervention\Image\Colors\Rgb\Color;
 use Intervention\Image\Colors\Rgb\Decoders\HexColorDecoder;
 use Intervention\Image\Tests\BaseTestCase;
 use PHPUnit\Framework\Attributes\DataProvider;
 
-#[RequiresPhpExtension('gd')]
-#[CoversClass(\Intervention\Image\Colors\Rgb\Decoders\HexColorDecoder::class)]
+#[CoversClass(HexColorDecoder::class)]
 final class HexColorDecoderTest extends BaseTestCase
 {
     #[DataProvider('decodeDataProvier')]

tests/Unit/Colors/Rgb/Decoders/HtmlColornameDecoderTest.php

@@ -6,14 +6,12 @@ namespace Intervention\Image\Tests\Unit\Colors\Rgb\Decoders;
 
 use Generator;
 use PHPUnit\Framework\Attributes\CoversClass;
-use PHPUnit\Framework\Attributes\RequiresPhpExtension;
 use Intervention\Image\Colors\Rgb\Color;
 use Intervention\Image\Colors\Rgb\Decoders\HtmlColornameDecoder;
 use Intervention\Image\Tests\BaseTestCase;
 use PHPUnit\Framework\Attributes\DataProvider;
 
-#[RequiresPhpExtension('gd')]
-#[CoversClass(\Intervention\Image\Colors\Rgb\Decoders\HtmlColorNameDecoder::class)]
+#[CoversClass(HtmlColorNameDecoder::class)]
 final class HtmlColornameDecoderTest extends BaseTestCase
 {
     #[DataProvider('decodeDataProvier')]

tests/Unit/Colors/Rgb/Decoders/StringColorDecoderTest.php

@@ -6,14 +6,12 @@ namespace Intervention\Image\Tests\Unit\Colors\Rgb\Decoders;
 
 use Generator;
 use PHPUnit\Framework\Attributes\CoversClass;
-use PHPUnit\Framework\Attributes\RequiresPhpExtension;
 use Intervention\Image\Colors\Rgb\Color;
 use Intervention\Image\Colors\Rgb\Decoders\StringColorDecoder;
 use Intervention\Image\Tests\BaseTestCase;
 use PHPUnit\Framework\Attributes\DataProvider;
 
-#[RequiresPhpExtension('gd')]
-#[CoversClass(\Intervention\Image\Colors\Rgb\Decoders\StringColorDecoder::class)]
+#[CoversClass(StringColorDecoder::class)]
 final class StringColorDecoderTest extends BaseTestCase
 {
     #[DataProvider('decodeDataProvier')]

tests/Unit/Drivers/AbstractDecoderTest.php

@@ -14,7 +14,7 @@ use Intervention\Image\Tests\BaseTestCase;
 use Mockery;
 use stdClass;
 
-#[CoversClass(\Intervention\Image\Drivers\AbstractDecoder::class)]
+#[CoversClass(AbstractDecoder::class)]
 final class AbstractDecoderTest extends BaseTestCase
 {
     public function testIsGifFormat(): void

tests/Unit/Drivers/AbstractEncoderTest.php

@@ -11,7 +11,7 @@ use Intervention\Image\Tests\BaseTestCase;
 use Mockery;
 use PHPUnit\Metadata\CoversClass;
 
-#[CoversClass(\Intervention\Image\Drivers\AbstractEncoder::class)]
+#[CoversClass(AbstractEncoder::class)]
 final class AbstractEncoderTest extends BaseTestCase
 {
     public function testEncode(): void

tests/Unit/Drivers/Gd/Analyzers/ColorspaceAnalyzerTest.php

@@ -4,21 +4,22 @@ declare(strict_types=1);
 
 namespace Intervention\Image\Tests\Unit\Drivers\Gd\Analyzers;
 
+use Intervention\Image\Drivers\Gd\Analyzers\ColorspaceAnalyzer;
+use Intervention\Image\Drivers\Gd\Driver;
 use PHPUnit\Framework\Attributes\CoversClass;
 use PHPUnit\Framework\Attributes\RequiresPhpExtension;
-use Intervention\Image\Analyzers\ColorspaceAnalyzer;
 use Intervention\Image\Interfaces\ColorspaceInterface;
 use Intervention\Image\Tests\GdTestCase;
 
 #[RequiresPhpExtension('gd')]
-#[CoversClass(\Intervention\Image\Analyzers\ColorspaceAnalyzer::class)]
-#[CoversClass(\Intervention\Image\Drivers\Imagick\Analyzers\ColorspaceAnalyzer::class)]
+#[CoversClass(ColorspaceAnalyzer::class)]
 final class ColorspaceAnalyzerTest extends GdTestCase
 {
     public function testAnalyze(): void
     {
         $image = $this->readTestImage('tile.png');
         $analyzer = new ColorspaceAnalyzer();
+        $analyzer->setDriver(new Driver());
         $result = $analyzer->analyze($image);
         $this->assertInstanceOf(ColorspaceInterface::class, $result);
     }

tests/Unit/Drivers/Gd/Analyzers/HeightAnalyzerTest.php

@@ -4,20 +4,21 @@ declare(strict_types=1);
 
 namespace Intervention\Image\Tests\Unit\Drivers\Gd\Analyzers;
 
+use Intervention\Image\Drivers\Gd\Analyzers\HeightAnalyzer;
+use Intervention\Image\Drivers\Gd\Driver;
 use PHPUnit\Framework\Attributes\CoversClass;
 use PHPUnit\Framework\Attributes\RequiresPhpExtension;
-use Intervention\Image\Analyzers\HeightAnalyzer;
 use Intervention\Image\Tests\GdTestCase;
 
 #[RequiresPhpExtension('gd')]
-#[CoversClass(\Intervention\Image\Analyzers\HeightAnalyzer::class)]
-#[CoversClass(\Intervention\Image\Drivers\Imagick\Analyzers\HeightAnalyzer::class)]
+#[CoversClass(HeightAnalyzer::class)]
 final class HeightAnalyzerTest extends GdTestCase
 {
     public function testAnalyze(): void
     {
         $image = $this->readTestImage('tile.png');
         $analyzer = new HeightAnalyzer();
+        $analyzer->setDriver(new Driver());
         $result = $analyzer->analyze($image);
         $this->assertEquals(16, $result);
     }

tests/Unit/Drivers/Gd/Analyzers/PixelColorAnalyzerTest.php

@@ -4,21 +4,22 @@ declare(strict_types=1);
 
 namespace Intervention\Image\Tests\Unit\Drivers\Gd\Analyzers;
 
+use Intervention\Image\Drivers\Gd\Analyzers\PixelColorAnalyzer;
+use Intervention\Image\Drivers\Gd\Driver;
 use PHPUnit\Framework\Attributes\CoversClass;
 use PHPUnit\Framework\Attributes\RequiresPhpExtension;
-use Intervention\Image\Analyzers\PixelColorAnalyzer;
 use Intervention\Image\Interfaces\ColorInterface;
 use Intervention\Image\Tests\GdTestCase;
 
 #[RequiresPhpExtension('gd')]
-#[CoversClass(\Intervention\Image\Analyzers\PixelColorAnalyzer::class)]
-#[CoversClass(\Intervention\Image\Drivers\Imagick\Analyzers\PixelColorAnalyzer::class)]
+#[CoversClass(PixelColorAnalyzer::class)]
 final class PixelColorAnalyzerTest extends GdTestCase
 {
     public function testAnalyze(): void
     {
         $image = $this->readTestImage('tile.png');
         $analyzer = new PixelColorAnalyzer(0, 0);
+        $analyzer->setDriver(new Driver());
         $result = $analyzer->analyze($image);
         $this->assertInstanceOf(ColorInterface::class, $result);
         $this->assertEquals('b4e000', $result->toHex());

tests/Unit/Drivers/Gd/Analyzers/PixelColorsAnalyzerTest.php

@@ -6,20 +6,21 @@ namespace Intervention\Image\Tests\Unit\Drivers\Gd\Analyzers;
 
 use PHPUnit\Framework\Attributes\CoversClass;
 use PHPUnit\Framework\Attributes\RequiresPhpExtension;
-use Intervention\Image\Analyzers\PixelColorsAnalyzer;
 use Intervention\Image\Collection;
+use Intervention\Image\Drivers\Gd\Analyzers\PixelColorsAnalyzer;
+use Intervention\Image\Drivers\Gd\Driver;
 use Intervention\Image\Interfaces\ColorInterface;
 use Intervention\Image\Tests\GdTestCase;
 
 #[RequiresPhpExtension('gd')]
-#[CoversClass(\Intervention\Image\Analyzers\PixelColorsAnalyzer::class)]
-#[CoversClass(\Intervention\Image\Drivers\Imagick\Analyzers\PixelColorsAnalyzer::class)]
+#[CoversClass(PixelColorsAnalyzer::class)]
 final class PixelColorsAnalyzerTest extends GdTestCase
 {
     public function testAnalyze(): void
     {
         $image = $this->readTestImage('tile.png');
         $analyzer = new PixelColorsAnalyzer(0, 0);
+        $analyzer->setDriver(new Driver());
         $result = $analyzer->analyze($image);
         $this->assertInstanceOf(Collection::class, $result);
         $this->assertInstanceOf(ColorInterface::class, $result->first());

tests/Unit/Drivers/Gd/Analyzers/ResolutionAnalyzerTest.php

@@ -4,21 +4,22 @@ declare(strict_types=1);
 
 namespace Intervention\Image\Tests\Unit\Drivers\Gd\Analyzers;
 
+use Intervention\Image\Drivers\Gd\Analyzers\ResolutionAnalyzer;
+use Intervention\Image\Drivers\Gd\Driver;
 use PHPUnit\Framework\Attributes\CoversClass;
 use PHPUnit\Framework\Attributes\RequiresPhpExtension;
-use Intervention\Image\Analyzers\ResolutionAnalyzer;
 use Intervention\Image\Resolution;
 use Intervention\Image\Tests\GdTestCase;
 
 #[RequiresPhpExtension('gd')]
-#[CoversClass(\Intervention\Image\Analyzers\ResolutionAnalyzer::class)]
-#[CoversClass(\Intervention\Image\Drivers\Imagick\Analyzers\ResolutionAnalyzer::class)]
+#[CoversClass(ResolutionAnalyzer::class)]
 final class ResolutionAnalyzerTest extends GdTestCase
 {
     public function testAnalyze(): void
     {
         $image = $this->readTestImage('tile.png');
         $analyzer = new ResolutionAnalyzer();
+        $analyzer->setDriver(new Driver());
         $result = $analyzer->analyze($image);
         $this->assertInstanceOf(Resolution::class, $result);
     }

tests/Unit/Drivers/Gd/Analyzers/WidthAnalyzerTest.php

@@ -4,20 +4,21 @@ declare(strict_types=1);
 
 namespace Intervention\Image\Tests\Unit\Drivers\Gd\Analyzers;
 
+use Intervention\Image\Drivers\Gd\Analyzers\WidthAnalyzer;
+use Intervention\Image\Drivers\Gd\Driver;
 use PHPUnit\Framework\Attributes\CoversClass;
 use PHPUnit\Framework\Attributes\RequiresPhpExtension;
-use Intervention\Image\Analyzers\WidthAnalyzer;
 use Intervention\Image\Tests\GdTestCase;
 
 #[RequiresPhpExtension('gd')]
-#[CoversClass(\Intervention\Image\Analyzers\WidthAnalyzer::class)]
-#[CoversClass(\Intervention\Image\Drivers\Imagick\Analyzers\WidthAnalyzer::class)]
+#[CoversClass(WidthAnalyzer::class)]
 final class WidthAnalyzerTest extends GdTestCase
 {
     public function testAnalyze(): void
     {
         $image = $this->readTestImage('tile.png');
         $analyzer = new WidthAnalyzer();
+        $analyzer->setDriver(new Driver());
         $result = $analyzer->analyze($image);
         $this->assertEquals(16, $result);
     }

tests/Unit/Drivers/Gd/ClonerTest.php

@@ -8,7 +8,11 @@ use Intervention\Image\Colors\Rgb\Color;
 use Intervention\Image\Drivers\Gd\Cloner;
 use Intervention\Image\Geometry\Rectangle;
 use Intervention\Image\Tests\BaseTestCase;
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\Attributes\RequiresPhpExtension;
 
+#[RequiresPhpExtension('gd')]
+#[CoversClass(Cloner::class)]
 final class ClonerTest extends BaseTestCase
 {
     public function testClone(): void

tests/Unit/Drivers/Gd/ColorProcessorTest.php

@@ -12,7 +12,11 @@ use Intervention\Image\Colors\Rgb\Color;
 use Intervention\Image\Drivers\Gd\ColorProcessor;
 use Intervention\Image\Exceptions\ColorException;
 use Intervention\Image\Tests\BaseTestCase;
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\Attributes\RequiresPhpExtension;
 
+#[RequiresPhpExtension('gd')]
+#[CoversClass(ColorProcessor::class)]
 final class ColorProcessorTest extends BaseTestCase
 {
     public function testColorToNative(): void

tests/Unit/Drivers/Gd/CoreTest.php

@@ -9,7 +9,11 @@ use Intervention\Image\Drivers\Gd\Core;
 use Intervention\Image\Drivers\Gd\Frame;
 use Intervention\Image\Exceptions\AnimationException;
 use Intervention\Image\Tests\BaseTestCase;
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\Attributes\RequiresPhpExtension;
 
+#[RequiresPhpExtension('gd')]
+#[CoversClass(Core::class)]
 final class CoreTest extends BaseTestCase
 {
     protected Core $core;

tests/Unit/Drivers/Gd/Decoders/AbstractDecoderTest.php

@@ -8,7 +8,11 @@ use Intervention\Image\Drivers\Gd\Decoders\AbstractDecoder;
 use Intervention\Image\MediaType;
 use Intervention\Image\Tests\BaseTestCase;
 use Mockery;
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\Attributes\RequiresPhpExtension;
 
+#[RequiresPhpExtension('gd')]
+#[CoversClass(AbstractDecoder::class)]
 final class AbstractDecoderTest extends BaseTestCase
 {
     public function testGetMediaTypeFromFilePath(): void

tests/Unit/Drivers/Gd/Decoders/Base64ImageDecoderTest.php

@@ -13,7 +13,7 @@ use Intervention\Image\Image;
 use Intervention\Image\Tests\BaseTestCase;
 
 #[RequiresPhpExtension('gd')]
-#[CoversClass(\Intervention\Image\Drivers\Gd\Decoders\Base64ImageDecoder::class)]
+#[CoversClass(Base64ImageDecoder::class)]
 final class Base64ImageDecoderTest extends BaseTestCase
 {
     protected Base64ImageDecoder $decoder;

tests/Unit/Drivers/Gd/Decoders/BinaryImageDecoderTest.php

@@ -12,7 +12,7 @@ use Intervention\Image\Image;
 use Intervention\Image\Tests\BaseTestCase;
 
 #[RequiresPhpExtension('gd')]
-#[CoversClass(\Intervention\Image\Drivers\Gd\Decoders\BinaryImageDecoder::class)]
+#[CoversClass(BinaryImageDecoder::class)]
 final class BinaryImageDecoderTest extends BaseTestCase
 {
     protected BinaryImageDecoder $decoder;

tests/Unit/Drivers/Gd/Decoders/DataUriImageDecoderTest.php

@@ -14,7 +14,7 @@ use Intervention\Image\Tests\BaseTestCase;
 use stdClass;
 
 #[RequiresPhpExtension('gd')]
-#[CoversClass(\Intervention\Image\Drivers\Gd\Decoders\DataUriImageDecoder::class)]
+#[CoversClass(DataUriImageDecoder::class)]
 final class DataUriImageDecoderTest extends BaseTestCase
 {
     protected DataUriImageDecoder $decoder;

tests/Unit/Drivers/Gd/Decoders/FilePathImageDecoderTest.php

@@ -15,7 +15,7 @@ use Intervention\Image\Tests\BaseTestCase;
 use PHPUnit\Framework\Attributes\DataProvider;
 
 #[RequiresPhpExtension('gd')]
-#[CoversClass(\Intervention\Image\Drivers\Gd\Decoders\FilePathImageDecoder::class)]
+#[CoversClass(FilePathImageDecoder::class)]
 final class FilePathImageDecoderTest extends BaseTestCase
 {
     protected FilePathImageDecoder $decoder;

tests/Unit/Drivers/Gd/Decoders/FilePointerImageDecoderTest.php

@@ -12,7 +12,7 @@ use Intervention\Image\Image;
 use Intervention\Image\Tests\GdTestCase;
 
 #[RequiresPhpExtension('gd')]
-#[CoversClass(\Intervention\Image\Drivers\Gd\Decoders\FilePointerImageDecoder::class)]
+#[CoversClass(FilePointerImageDecoder::class)]
 final class FilePointerImageDecoderTest extends GdTestCase
 {
     public function testDecode(): void

tests/Unit/Drivers/Gd/Decoders/ImageObjectDecoderTest.php

@@ -11,7 +11,7 @@ use Intervention\Image\Image;
 use Intervention\Image\Tests\GdTestCase;
 
 #[RequiresPhpExtension('gd')]
-#[CoversClass(\Intervention\Image\Decoders\ImageObjectDecoder::class)]
+#[CoversClass(ImageObjectDecoder::class)]
 final class ImageObjectDecoderTest extends GdTestCase
 {
     public function testDecode(): void

tests/Unit/Drivers/Gd/Decoders/SplFileInfoImageDecoderTest.php

@@ -13,7 +13,7 @@ use Intervention\Image\Tests\BaseTestCase;
 use SplFileInfo;
 
 #[RequiresPhpExtension('gd')]
-#[CoversClass(\Intervention\Image\Drivers\Gd\Decoders\SplFileInfoImageDecoder::class)]
+#[CoversClass(SplFileInfoImageDecoder::class)]
 final class SplFileInfoImageDecoderTest extends BaseTestCase
 {
     public function testDecode(): void

tests/Unit/Drivers/Gd/DriverTest.php

@@ -15,8 +15,12 @@ use Intervention\Image\Interfaces\ColorProcessorInterface;
 use Intervention\Image\Interfaces\ImageInterface;
 use Intervention\Image\MediaType;
 use Intervention\Image\Tests\BaseTestCase;
+use PHPUnit\Framework\Attributes\CoversClass;
 use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\Attributes\RequiresPhpExtension;
 
+#[RequiresPhpExtension('gd')]
+#[CoversClass(Driver::class)]
 final class DriverTest extends BaseTestCase
 {
     protected Driver $driver;

tests/Unit/Drivers/Gd/Encoders/AvifEncoderTest.php

@@ -4,14 +4,13 @@ declare(strict_types=1);
 
 namespace Intervention\Image\Tests\Unit\Drivers\Gd\Encoders;
 
+use Intervention\Image\Drivers\Gd\Encoders\AvifEncoder;
 use PHPUnit\Framework\Attributes\CoversClass;
 use PHPUnit\Framework\Attributes\RequiresPhpExtension;
-use Intervention\Image\Encoders\AvifEncoder;
 use Intervention\Image\Tests\GdTestCase;
 
 #[RequiresPhpExtension('gd')]
-#[CoversClass(\Intervention\Image\Encoders\AvifEncoder::class)]
-#[CoversClass(\Intervention\Image\Drivers\Gd\Encoders\AvifEncoder::class)]
+#[CoversClass(AvifEncoder::class)]
 final class AvifEncoderTest extends GdTestCase
 {
     public function testEncode(): void

tests/Unit/Drivers/Gd/Encoders/BmpEncoderTest.php

@@ -4,14 +4,13 @@ declare(strict_types=1);
 
 namespace Intervention\Image\Tests\Unit\Drivers\Gd\Encoders;
 
+use Intervention\Image\Drivers\Gd\Encoders\BmpEncoder;
 use PHPUnit\Framework\Attributes\CoversClass;
 use PHPUnit\Framework\Attributes\RequiresPhpExtension;
-use Intervention\Image\Encoders\BmpEncoder;
 use Intervention\Image\Tests\GdTestCase;
 
 #[RequiresPhpExtension('gd')]
-#[CoversClass(\Intervention\Image\Encoders\BmpEncoder::class)]
-#[CoversClass(\Intervention\Image\Drivers\Gd\Encoders\BmpEncoder::class)]
+#[CoversClass(BmpEncoder::class)]
 final class BmpEncoderTest extends GdTestCase
 {
     public function testEncode(): void

tests/Unit/Drivers/Gd/Encoders/GifEncoderTest.php

@@ -5,14 +5,13 @@ declare(strict_types=1);
 namespace Intervention\Image\Tests\Unit\Drivers\Gd\Encoders;
 
 use Intervention\Gif\Decoder;
+use Intervention\Image\Drivers\Gd\Encoders\GifEncoder;
 use PHPUnit\Framework\Attributes\CoversClass;
 use PHPUnit\Framework\Attributes\RequiresPhpExtension;
-use Intervention\Image\Encoders\GifEncoder;
 use Intervention\Image\Tests\GdTestCase;
 
 #[RequiresPhpExtension('gd')]
-#[CoversClass(\Intervention\Image\Encoders\GifEncoder::class)]
-#[CoversClass(\Intervention\Image\Drivers\Gd\Encoders\GifEncoder::class)]
+#[CoversClass(GifEncoder::class)]
 final class GifEncoderTest extends GdTestCase
 {
     public function testEncode(): void

tests/Unit/Drivers/Gd/Encoders/JpegEncoderTest.php

@@ -4,15 +4,15 @@ declare(strict_types=1);
 
 namespace Intervention\Image\Tests\Unit\Drivers\Gd\Encoders;
 
+use Intervention\Image\Drivers\Gd\Driver;
+use Intervention\Image\Drivers\Gd\Encoders\JpegEncoder;
 use PHPUnit\Framework\Attributes\CoversClass;
 use PHPUnit\Framework\Attributes\RequiresPhpExtension;
-use Intervention\Image\Encoders\JpegEncoder;
 use Intervention\Image\Tests\GdTestCase;
 use Intervention\Image\Tests\Traits\CanDetectProgressiveJpeg;
 
 #[RequiresPhpExtension('gd')]
-#[CoversClass(\Intervention\Image\Encoders\JpegEncoder::class)]
-#[CoversClass(\Intervention\Image\Drivers\Gd\Encoders\JpegEncoder::class)]
+#[CoversClass(JpegEncoder::class)]
 final class JpegEncoderTest extends GdTestCase
 {
     use CanDetectProgressiveJpeg;
@@ -21,6 +21,7 @@ final class JpegEncoderTest extends GdTestCase
     {
         $image = $this->createTestImage(3, 2);
         $encoder = new JpegEncoder(75);
+        $encoder->setDriver(new Driver());
         $result = $encoder->encode($image);
         $this->assertMediaType('image/jpeg', $result);
         $this->assertEquals('image/jpeg', $result->mimetype());
@@ -30,6 +31,7 @@ final class JpegEncoderTest extends GdTestCase
     {
         $image = $this->createTestImage(3, 2);
         $encoder = new JpegEncoder(progressive: true);
+        $encoder->setDriver(new Driver());
         $result = $encoder->encode($image);
         $this->assertMediaType('image/jpeg', $result);
         $this->assertEquals('image/jpeg', $result->mimetype());

tests/Unit/Drivers/Gd/Encoders/PngEncoderTest.php

@@ -5,17 +5,16 @@ declare(strict_types=1);
 namespace Intervention\Image\Tests\Unit\Drivers\Gd\Encoders;
 
 use Generator;
+use Intervention\Image\Drivers\Gd\Encoders\PngEncoder;
 use PHPUnit\Framework\Attributes\CoversClass;
 use PHPUnit\Framework\Attributes\RequiresPhpExtension;
-use Intervention\Image\Encoders\PngEncoder;
 use Intervention\Image\Interfaces\ImageInterface;
 use Intervention\Image\Tests\GdTestCase;
 use Intervention\Image\Tests\Traits\CanInspectPngFormat;
 use PHPUnit\Framework\Attributes\DataProvider;
 
 #[RequiresPhpExtension('gd')]
-#[CoversClass(\Intervention\Image\Encoders\PngEncoder::class)]
-#[CoversClass(\Intervention\Image\Drivers\Gd\Encoders\PngEncoder::class)]
+#[CoversClass(PngEncoder::class)]
 final class PngEncoderTest extends GdTestCase
 {
     use CanInspectPngFormat;

tests/Unit/Drivers/Gd/Encoders/WebpEncoderTest.php

@@ -4,14 +4,13 @@ declare(strict_types=1);
 
 namespace Intervention\Image\Tests\Unit\Drivers\Gd\Encoders;
 
+use Intervention\Image\Drivers\Gd\Encoders\WebpEncoder;
 use PHPUnit\Framework\Attributes\CoversClass;
 use PHPUnit\Framework\Attributes\RequiresPhpExtension;
-use Intervention\Image\Encoders\WebpEncoder;
 use Intervention\Image\Tests\GdTestCase;
 
 #[RequiresPhpExtension('gd')]
-#[CoversClass(\Intervention\Image\Encoders\WebpEncoder::class)]
-#[CoversClass(\Intervention\Image\Drivers\Gd\Encoders\WebpEncoder::class)]
+#[CoversClass(WebpEncoder::class)]
 final class WebpEncoderTest extends GdTestCase
 {
     public function testEncode(): void

tests/Unit/Drivers/Gd/FontProcessorTest.php

@@ -10,7 +10,11 @@ use Intervention\Image\Interfaces\SizeInterface;
 use Intervention\Image\Tests\BaseTestCase;
 use Intervention\Image\Typography\Font;
 use Intervention\Image\Typography\TextBlock;
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\Attributes\RequiresPhpExtension;
 
+#[RequiresPhpExtension('gd')]
+#[CoversClass(FontProcessor::class)]
 final class FontProcessorTest extends BaseTestCase
 {
     public function testBoxSizeGdOne(): void

tests/Unit/Drivers/Gd/FrameTest.php

@@ -14,7 +14,7 @@ use Intervention\Image\Geometry\Rectangle;
 use Intervention\Image\Tests\BaseTestCase;
 
 #[RequiresPhpExtension('gd')]
-#[CoversClass(\Intervention\Image\Drivers\Gd\Frame::class)]
+#[CoversClass(Frame::class)]
 final class FrameTest extends BaseTestCase
 {
     protected function getTestFrame(): Frame

tests/Unit/Drivers/Gd/ImageTest.php

@@ -25,7 +25,11 @@ use Intervention\Image\MediaType;
 use Intervention\Image\Modifiers\GreyscaleModifier;
 use Intervention\Image\Tests\GdTestCase;
 use Intervention\Image\Typography\Font;
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\Attributes\RequiresPhpExtension;
 
+#[RequiresPhpExtension('gd')]
+#[CoversClass(Image::class)]
 final class ImageTest extends GdTestCase
 {
     protected Image $image;

tests/Unit/Drivers/Imagick/Analyzers/ColorspaceAnalyzerTest.php

@@ -4,21 +4,22 @@ declare(strict_types=1);
 
 namespace Intervention\Image\Tests\Unit\Drivers\Imagick\Analyzers;
 
+use Intervention\Image\Drivers\Imagick\Analyzers\ColorspaceAnalyzer;
+use Intervention\Image\Drivers\Imagick\Driver;
 use PHPUnit\Framework\Attributes\CoversClass;
 use PHPUnit\Framework\Attributes\RequiresPhpExtension;
-use Intervention\Image\Analyzers\ColorspaceAnalyzer;
 use Intervention\Image\Interfaces\ColorspaceInterface;
 use Intervention\Image\Tests\ImagickTestCase;
 
 #[RequiresPhpExtension('imagick')]
-#[CoversClass(\Intervention\Image\Analyzers\ColorspaceAnalyzer::class)]
-#[CoversClass(\Intervention\Image\Drivers\Imagick\Analyzers\ColorspaceAnalyzer::class)]
+#[CoversClass(ColorspaceAnalyzer::class)]
 final class ColorspaceAnalyzerTest extends ImagickTestCase
 {
     public function testAnalyze(): void
     {
         $image = $this->readTestImage('tile.png');
         $analyzer = new ColorspaceAnalyzer();
+        $analyzer->setDriver(new Driver());
         $result = $analyzer->analyze($image);
         $this->assertInstanceOf(ColorspaceInterface::class, $result);
     }

tests/Unit/Drivers/Imagick/Analyzers/HeightAnalyzerTest.php

@@ -4,20 +4,21 @@ declare(strict_types=1);
 
 namespace Intervention\Image\Tests\Unit\Drivers\Imagick\Analyzers;
 
+use Intervention\Image\Drivers\Imagick\Analyzers\HeightAnalyzer;
+use Intervention\Image\Drivers\Imagick\Driver;
 use PHPUnit\Framework\Attributes\CoversClass;
 use PHPUnit\Framework\Attributes\RequiresPhpExtension;
-use Intervention\Image\Analyzers\HeightAnalyzer;
 use Intervention\Image\Tests\ImagickTestCase;
 
 #[RequiresPhpExtension('imagick')]
-#[CoversClass(\Intervention\Image\Analyzers\HeightAnalyzer::class)]
-#[CoversClass(\Intervention\Image\Drivers\Imagick\Analyzers\HeightAnalyzer::class)]
+#[CoversClass(HeightAnalyzer::class)]
 final class HeightAnalyzerTest extends ImagickTestCase
 {
     public function testAnalyze(): void
     {
         $image = $this->readTestImage('tile.png');
         $analyzer = new HeightAnalyzer();
+        $analyzer->setDriver(new Driver());
         $result = $analyzer->analyze($image);
         $this->assertEquals(16, $result);
     }

tests/Unit/Drivers/Imagick/Analyzers/PixelColorAnalyzerTest.php

@@ -4,21 +4,22 @@ declare(strict_types=1);
 
 namespace Intervention\Image\Tests\Unit\Drivers\Imagick\Analyzers;
 
+use Intervention\Image\Drivers\Imagick\Analyzers\PixelColorAnalyzer;
+use Intervention\Image\Drivers\Imagick\Driver;
 use PHPUnit\Framework\Attributes\CoversClass;
 use PHPUnit\Framework\Attributes\RequiresPhpExtension;
-use Intervention\Image\Analyzers\PixelColorAnalyzer;
 use Intervention\Image\Interfaces\ColorInterface;
 use Intervention\Image\Tests\ImagickTestCase;
 
 #[RequiresPhpExtension('imagick')]
-#[CoversClass(\Intervention\Image\Analyzers\PixelColorAnalyzer::class)]
-#[CoversClass(\Intervention\Image\Drivers\Imagick\Analyzers\PixelColorAnalyzer::class)]
+#[CoversClass(PixelColorAnalyzer::class)]
 final class PixelColorAnalyzerTest extends ImagickTestCase
 {
     public function testAnalyze(): void
     {
         $image = $this->readTestImage('tile.png');
         $analyzer = new PixelColorAnalyzer(0, 0);
+        $analyzer->setDriver(new Driver());
         $result = $analyzer->analyze($image);
         $this->assertInstanceOf(ColorInterface::class, $result);
         $this->assertEquals('b4e000', $result->toHex());

tests/Unit/Drivers/Imagick/Analyzers/PixelColorsAnalyzerTest.php

@@ -6,20 +6,21 @@ namespace Intervention\Image\Tests\Unit\Drivers\Imagick\Analyzers;
 
 use PHPUnit\Framework\Attributes\CoversClass;
 use PHPUnit\Framework\Attributes\RequiresPhpExtension;
-use Intervention\Image\Analyzers\PixelColorsAnalyzer;
 use Intervention\Image\Collection;
+use Intervention\Image\Drivers\Imagick\Analyzers\PixelColorsAnalyzer;
+use Intervention\Image\Drivers\Imagick\Driver;
 use Intervention\Image\Interfaces\ColorInterface;
 use Intervention\Image\Tests\ImagickTestCase;
 
 #[RequiresPhpExtension('imagick')]
-#[CoversClass(\Intervention\Image\Analyzers\PixelColorsAnalyzer::class)]
-#[CoversClass(\Intervention\Image\Drivers\Imagick\Analyzers\PixelColorsAnalyzer::class)]
+#[CoversClass(PixelColorsAnalyzer::class)]
 final class PixelColorsAnalyzerTest extends ImagickTestCase
 {
     public function testAnalyze(): void
     {
         $image = $this->readTestImage('tile.png');
         $analyzer = new PixelColorsAnalyzer(0, 0);
+        $analyzer->setDriver(new Driver());
         $result = $analyzer->analyze($image);
         $this->assertInstanceOf(Collection::class, $result);
         $this->assertInstanceOf(ColorInterface::class, $result->first());

tests/Unit/Drivers/Imagick/Analyzers/ProfileAnalyzerTest.php

@@ -4,21 +4,22 @@ declare(strict_types=1);
 
 namespace Intervention\Image\Tests\Unit\Drivers\Imagick\Analyzers;
 
+use Intervention\Image\Drivers\Imagick\Analyzers\ProfileAnalyzer;
+use Intervention\Image\Drivers\Imagick\Driver;
 use PHPUnit\Framework\Attributes\CoversClass;
 use PHPUnit\Framework\Attributes\RequiresPhpExtension;
-use Intervention\Image\Analyzers\ProfileAnalyzer;
 use Intervention\Image\Exceptions\ColorException;
 use Intervention\Image\Tests\ImagickTestCase;
 
 #[RequiresPhpExtension('imagick')]
-#[CoversClass(\Intervention\Image\Analyzers\ProfileAnalyzer::class)]
-#[CoversClass(\Intervention\Image\Drivers\Imagick\Analyzers\ProfileAnalyzer::class)]
+#[CoversClass(ProfileAnalyzer::class)]
 final class ProfileAnalyzerTest extends ImagickTestCase
 {
     public function testAnalyze(): void
     {
         $image = $this->readTestImage('tile.png');
         $analyzer = new ProfileAnalyzer();
+        $analyzer->setDriver(new Driver());
         $this->expectException(ColorException::class);
         $analyzer->analyze($image);
     }

tests/Unit/Drivers/Imagick/Analyzers/ResolutionAnalyzerTest.php

@@ -4,21 +4,22 @@ declare(strict_types=1);
 
 namespace Intervention\Image\Tests\Unit\Drivers\Imagick\Analyzers;
 
+use Intervention\Image\Drivers\Imagick\Analyzers\ResolutionAnalyzer;
 use PHPUnit\Framework\Attributes\CoversClass;
 use PHPUnit\Framework\Attributes\RequiresPhpExtension;
-use Intervention\Image\Analyzers\ResolutionAnalyzer;
+use Intervention\Image\Drivers\Imagick\Driver;
 use Intervention\Image\Resolution;
 use Intervention\Image\Tests\ImagickTestCase;
 
 #[RequiresPhpExtension('imagick')]
-#[CoversClass(\Intervention\Image\Analyzers\ResolutionAnalyzer::class)]
-#[CoversClass(\Intervention\Image\Drivers\Imagick\Analyzers\ResolutionAnalyzer::class)]
+#[CoversClass(ResolutionAnalyzer::class)]
 final class ResolutionAnalyzerTest extends ImagickTestCase
 {
     public function testAnalyze(): void
     {
         $image = $this->readTestImage('tile.png');
         $analyzer = new ResolutionAnalyzer();
+        $analyzer->setDriver(new Driver());
         $result = $analyzer->analyze($image);
         $this->assertInstanceOf(Resolution::class, $result);
     }

tests/Unit/Drivers/Imagick/Analyzers/WidthAnalyzerTest.php

@@ -4,20 +4,21 @@ declare(strict_types=1);
 
 namespace Intervention\Image\Tests\Unit\Drivers\Imagick\Analyzers;
 
+use Intervention\Image\Drivers\Imagick\Analyzers\WidthAnalyzer;
+use Intervention\Image\Drivers\Imagick\Driver;
 use PHPUnit\Framework\Attributes\CoversClass;
 use PHPUnit\Framework\Attributes\RequiresPhpExtension;
-use Intervention\Image\Analyzers\WidthAnalyzer;
 use Intervention\Image\Tests\ImagickTestCase;
 
 #[RequiresPhpExtension('imagick')]
-#[CoversClass(\Intervention\Image\Analyzers\WidthAnalyzer::class)]
-#[CoversClass(\Intervention\Image\Drivers\Imagick\Analyzers\WidthAnalyzer::class)]
+#[CoversClass(WidthAnalyzer::class)]
 final class WidthAnalyzerTest extends ImagickTestCase
 {
     public function testAnalyze(): void
     {
         $image = $this->readTestImage('tile.png');
         $analyzer = new WidthAnalyzer();
+        $analyzer->setDriver(new Driver());
         $result = $analyzer->analyze($image);
         $this->assertEquals(16, $result);
     }

tests/Unit/Drivers/Imagick/ColorProcessorTest.php

@@ -9,7 +9,11 @@ use Intervention\Image\Colors\Rgb\Color;
 use Intervention\Image\Colors\Rgb\Colorspace;
 use Intervention\Image\Drivers\Imagick\ColorProcessor;
 use Intervention\Image\Tests\BaseTestCase;
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\Attributes\RequiresPhpExtension;
 
+#[RequiresPhpExtension('imagick')]
+#[CoversClass(ColorProcessor::class)]
 final class ColorProcessorTest extends BaseTestCase
 {
     public function testColorToNative(): void

tests/Unit/Drivers/Imagick/CoreTest.php

@@ -10,7 +10,11 @@ use Intervention\Image\Drivers\Imagick\Core;
 use Intervention\Image\Drivers\Imagick\Frame;
 use Intervention\Image\Exceptions\AnimationException;
 use Intervention\Image\Tests\BaseTestCase;
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\Attributes\RequiresPhpExtension;
 
+#[RequiresPhpExtension('imagick')]
+#[CoversClass(Core::class)]
 final class CoreTest extends BaseTestCase
 {
     protected Core $core;

tests/Unit/Drivers/Imagick/Decoders/Base64ImageDecoderTest.php

@@ -13,7 +13,7 @@ use Intervention\Image\Image;
 use Intervention\Image\Tests\BaseTestCase;
 
 #[RequiresPhpExtension('imagick')]
-#[CoversClass(\Intervention\Image\Drivers\Imagick\Decoders\Base64ImageDecoder::class)]
+#[CoversClass(Base64ImageDecoder::class)]
 final class Base64ImageDecoderTest extends BaseTestCase
 {
     protected Base64ImageDecoder $decoder;

tests/Unit/Drivers/Imagick/Decoders/BinaryImageDecoderTest.php

@@ -11,8 +11,12 @@ use Intervention\Image\Drivers\Imagick\Driver;
 use Intervention\Image\Exceptions\DecoderException;
 use Intervention\Image\Image;
 use Intervention\Image\Tests\BaseTestCase;
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\Attributes\RequiresPhpExtension;
 use stdClass;
 
+#[RequiresPhpExtension('imagick')]
+#[CoversClass(BinaryImageDecoder::class)]
 final class BinaryImageDecoderTest extends BaseTestCase
 {
     protected BinaryImageDecoder $decoder;

tests/Unit/Drivers/Imagick/Decoders/DataUriImageDecoderTest.php

@@ -14,7 +14,7 @@ use Intervention\Image\Tests\BaseTestCase;
 use stdClass;
 
 #[RequiresPhpExtension('imagick')]
-#[CoversClass(\Intervention\Image\Drivers\Imagick\Decoders\DataUriImageDecoder::class)]
+#[CoversClass(DataUriImageDecoder::class)]
 final class DataUriImageDecoderTest extends BaseTestCase
 {
     protected DataUriImageDecoder $decoder;

tests/Unit/Drivers/Imagick/Decoders/FilePathImageDecoderTest.php

@@ -15,7 +15,7 @@ use Intervention\Image\Tests\BaseTestCase;
 use PHPUnit\Framework\Attributes\DataProvider;
 
 #[RequiresPhpExtension('imagick')]
-#[CoversClass(\Intervention\Image\Drivers\Imagick\Decoders\FilePathImageDecoder::class)]
+#[CoversClass(FilePathImageDecoder::class)]
 final class FilePathImageDecoderTest extends BaseTestCase
 {
     protected FilePathImageDecoder $decoder;

tests/Unit/Drivers/Imagick/Decoders/FilePointerImageDecoderTest.php

@@ -12,7 +12,7 @@ use Intervention\Image\Image;
 use Intervention\Image\Tests\ImagickTestCase;
 
 #[RequiresPhpExtension('imagick')]
-#[CoversClass(\Intervention\Image\Drivers\Imagick\Decoders\FilePointerImageDecoder::class)]
+#[CoversClass(FilePointerImageDecoder::class)]
 final class FilePointerImageDecoderTest extends ImagickTestCase
 {
     public function testDecode(): void

tests/Unit/Drivers/Imagick/Decoders/ImageObjectDecoderTest.php

@@ -11,7 +11,7 @@ use Intervention\Image\Image;
 use Intervention\Image\Tests\ImagickTestCase;
 
 #[RequiresPhpExtension('imagick')]
-#[CoversClass(\Intervention\Image\Decoders\ImageObjectDecoder::class)]
+#[CoversClass(ImageObjectDecoder::class)]
 final class ImageObjectDecoderTest extends ImagickTestCase
 {
     public function testDecode(): void

tests/Unit/Drivers/Imagick/Decoders/SplFileInfoImageDecoderTest.php

@@ -13,7 +13,7 @@ use Intervention\Image\Tests\BaseTestCase;
 use SplFileInfo;
 
 #[RequiresPhpExtension('imagick')]
-#[CoversClass(\Intervention\Image\Drivers\Imagick\Decoders\SplFileInfoImageDecoder::class)]
+#[CoversClass(SplFileInfoImageDecoder::class)]
 final class SplFileInfoImageDecoderTest extends BaseTestCase
 {
     public function testDecode(): void

tests/Unit/Drivers/Imagick/DriverTest.php

@@ -15,8 +15,12 @@ use Intervention\Image\Interfaces\ColorProcessorInterface;
 use Intervention\Image\Interfaces\ImageInterface;
 use Intervention\Image\MediaType;
 use Intervention\Image\Tests\BaseTestCase;
+use PHPUnit\Framework\Attributes\CoversClass;
 use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\Attributes\RequiresPhpExtension;
 
+#[RequiresPhpExtension('imagick')]
+#[CoversClass(Driver::class)]
 final class DriverTest extends BaseTestCase
 {
     protected Driver $driver;

tests/Unit/Drivers/Imagick/Encoders/AvifEncoderTest.php

@@ -4,14 +4,13 @@ declare(strict_types=1);
 
 namespace Intervention\Image\Tests\Unit\Drivers\Imagick\Encoders;
 
+use Intervention\Image\Drivers\Imagick\Encoders\AvifEncoder;
 use PHPUnit\Framework\Attributes\CoversClass;
 use PHPUnit\Framework\Attributes\RequiresPhpExtension;
-use Intervention\Image\Encoders\AvifEncoder;
 use Intervention\Image\Tests\ImagickTestCase;
 
 #[RequiresPhpExtension('imagick')]
-#[CoversClass(\Intervention\Image\Encoders\AvifEncoder::class)]
-#[CoversClass(\Intervention\Image\Drivers\Imagick\Encoders\AvifEncoder::class)]
+#[CoversClass(AvifEncoder::class)]
 final class AvifEncoderTest extends ImagickTestCase
 {
     public function testEncode(): void

tests/Unit/Drivers/Imagick/Encoders/BmpEncoderTest.php

@@ -4,14 +4,13 @@ declare(strict_types=1);
 
 namespace Intervention\Image\Tests\Unit\Drivers\Imagick\Encoders;
 
+use Intervention\Image\Drivers\Imagick\Encoders\BmpEncoder;
 use PHPUnit\Framework\Attributes\CoversClass;
 use PHPUnit\Framework\Attributes\RequiresPhpExtension;
-use Intervention\Image\Encoders\BmpEncoder;
 use Intervention\Image\Tests\ImagickTestCase;
 
 #[RequiresPhpExtension('imagick')]
-#[CoversClass(\Intervention\Image\Encoders\BmpEncoder::class)]
-#[CoversClass(\Intervention\Image\Drivers\Imagick\Encoders\BmpEncoder::class)]
+#[CoversClass(BmpEncoder::class)]
 final class BmpEncoderTest extends ImagickTestCase
 {
     public function testEncode(): void

tests/Unit/Drivers/Imagick/Encoders/GifEncoderTest.php

@@ -5,14 +5,13 @@ declare(strict_types=1);
 namespace Intervention\Image\Tests\Unit\Drivers\Imagick\Encoders;
 
 use Intervention\Gif\Decoder;
+use Intervention\Image\Drivers\Imagick\Encoders\GifEncoder;
 use PHPUnit\Framework\Attributes\CoversClass;
 use PHPUnit\Framework\Attributes\RequiresPhpExtension;
-use Intervention\Image\Encoders\GifEncoder;
 use Intervention\Image\Tests\ImagickTestCase;
 
 #[RequiresPhpExtension('imagick')]
-#[CoversClass(\Intervention\Image\Encoders\GifEncoder::class)]
-#[CoversClass(\Intervention\Image\Drivers\Imagick\Encoders\GifEncoder::class)]
+#[CoversClass(GifEncoder::class)]
 final class GifEncoderTest extends ImagickTestCase
 {
     public function testEncode(): void

tests/Unit/Drivers/Imagick/Encoders/HeicEncoderTest.php

@@ -4,14 +4,13 @@ declare(strict_types=1);
 
 namespace Intervention\Image\Tests\Unit\Drivers\Imagick\Encoders;
 
+use Intervention\Image\Drivers\Imagick\Encoders\HeicEncoder;
 use PHPUnit\Framework\Attributes\CoversClass;
 use PHPUnit\Framework\Attributes\RequiresPhpExtension;
-use Intervention\Image\Encoders\HeicEncoder;
 use Intervention\Image\Tests\ImagickTestCase;
 
 #[RequiresPhpExtension('imagick')]
-#[CoversClass(\Intervention\Image\Encoders\HeicEncoder::class)]
-#[CoversClass(\Intervention\Image\Drivers\Imagick\Encoders\HeicEncoder::class)]
+#[CoversClass(HeicEncoder::class)]
 final class HeicEncoderTest extends ImagickTestCase
 {
     public function testEncode(): void

tests/Unit/Drivers/Imagick/Encoders/Jpeg2000EncoderTest.php

@@ -4,14 +4,13 @@ declare(strict_types=1);
 
 namespace Intervention\Image\Tests\Unit\Drivers\Imagick\Encoders;
 
+use Intervention\Image\Drivers\Imagick\Encoders\Jpeg2000Encoder;
 use PHPUnit\Framework\Attributes\CoversClass;
 use PHPUnit\Framework\Attributes\RequiresPhpExtension;
-use Intervention\Image\Encoders\Jpeg2000Encoder;
 use Intervention\Image\Tests\ImagickTestCase;
 
 #[RequiresPhpExtension('imagick')]
-#[CoversClass(\Intervention\Image\Encoders\Jpeg2000Encoder::class)]
-#[CoversClass(\Intervention\Image\Drivers\Imagick\Encoders\Jpeg2000Encoder::class)]
+#[CoversClass(Jpeg2000Encoder::class)]
 final class Jpeg2000EncoderTest extends ImagickTestCase
 {
     public function testEncode(): void

tests/Unit/Drivers/Imagick/Encoders/JpegEncoderTest.php

@@ -4,15 +4,15 @@ declare(strict_types=1);
 
 namespace Intervention\Image\Tests\Unit\Drivers\Imagick\Encoders;
 
+use Intervention\Image\Drivers\Imagick\Driver;
+use Intervention\Image\Drivers\Imagick\Encoders\JpegEncoder;
 use PHPUnit\Framework\Attributes\CoversClass;
 use PHPUnit\Framework\Attributes\RequiresPhpExtension;
-use Intervention\Image\Encoders\JpegEncoder;
 use Intervention\Image\Tests\ImagickTestCase;
 use Intervention\Image\Tests\Traits\CanDetectProgressiveJpeg;
 
 #[RequiresPhpExtension('imagick')]
-#[CoversClass(\Intervention\Image\Encoders\JpegEncoder::class)]
-#[CoversClass(\Intervention\Image\Drivers\Imagick\Encoders\JpegEncoder::class)]
+#[CoversClass(JpegEncoder::class)]
 final class JpegEncoderTest extends ImagickTestCase
 {
     use CanDetectProgressiveJpeg;
@@ -21,6 +21,7 @@ final class JpegEncoderTest extends ImagickTestCase
     {
         $image = $this->createTestImage(3, 2);
         $encoder = new JpegEncoder(75);
+        $encoder->setDriver(new Driver());
         $result = $encoder->encode($image);
         $this->assertMediaType('image/jpeg', $result);
         $this->assertEquals('image/jpeg', $result->mimetype());
@@ -30,6 +31,7 @@ final class JpegEncoderTest extends ImagickTestCase
     {
         $image = $this->createTestImage(3, 2);
         $encoder = new JpegEncoder(progressive: true);
+        $encoder->setDriver(new Driver());
         $result = $encoder->encode($image);
         $this->assertMediaType('image/jpeg', $result);
         $this->assertEquals('image/jpeg', $result->mimetype());

tests/Unit/Drivers/Imagick/Encoders/PngEncoderTest.php

@@ -5,17 +5,16 @@ declare(strict_types=1);
 namespace Intervention\Image\Tests\Unit\Drivers\Imagick\Encoders;
 
 use Generator;
+use Intervention\Image\Drivers\Imagick\Encoders\PngEncoder;
 use PHPUnit\Framework\Attributes\CoversClass;
 use PHPUnit\Framework\Attributes\RequiresPhpExtension;
-use Intervention\Image\Encoders\PngEncoder;
 use Intervention\Image\Interfaces\ImageInterface;
 use Intervention\Image\Tests\ImagickTestCase;
 use Intervention\Image\Tests\Traits\CanInspectPngFormat;
 use PHPUnit\Framework\Attributes\DataProvider;
 
 #[RequiresPhpExtension('imagick')]
-#[CoversClass(\Intervention\Image\Encoders\PngEncoder::class)]
-#[CoversClass(\Intervention\Image\Drivers\Imagick\Encoders\PngEncoder::class)]
+#[CoversClass(PngEncoder::class)]
 final class PngEncoderTest extends ImagickTestCase
 {
     use CanInspectPngFormat;

tests/Unit/Drivers/Imagick/Encoders/TiffEncoderTest.php

@@ -4,14 +4,13 @@ declare(strict_types=1);
 
 namespace Intervention\Image\Tests\Unit\Drivers\Imagick\Encoders;
 
+use Intervention\Image\Drivers\Imagick\Encoders\TiffEncoder;
 use PHPUnit\Framework\Attributes\CoversClass;
 use PHPUnit\Framework\Attributes\RequiresPhpExtension;
-use Intervention\Image\Encoders\TiffEncoder;
 use Intervention\Image\Tests\ImagickTestCase;
 
 #[RequiresPhpExtension('imagick')]
-#[CoversClass(\Intervention\Image\Encoders\TiffEncoder::class)]
-#[CoversClass(\Intervention\Image\Drivers\Imagick\Encoders\TiffEncoder::class)]
+#[CoversClass(TiffEncoder::class)]
 final class TiffEncoderTest extends ImagickTestCase
 {
     public function testEncode(): void

tests/Unit/Drivers/Imagick/Encoders/WebpEncoderTest.php

@@ -4,14 +4,13 @@ declare(strict_types=1);
 
 namespace Intervention\Image\Tests\Unit\Drivers\Imagick\Encoders;
 
+use Intervention\Image\Drivers\Imagick\Encoders\WebpEncoder;
 use PHPUnit\Framework\Attributes\CoversClass;
 use PHPUnit\Framework\Attributes\RequiresPhpExtension;
-use Intervention\Image\Encoders\WebpEncoder;
 use Intervention\Image\Tests\ImagickTestCase;
 
 #[RequiresPhpExtension('imagick')]
-#[CoversClass(\Intervention\Image\Encoders\WebpEncoder::class)]
-#[CoversClass(\Intervention\Image\Drivers\Imagick\Encoders\WebpEncoder::class)]
+#[CoversClass(WebpEncoder::class)]
 final class WebpEncoderTest extends ImagickTestCase
 {
     public function testEncode(): void

tests/Unit/Drivers/Imagick/FontProcessorTest.php

@@ -10,7 +10,11 @@ use Intervention\Image\Interfaces\SizeInterface;
 use Intervention\Image\Tests\BaseTestCase;
 use Intervention\Image\Typography\Font;
 use Intervention\Image\Typography\TextBlock;
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\Attributes\RequiresPhpExtension;
 
+#[RequiresPhpExtension('imagick')]
+#[CoversClass(FontProcessor::class)]
 final class FontProcessorTest extends BaseTestCase
 {
     public function testBoxSizeTtf(): void

tests/Unit/Drivers/Imagick/FrameTest.php

@@ -15,7 +15,7 @@ use Intervention\Image\Geometry\Rectangle;
 use Intervention\Image\Tests\BaseTestCase;
 
 #[RequiresPhpExtension('imagick')]
-#[CoversClass(\Intervention\Image\Drivers\Imagick\Frame::class)]
+#[CoversClass(Frame::class)]
 final class FrameTest extends BaseTestCase
 {
     protected function getTestFrame(): Frame

tests/Unit/Drivers/Imagick/ImageTest.php

@@ -25,7 +25,11 @@ use Intervention\Image\Interfaces\SizeInterface;
 use Intervention\Image\Modifiers\GreyscaleModifier;
 use Intervention\Image\Origin;
 use Intervention\Image\Tests\ImagickTestCase;
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\Attributes\RequiresPhpExtension;
 
+#[RequiresPhpExtension('imagick')]
+#[CoversClass(Image::class)]
 final class ImageTest extends ImagickTestCase
 {
     protected Image $image;

tests/Unit/Drivers/SpecializableAnalyzerTest.php

@@ -8,10 +8,12 @@ use Intervention\Image\Drivers\SpecializableAnalyzer;
 use Intervention\Image\Interfaces\ImageInterface;
 use Intervention\Image\Tests\BaseTestCase;
 use Mockery;
+use PHPUnit\Framework\Attributes\CoversClass;
 
+#[CoversClass(SpecializableAnalyzer::class)]
 final class SpecializableAnalyzerTest extends BaseTestCase
 {
-    public function testAnalyzer(): void
+    public function testAnalyze(): void
     {
         $analyzer = Mockery::mock(SpecializableAnalyzer::class)->makePartial();
         $image = Mockery::mock(ImageInterface::class);

tests/Unit/Drivers/SpecializableDecoderTest.php

@@ -8,7 +8,9 @@ use Intervention\Image\Drivers\SpecializableDecoder;
 use Intervention\Image\Exceptions\DecoderException;
 use Intervention\Image\Tests\BaseTestCase;
 use Mockery;
+use PHPUnit\Framework\Attributes\CoversClass;
 
+#[CoversClass(SpecializableDecoder::class)]
 final class SpecializableDecoderTest extends BaseTestCase
 {
     public function testDecode(): void

tests/Unit/Drivers/SpecializableModifierTest.php

@@ -8,7 +8,9 @@ use Intervention\Image\Drivers\SpecializableModifier;
 use Intervention\Image\Interfaces\ImageInterface;
 use Intervention\Image\Tests\BaseTestCase;
 use Mockery;
+use PHPUnit\Framework\Attributes\CoversClass;
 
+#[CoversClass(SpecializableModifier::class)]
 final class SpecializableModifierTest extends BaseTestCase
 {
     public function testApply(): void

tests/Unit/EncodedImageTest.php

@@ -8,7 +8,7 @@ use PHPUnit\Framework\Attributes\CoversClass;
 use Intervention\Image\EncodedImage;
 use Intervention\Image\Tests\BaseTestCase;
 
-#[CoversClass(\Intervention\Image\EncodedImage::class)]
+#[CoversClass(EncodedImage::class)]
 final class EncodedImageTest extends BaseTestCase
 {
     public function testConstructor(): void

tests/Unit/Encoders/FileExtensionEncoderTest.php

@@ -19,8 +19,10 @@ use Intervention\Image\Exceptions\EncoderException;
 use Intervention\Image\FileExtension;
 use Intervention\Image\Interfaces\EncoderInterface;
 use Intervention\Image\Tests\BaseTestCase;
+use PHPUnit\Framework\Attributes\CoversClass;
 use PHPUnit\Framework\Attributes\DataProvider;
 
+#[CoversClass(FileExtensionEncoder::class)]
 final class FileExtensionEncoderTest extends BaseTestCase
 {
     private function testEncoder(string|FileExtension $extension, array $options = []): EncoderInterface

tests/Unit/Encoders/MediaTypeEncoderTest.php

@@ -19,8 +19,10 @@ use Intervention\Image\Exceptions\EncoderException;
 use Intervention\Image\Interfaces\EncoderInterface;
 use Intervention\Image\MediaType;
 use Intervention\Image\Tests\BaseTestCase;
+use PHPUnit\Framework\Attributes\CoversClass;
 use PHPUnit\Framework\Attributes\DataProvider;
 
+#[CoversClass(MediaTypeEncoder::class)]
 final class MediaTypeEncoderTest extends BaseTestCase
 {
     private function testEncoder(string|MediaType $mediaType, array $options = []): EncoderInterface

tests/Unit/FileExtensionTest.php

@@ -9,8 +9,10 @@ use Intervention\Image\FileExtension;
 use Intervention\Image\Format;
 use Intervention\Image\MediaType;
 use Intervention\Image\Tests\BaseTestCase;
+use PHPUnit\Framework\Attributes\CoversClass;
 use PHPUnit\Framework\Attributes\DataProvider;
 
+#[CoversClass(FileExtension::class)]
 final class FileExtensionTest extends BaseTestCase
 {
     public function testFormatJpeg(): void

tests/Unit/FileTest.php

@@ -8,7 +8,7 @@ use PHPUnit\Framework\Attributes\CoversClass;
 use Intervention\Image\File;
 use Intervention\Image\Tests\BaseTestCase;
 
-#[CoversClass(\Intervention\Image\File::class)]
+#[CoversClass(File::class)]
 final class FileTest extends BaseTestCase
 {
     public function testConstructor(): void

tests/Unit/FormatTest.php

@@ -18,7 +18,9 @@ use Intervention\Image\FileExtension;
 use Intervention\Image\Format;
 use Intervention\Image\MediaType;
 use Intervention\Image\Tests\BaseTestCase;
+use PHPUnit\Framework\Attributes\CoversClass;
 
+#[CoversClass(Format::class)]
 final class FormatTest extends BaseTestCase
 {
     public function testCreate(): void

tests/Unit/Geometry/BezierTest.php

@@ -9,7 +9,7 @@ use Intervention\Image\Geometry\Point;
 use Intervention\Image\Geometry\Bezier;
 use Intervention\Image\Tests\BaseTestCase;
 
-#[CoversClass(\Intervention\Image\Geometry\Bezier::class)]
+#[CoversClass(Bezier::class)]
 final class BezierTest extends BaseTestCase
 {
     public function testConstructor(): void

tests/Unit/Geometry/CircleTest.php

@@ -7,7 +7,9 @@ namespace Intervention\Image\Tests\Unit\Geometry;
 use Intervention\Image\Geometry\Circle;
 use Intervention\Image\Geometry\Point;
 use Intervention\Image\Tests\BaseTestCase;
+use PHPUnit\Framework\Attributes\CoversClass;
 
+#[CoversClass(Circle::class)]
 final class CircleTest extends BaseTestCase
 {
     public function testConstructor(): void

tests/Unit/Geometry/EllipseTest.php

@@ -7,7 +7,9 @@ namespace Intervention\Image\Tests\Unit\Geometry;
 use Intervention\Image\Geometry\Ellipse;
 use Intervention\Image\Geometry\Point;
 use Intervention\Image\Tests\BaseTestCase;
+use PHPUnit\Framework\Attributes\CoversClass;
 
+#[CoversClass(Ellipse::class)]
 final class EllipseTest extends BaseTestCase
 {
     public function testConstructor(): void

tests/Unit/Geometry/Factories/BezierFactoryTest.php

@@ -7,7 +7,9 @@ namespace Intervention\Image\Tests\Unit\Geometry\Factories;
 use Intervention\Image\Geometry\Factories\BezierFactory;
 use Intervention\Image\Geometry\Bezier;
 use Intervention\Image\Tests\BaseTestCase;
+use PHPUnit\Framework\Attributes\CoversClass;
 
+#[CoversClass(BezierFactory::class)]
 final class BezierFactoryTest extends BaseTestCase
 {
     public function testFactoryCallback(): void

tests/Unit/Geometry/Factories/CircleFactoryTest.php

@@ -8,7 +8,9 @@ use Intervention\Image\Geometry\Ellipse;
 use Intervention\Image\Geometry\Factories\CircleFactory;
 use Intervention\Image\Geometry\Point;
 use Intervention\Image\Tests\BaseTestCase;
+use PHPUnit\Framework\Attributes\CoversClass;
 
+#[CoversClass(CircleFactory::class)]
 final class CircleFactoryTest extends BaseTestCase
 {
     public function testFactoryCallback(): void

tests/Unit/Geometry/Factories/DrawableTest.php

@@ -12,7 +12,9 @@ use Intervention\Image\Geometry\Factories\LineFactory;
 use Intervention\Image\Geometry\Factories\PolygonFactory;
 use Intervention\Image\Geometry\Factories\RectangleFactory;
 use Intervention\Image\Tests\BaseTestCase;
+use PHPUnit\Framework\Attributes\CoversClass;
 
+#[CoversClass(BezierFactory::class)]
 final class DrawableTest extends BaseTestCase
 {
     public function testBezier(): void

tests/Unit/Geometry/Factories/EllipseFactoryTest.php

@@ -8,7 +8,9 @@ use Intervention\Image\Geometry\Ellipse;
 use Intervention\Image\Geometry\Factories\EllipseFactory;
 use Intervention\Image\Geometry\Point;
 use Intervention\Image\Tests\BaseTestCase;
+use PHPUnit\Framework\Attributes\CoversClass;
 
+#[CoversClass(EllipseFactory::class)]
 final class EllipseFactoryTest extends BaseTestCase
 {
     public function testFactoryCallback(): void

tests/Unit/Geometry/Factories/LineFactoryTest.php

@@ -7,7 +7,9 @@ namespace Intervention\Image\Tests\Unit\Geometry\Factories;
 use Intervention\Image\Geometry\Factories\LineFactory;
 use Intervention\Image\Geometry\Line;
 use Intervention\Image\Tests\BaseTestCase;
+use PHPUnit\Framework\Attributes\CoversClass;
 
+#[CoversClass(LineFactory::class)]
 final class LineFactoryTest extends BaseTestCase
 {
     public function testFactoryCallback(): void

tests/Unit/Geometry/Factories/PolygonFactoryTest.php

@@ -7,7 +7,9 @@ namespace Intervention\Image\Tests\Unit\Geometry\Factories;
 use Intervention\Image\Geometry\Factories\PolygonFactory;
 use Intervention\Image\Geometry\Polygon;
 use Intervention\Image\Tests\BaseTestCase;
+use PHPUnit\Framework\Attributes\CoversClass;
 
+#[CoversClass(PolygonFactory::class)]
 final class PolygonFactoryTest extends BaseTestCase
 {
     public function testFactoryCallback(): void