diff --git a/README.md b/README.md
index a0a0ac1..0d12536 100644
--- a/README.md
+++ b/README.md
@@ -68,7 +68,6 @@ composer require okapi/code-transformer
 - [Limitations](#limitations)
 - [How it works](#how-it-works)
 - [Testing](#testing)
-- [TODO](#todo)
 
 
 
@@ -332,18 +331,6 @@ Give a ⭐ if this project helped you!
 
 
 
-## TODO
-
-- Add support for Production/Development environments:
-  - Production: Cache will not be checked for updates (better performance)
-  - Development: Cache will be checked for updates (better debugging experience)
-
-- Create a flowchart (WIP)
-
-- Cache lifetime
-
-
-
 ## 🙏 Thanks
 
 - Big thanks to [lisachenko](https://github.com/lisachenko) for their pioneering
diff --git a/composer.json b/composer.json
index 5e0fc3f..e54767b 100644
--- a/composer.json
+++ b/composer.json
@@ -1,7 +1,7 @@
 {
     "name": "okapi/code-transformer",
     "description": "PHP Code Transformer is a PHP library that allows you to modify and transform the source code of a loaded PHP class.",
-    "version": "1.3.3",
+    "version": "1.3.4",
     "type": "library",
     "homepage": "https://github.com/okapi-web/php-code-transformer",
     "license": "MIT",
diff --git a/src/CodeTransformerKernel.php b/src/CodeTransformerKernel.php
index 17616fc..6481c7c 100644
--- a/src/CodeTransformerKernel.php
+++ b/src/CodeTransformerKernel.php
@@ -2,6 +2,7 @@
 
 namespace Okapi\CodeTransformer;
 
+use Closure;
 use DI\Attribute\Inject;
 use Okapi\CodeTransformer\Core\AutoloadInterceptor;
 use Okapi\CodeTransformer\Core\Cache\CacheStateManager;
@@ -160,7 +161,7 @@ public static function init(): void
     }
 
     /**
-     * Register the dependency injection.
+     * Internal dependency injection.
      *
      * @return void
      */
@@ -199,22 +200,31 @@ protected function configureOptions(): void
     }
 
     /**
-     * Register the services.
+     * Custom dependency injection handler.
      *
-     * @return void
+     * Pass a closure that takes a transformer class name as the argument and
+     * returns a transformer instance.
+     *
+     * @return null|Closure(class-string<Transformer>): Transformer
      */
+    protected function dependencyInjectionHandler(): ?Closure
+    {
+        // Override this method to configure the dependency injection handler
+
+        return null;
+    }
+
     protected function registerServices(): void
     {
-        // Options provider
         $this->options->register();
 
-        // Manage the user-defined transformers
+        $this->transformerManager->registerCustomDependencyInjectionHandler(
+            $this->dependencyInjectionHandler()
+        );
         $this->transformerManager->register();
 
-        // Cache path manager
         $this->cacheStateManager->register();
 
-        // Stream filter -> Source transformer
         $this->streamFilter->register();
     }
 
diff --git a/src/Core/AutoloadInterceptor/ClassLoader.php b/src/Core/AutoloadInterceptor/ClassLoader.php
index 38b9280..4543c12 100644
--- a/src/Core/AutoloadInterceptor/ClassLoader.php
+++ b/src/Core/AutoloadInterceptor/ClassLoader.php
@@ -86,6 +86,7 @@ public function loadClass($namespacedClass): bool
      * @return false|string
      *
      * @noinspection PhpParameterNameChangedDuringInheritanceInspection
+     * @noinspection PhpStatementHasEmptyBodyInspection
      */
     public function findFile($namespacedClass): false|string
     {
diff --git a/src/Core/Cache/CacheStateManager.php b/src/Core/Cache/CacheStateManager.php
index 4c86a7e..97587a3 100644
--- a/src/Core/Cache/CacheStateManager.php
+++ b/src/Core/Cache/CacheStateManager.php
@@ -89,8 +89,14 @@ public function register(): void
      */
     private function initializeCacheDirectory(): void
     {
+        $cacheDir = $this->options->getCacheDir();
+
+        if (file_exists($cacheDir)) {
+            return;
+        }
+
         Filesystem::mkdir(
-            $this->options->getCacheDir(),
+            $cacheDir,
             $this->options->getCacheFileMode(),
             recursive: true,
         );
@@ -185,7 +191,7 @@ private function saveCacheState(): void
         // Create the cache state array
         $cacheStateArray = array_map(
             fn (CacheState $cacheState) => $cacheState->toArray(),
-            array_merge($this->newCacheState, $this->cacheState),
+            array_merge($this->cacheState, $this->newCacheState),
         );
 
         // Set the hash
diff --git a/src/Core/Container/TransformerManager.php b/src/Core/Container/TransformerManager.php
index bdcc64f..f6e48a6 100644
--- a/src/Core/Container/TransformerManager.php
+++ b/src/Core/Container/TransformerManager.php
@@ -2,10 +2,12 @@
 /** @noinspection PhpPropertyOnlyWrittenInspection */
 namespace Okapi\CodeTransformer\Core\Container;
 
+use Closure;
 use Error;
 use Exception;
 use Okapi\CodeTransformer\Core\DI;
 use Okapi\CodeTransformer\Core\Exception\Transformer\InvalidTransformerClassException;
+use Okapi\CodeTransformer\Core\Exception\Transformer\InvalidTransformerClassNameException;
 use Okapi\CodeTransformer\Core\Exception\Transformer\TransformerNotFoundException;
 use Okapi\CodeTransformer\Core\ServiceInterface;
 use Okapi\CodeTransformer\Transformer;
@@ -32,6 +34,11 @@ class TransformerManager implements ServiceInterface
      */
     private array $transformerContainers = [];
 
+    /**
+     * @var ?Closure(class-string<Transformer>): Transformer
+     */
+    private ?Closure $dependencyInjectionHandler = null;
+
     // region Pre-Initialization
 
     /**
@@ -54,51 +61,73 @@ public function addTransformers(array $transformers): void
     // region Initialization
 
     /**
-     * Register the transformer container.
-     *
-     * @return void
+     * @param null|(Closure(class-string<Transformer>): Transformer) $dependencyInjectionHandler
      */
+    public function registerCustomDependencyInjectionHandler(
+        ?Closure $dependencyInjectionHandler
+    ): void {
+        $this->dependencyInjectionHandler = $dependencyInjectionHandler;
+    }
+
     public function register(): void
     {
         $this->loadTransformers();
     }
 
+    private function loadTransformers(): void
+    {
+        foreach ($this->transformers as $transformer) {
+            $this->loadTransformer($transformer);
+        }
+    }
+
     /**
-     * Get the transformer instances.
-     *
-     * @return void
+     * @param class-string<Transformer> $transformerClassName
      *
      * @noinspection PhpUnhandledExceptionInspection
      * @noinspection PhpDocMissingThrowsInspection
      */
-    private function loadTransformers(): void
+    private function loadTransformer(mixed $transformerClassName): void
     {
-        foreach ($this->transformers as $transformer) {
-            // Instantiate the transformer
+        // Check if the transformer is already loaded
+        if (array_key_exists($transformerClassName, $this->transformerContainers)) {
+            // @codeCoverageIgnoreStart
+            return;
+            // @codeCoverageIgnoreEnd
+        }
+
+        // Validate the transformer
+        if (gettype($transformerClassName) !== 'string') {
+            throw new InvalidTransformerClassNameException;
+        }
+
+        // Instantiate the transformer
+        if ($this->dependencyInjectionHandler) {
+            $transformerInstance = ($this->dependencyInjectionHandler)($transformerClassName);
+        } else {
             try {
-                $transformerInstance = DI::make($transformer);
+                $transformerInstance = DI::make($transformerClassName);
             } catch (Error|Exception) {
-                throw new TransformerNotFoundException($transformer);
+                throw new TransformerNotFoundException($transformerClassName);
             }
+        }
 
-            // Validate the transformer
-            $isTransformer = $transformerInstance instanceof Transformer;
-            if (!$isTransformer) {
-                throw new InvalidTransformerClassException($transformer);
-            }
-            assert($transformerInstance instanceof Transformer);
+        // Validate the transformer
+        $isTransformer = $transformerInstance instanceof Transformer;
+        if (!$isTransformer) {
+            throw new InvalidTransformerClassException($transformerClassName);
+        }
 
-            // Create transformer container
-            $transformerContainer = DI::make(TransformerContainer::class, [
-                'transformerInstance' => $transformerInstance,
-            ]);
+        // Create transformer container
+        $transformerContainer = DI::make(TransformerContainer::class, [
+            'transformerInstance' => $transformerInstance,
+        ]);
 
-            // Create a reflection of the transformer
-            $transformerRefClass = new BaseReflectionClass($transformerInstance);
+        // Create a reflection of the transformer
+        $transformerRefClass = new BaseReflectionClass($transformerInstance);
 
-            $filePath = $transformerRefClass->getFileName();
-            $this->transformerContainers[$filePath] = $transformerContainer;
-        }
+        $filePath = $transformerRefClass->getFileName();
+        $this->transformerContainers[$filePath] = $transformerContainer;
     }
 
     // endregion
diff --git a/src/Core/Exception/Transformer/InvalidTransformerClassNameException.php b/src/Core/Exception/Transformer/InvalidTransformerClassNameException.php
new file mode 100644
index 0000000..035dc88
--- /dev/null
+++ b/src/Core/Exception/Transformer/InvalidTransformerClassNameException.php
@@ -0,0 +1,15 @@
+<?php
+
+namespace Okapi\CodeTransformer\Core\Exception\Transformer;
+
+use Okapi\CodeTransformer\Core\Exception\TransformerException;
+
+class InvalidTransformerClassNameException extends TransformerException
+{
+    public function __construct()
+    {
+        parent::__construct(
+            'Transformer class name in Kernel must be a string.',
+        );
+    }
+}
diff --git a/tests/Functional/ReplaceStringInClassTest.php b/tests/Functional/Cache/CachedFileAndDestructor/CachedFileAndDestructorTest.php
similarity index 74%
rename from tests/Functional/ReplaceStringInClassTest.php
rename to tests/Functional/Cache/CachedFileAndDestructor/CachedFileAndDestructorTest.php
index 3072be6..9aa2d69 100644
--- a/tests/Functional/ReplaceStringInClassTest.php
+++ b/tests/Functional/Cache/CachedFileAndDestructor/CachedFileAndDestructorTest.php
@@ -1,27 +1,26 @@
 <?php
 
-namespace Okapi\CodeTransformer\Tests\Functional;
+namespace Okapi\CodeTransformer\Tests\Functional\Cache\CachedFileAndDestructor;
 
 use Okapi\CodeTransformer\Core\Cache\CacheStateManager;
 use Okapi\CodeTransformer\Core\DI;
 use Okapi\CodeTransformer\Tests\ClassLoaderMockTrait;
-use Okapi\CodeTransformer\Tests\Stubs\ClassesToTransform\StringClass;
-use Okapi\CodeTransformer\Tests\Stubs\Kernel\ApplicationKernel;
-use Okapi\CodeTransformer\Tests\Stubs\Transformer\StringTransformer;
+use Okapi\CodeTransformer\Tests\Functional\Cache\CachedFileAndDestructor\Target\StringClass;
+use Okapi\CodeTransformer\Tests\Functional\Cache\CachedFileAndDestructor\Transformer\StringTransformer;
 use Okapi\CodeTransformer\Tests\Util;
 use Okapi\Filesystem\Filesystem;
 use PHPUnit\Framework\Attributes\RunTestsInSeparateProcesses;
 use PHPUnit\Framework\TestCase;
 
 #[RunTestsInSeparateProcesses]
-class ReplaceStringInClassTest extends TestCase
+class CachedFileAndDestructorTest extends TestCase
 {
     use ClassLoaderMockTrait;
 
     public function testReplaceStringInClass(): void
     {
         Util::clearCache();
-        ApplicationKernel::init();
+        Kernel::init();
 
         $class = StringClass::class;
         $this->assertWillBeTransformed($class);
@@ -32,7 +31,7 @@ public function testReplaceStringInClass(): void
             $stringClass->test(),
         );
 
-        $file    = Util::CLASSES_TO_TRANSFORM_DIR . '/StringClass.php';
+        $file    = Util::getFilePath(StringClass::class);
         $content = Filesystem::readFile($file);
 
         $this->assertEquals(
@@ -43,7 +42,7 @@ public function testReplaceStringInClass(): void
 
     public function testCachedReplaceStringClass(): void
     {
-        ApplicationKernel::init();
+        Kernel::init();
 
         $class = StringClass::class;
         $this->assertTransformerLoadedFromCache($class);
@@ -57,7 +56,7 @@ public function testCachedReplaceStringClass(): void
 
     public function testCachedFile(): void
     {
-        $cachedFilePath = Util::CACHED_CLASSES_TO_TRANSFORM_DIR . '/StringClass.php';
+        $cachedFilePath = Util::getTransformedFilePath(StringClass::class);
 
         $this->assertFileExists($cachedFilePath);
         $file = Filesystem::readFile($cachedFilePath);
@@ -76,7 +75,7 @@ public function testCachedFile(): void
     public function testDestructor(): void
     {
         Util::clearCache();
-        ApplicationKernel::init();
+        Kernel::init();
 
         $class = StringClass::class;
         $stringClass = new $class();
@@ -89,7 +88,7 @@ public function testDestructor(): void
 
         $file = require Util::CACHE_STATES_FILE;
 
-        $key = 'CODE_TRANSFORMER_APP_DIR\tests\Stubs\ClassesToTransform\StringClass.php';
+        $key = 'CODE_TRANSFORMER_APP_DIR\tests\Functional\Cache\CachedFileAndDestructor\Target\StringClass.php';
         $key = str_replace('\\', DIRECTORY_SEPARATOR, $key);
         $this->assertArrayHasKey($key, $file);
     }
diff --git a/tests/Functional/Cache/CachedFileAndDestructor/Kernel.php b/tests/Functional/Cache/CachedFileAndDestructor/Kernel.php
new file mode 100644
index 0000000..4328328
--- /dev/null
+++ b/tests/Functional/Cache/CachedFileAndDestructor/Kernel.php
@@ -0,0 +1,16 @@
+<?php
+
+namespace Okapi\CodeTransformer\Tests\Functional\Cache\CachedFileAndDestructor;
+
+use Okapi\CodeTransformer\CodeTransformerKernel;
+use Okapi\CodeTransformer\Tests\Functional\Cache\CachedFileAndDestructor\Transformer\StringTransformer;
+use Okapi\CodeTransformer\Tests\Util;
+
+class Kernel extends CodeTransformerKernel
+{
+    protected ?string $cacheDir = Util::CACHE_DIR;
+
+    protected array $transformers = [
+        StringTransformer::class,
+    ];
+}
diff --git a/tests/Stubs/ClassesToTransform/StringClass.php b/tests/Functional/Cache/CachedFileAndDestructor/Target/StringClass.php
similarity index 52%
rename from tests/Stubs/ClassesToTransform/StringClass.php
rename to tests/Functional/Cache/CachedFileAndDestructor/Target/StringClass.php
index e5a5e43..1ba0c29 100644
--- a/tests/Stubs/ClassesToTransform/StringClass.php
+++ b/tests/Functional/Cache/CachedFileAndDestructor/Target/StringClass.php
@@ -1,6 +1,6 @@
 <?php
 
-namespace Okapi\CodeTransformer\Tests\Stubs\ClassesToTransform;
+namespace Okapi\CodeTransformer\Tests\Functional\Cache\CachedFileAndDestructor\Target;
 
 class StringClass
 {
diff --git a/tests/Stubs/Transformer/StringTransformer.php b/tests/Functional/Cache/CachedFileAndDestructor/Transformer/StringTransformer.php
similarity index 71%
rename from tests/Stubs/Transformer/StringTransformer.php
rename to tests/Functional/Cache/CachedFileAndDestructor/Transformer/StringTransformer.php
index 9fd458d..86f6771 100644
--- a/tests/Stubs/Transformer/StringTransformer.php
+++ b/tests/Functional/Cache/CachedFileAndDestructor/Transformer/StringTransformer.php
@@ -1,10 +1,10 @@
 <?php
 
-namespace Okapi\CodeTransformer\Tests\Stubs\Transformer;
+namespace Okapi\CodeTransformer\Tests\Functional\Cache\CachedFileAndDestructor\Transformer;
 
 use Microsoft\PhpParser\Node\StringLiteral;
-use Okapi\CodeTransformer\Tests\Stubs\ClassesToTransform\MultipleTransformersClass;
-use Okapi\CodeTransformer\Tests\Stubs\ClassesToTransform\StringClass;
+use Okapi\CodeTransformer\Tests\Functional\Cache\CachedFileAndDestructor\Target\StringClass;
+use Okapi\CodeTransformer\Tests\Functional\Transformer\MultipleTransformer\TargetClass;
 use Okapi\CodeTransformer\Transformer;
 use Okapi\CodeTransformer\Transformer\Code;
 
@@ -14,7 +14,7 @@ class StringTransformer extends Transformer
 
     public function getTargetClass(): string|array
     {
-        return [StringClass::class, 'Okapi*Tests*StringClass', MultipleTransformersClass::class];
+        return [StringClass::class, 'Okapi*Tests*StringClass', TargetClass::class];
     }
 
     public function transform(Code $code): void
diff --git a/tests/Functional/DeleteCacheFileTest.php b/tests/Functional/Cache/DeleteCacheFile/DeleteCacheFileTest.php
similarity index 68%
rename from tests/Functional/DeleteCacheFileTest.php
rename to tests/Functional/Cache/DeleteCacheFile/DeleteCacheFileTest.php
index b9e2401..a9625e2 100644
--- a/tests/Functional/DeleteCacheFileTest.php
+++ b/tests/Functional/Cache/DeleteCacheFile/DeleteCacheFileTest.php
@@ -1,10 +1,8 @@
 <?php
 
-namespace Okapi\CodeTransformer\Tests\Functional;
+namespace Okapi\CodeTransformer\Tests\Functional\Cache\DeleteCacheFile;
 
 use Okapi\CodeTransformer\Tests\ClassLoaderMockTrait;
-use Okapi\CodeTransformer\Tests\Stubs\ClassesToTransform\DeleteCacheFileClass;
-use Okapi\CodeTransformer\Tests\Stubs\Kernel\ApplicationKernel;
 use Okapi\CodeTransformer\Tests\Util;
 use Okapi\Filesystem\Filesystem;
 use PHPUnit\Framework\Attributes\RunTestsInSeparateProcesses;
@@ -18,9 +16,9 @@ class DeleteCacheFileTest extends TestCase
     public function testDeleteCacheFileClass(): void
     {
         Util::clearCache();
-        ApplicationKernel::init();
+        Kernel::init();
 
-        $class = DeleteCacheFileClass::class;
+        $class = Target::class;
         $this->assertWillBeTransformed($class);
 
         $deleteCacheFileClass = new $class();
@@ -32,15 +30,15 @@ public function testDeleteCacheFileClass(): void
 
     public function testCachedDeleteCacheFileClass(): void
     {
-        ApplicationKernel::init();
+        Kernel::init();
 
-        $cachedFilePath = Util::CACHED_CLASSES_TO_TRANSFORM_DIR . '/DeleteCacheFileClass.php';
+        $cachedFilePath = Util::getTransformedFilePath(Target::class);
 
         $this->assertFileExists($cachedFilePath);
         Filesystem::rm($cachedFilePath);
         $this->assertFileDoesNotExist($cachedFilePath);
 
-        $class = DeleteCacheFileClass::class;
+        $class = Target::class;
         $this->assertWillBeTransformed($class);
 
         $deleteCacheFileClass = new $class();
diff --git a/tests/Functional/Cache/DeleteCacheFile/Kernel.php b/tests/Functional/Cache/DeleteCacheFile/Kernel.php
new file mode 100644
index 0000000..d465f60
--- /dev/null
+++ b/tests/Functional/Cache/DeleteCacheFile/Kernel.php
@@ -0,0 +1,15 @@
+<?php
+
+namespace Okapi\CodeTransformer\Tests\Functional\Cache\DeleteCacheFile;
+
+use Okapi\CodeTransformer\CodeTransformerKernel;
+use Okapi\CodeTransformer\Tests\Util;
+
+class Kernel extends CodeTransformerKernel
+{
+    protected ?string $cacheDir = Util::CACHE_DIR;
+
+    protected array $transformers = [
+        Transformer::class,
+    ];
+}
diff --git a/tests/Functional/Cache/DeleteCacheFile/Target.php b/tests/Functional/Cache/DeleteCacheFile/Target.php
new file mode 100644
index 0000000..7982d82
--- /dev/null
+++ b/tests/Functional/Cache/DeleteCacheFile/Target.php
@@ -0,0 +1,11 @@
+<?php
+
+namespace Okapi\CodeTransformer\Tests\Functional\Cache\DeleteCacheFile;
+
+class Target
+{
+    public function test(): string
+    {
+        return 'Hello World!';
+    }
+}
diff --git a/tests/Functional/Cache/DeleteCacheFile/Transformer.php b/tests/Functional/Cache/DeleteCacheFile/Transformer.php
new file mode 100644
index 0000000..cc329e2
--- /dev/null
+++ b/tests/Functional/Cache/DeleteCacheFile/Transformer.php
@@ -0,0 +1,19 @@
+<?php
+
+namespace Okapi\CodeTransformer\Tests\Functional\Cache\DeleteCacheFile;
+
+use Okapi\CodeTransformer\Transformer as TransformerClass;
+use Okapi\CodeTransformer\Transformer\Code;
+
+class Transformer extends TransformerClass
+{
+    public function getTargetClass(): string|array
+    {
+        return Target::class;
+    }
+
+    public function transform(Code $code): void
+    {
+        $code->append('// Hello from Code Transformer!');
+    }
+}
diff --git a/tests/Functional/InvalidTransformerClassTest.php b/tests/Functional/InvalidTransformerClassTest.php
deleted file mode 100644
index 3cd92e0..0000000
--- a/tests/Functional/InvalidTransformerClassTest.php
+++ /dev/null
@@ -1,28 +0,0 @@
-<?php
-
-namespace Okapi\CodeTransformer\Tests\Functional;
-
-use Okapi\CodeTransformer\Core\Exception\Transformer\InvalidTransformerClassException;
-use Okapi\CodeTransformer\Core\Exception\Transformer\TransformerNotFoundException;
-use Okapi\CodeTransformer\Tests\Stubs\Kernel\TransformerDoesNotExistKernel;
-use Okapi\CodeTransformer\Tests\Stubs\Kernel\TransformerDoesNotExtendTransformerKernel;
-use PHPUnit\Framework\Attributes\RunTestsInSeparateProcesses;
-use PHPUnit\Framework\TestCase;
-
-#[RunTestsInSeparateProcesses]
-class InvalidTransformerClassTest extends TestCase
-{
-    public function testTransformerNotFound(): void
-    {
-        $this->expectException(TransformerNotFoundException::class);
-
-        TransformerDoesNotExistKernel::init();
-    }
-
-    public function testTransformerDoesNotExtendTransformer(): void
-    {
-        $this->expectException(InvalidTransformerClassException::class);
-
-        TransformerDoesNotExtendTransformerKernel::init();
-    }
-}
diff --git a/tests/Functional/AddedTransformerTest.php b/tests/Functional/Kernel/AddedTransformer/AddedTransformerTest.php
similarity index 68%
rename from tests/Functional/AddedTransformerTest.php
rename to tests/Functional/Kernel/AddedTransformer/AddedTransformerTest.php
index 7fb989e..60312f6 100644
--- a/tests/Functional/AddedTransformerTest.php
+++ b/tests/Functional/Kernel/AddedTransformer/AddedTransformerTest.php
@@ -1,11 +1,10 @@
 <?php
 
-namespace Okapi\CodeTransformer\Tests\Functional;
+namespace Okapi\CodeTransformer\Tests\Functional\Kernel\AddedTransformer;
 
 use Okapi\CodeTransformer\Tests\ClassLoaderMockTrait;
-use Okapi\CodeTransformer\Tests\Stubs\ClassesToTransform\AddedTransformerClass;
-use Okapi\CodeTransformer\Tests\Stubs\Kernel\AddedTransformerKernel;
-use Okapi\CodeTransformer\Tests\Stubs\Kernel\ApplicationKernel;
+use Okapi\CodeTransformer\Tests\Functional\Kernel\AddedTransformer\Kernel\AddedTransformerKernel;
+use Okapi\CodeTransformer\Tests\Functional\Kernel\AddedTransformer\Kernel\BeforeAddedTransformerKernel;
 use Okapi\CodeTransformer\Tests\Util;
 use PHPUnit\Framework\Attributes\RunTestsInSeparateProcesses;
 use PHPUnit\Framework\TestCase;
@@ -18,9 +17,9 @@ class AddedTransformerTest extends TestCase
     public function testAddedTransformer(): void
     {
         Util::clearCache();
-        ApplicationKernel::init();
+        BeforeAddedTransformerKernel::init();
 
-        $class = AddedTransformerClass::class;
+        $class = Target::class;
         $this->assertWillBeTransformed($class);
 
         $addedTransformerClass = new $class();
@@ -35,7 +34,7 @@ public function testCachedAddedTransformer(): void
     {
         AddedTransformerKernel::init();
 
-        $class = AddedTransformerClass::class;
+        $class = Target::class;
         $this->assertWillBeTransformed($class);
 
         $addedTransformerClass = new $class();
diff --git a/tests/Functional/Kernel/AddedTransformer/Kernel/AddedTransformerKernel.php b/tests/Functional/Kernel/AddedTransformer/Kernel/AddedTransformerKernel.php
new file mode 100644
index 0000000..60eedb1
--- /dev/null
+++ b/tests/Functional/Kernel/AddedTransformer/Kernel/AddedTransformerKernel.php
@@ -0,0 +1,17 @@
+<?php
+
+namespace Okapi\CodeTransformer\Tests\Functional\Kernel\AddedTransformer\Kernel;
+
+use Okapi\CodeTransformer\Tests\Functional\Kernel\AddedTransformer\Transformer\AddedTransformer2;
+
+class AddedTransformerKernel extends BeforeAddedTransformerKernel
+{
+    protected array $addedTransformers = [
+        AddedTransformer2::class,
+    ];
+
+    protected function configureOptions(): void
+    {
+        $this->transformerManager->addTransformers($this->addedTransformers);
+    }
+}
diff --git a/tests/Functional/Kernel/AddedTransformer/Kernel/BeforeAddedTransformerKernel.php b/tests/Functional/Kernel/AddedTransformer/Kernel/BeforeAddedTransformerKernel.php
new file mode 100644
index 0000000..0541ade
--- /dev/null
+++ b/tests/Functional/Kernel/AddedTransformer/Kernel/BeforeAddedTransformerKernel.php
@@ -0,0 +1,16 @@
+<?php
+
+namespace Okapi\CodeTransformer\Tests\Functional\Kernel\AddedTransformer\Kernel;
+
+use Okapi\CodeTransformer\CodeTransformerKernel;
+use Okapi\CodeTransformer\Tests\Functional\Kernel\AddedTransformer\Transformer\AddedTransformer1;
+use Okapi\CodeTransformer\Tests\Util;
+
+class BeforeAddedTransformerKernel extends CodeTransformerKernel
+{
+    protected ?string $cacheDir = Util::CACHE_DIR;
+
+    protected array $transformers = [
+        AddedTransformer1::class,
+    ];
+}
diff --git a/tests/Stubs/ClassesToTransform/AddedTransformerClass.php b/tests/Functional/Kernel/AddedTransformer/Target.php
similarity index 57%
rename from tests/Stubs/ClassesToTransform/AddedTransformerClass.php
rename to tests/Functional/Kernel/AddedTransformer/Target.php
index 34e58cb..6e09ce7 100644
--- a/tests/Stubs/ClassesToTransform/AddedTransformerClass.php
+++ b/tests/Functional/Kernel/AddedTransformer/Target.php
@@ -1,8 +1,8 @@
 <?php
 
-namespace Okapi\CodeTransformer\Tests\Stubs\ClassesToTransform;
+namespace Okapi\CodeTransformer\Tests\Functional\Kernel\AddedTransformer;
 
-class AddedTransformerClass
+class Target
 {
     public function test(): string
     {
diff --git a/tests/Stubs/Transformer/AddedTransformer1.php b/tests/Functional/Kernel/AddedTransformer/Transformer/AddedTransformer1.php
similarity index 85%
rename from tests/Stubs/Transformer/AddedTransformer1.php
rename to tests/Functional/Kernel/AddedTransformer/Transformer/AddedTransformer1.php
index b465360..2b4ed0c 100644
--- a/tests/Stubs/Transformer/AddedTransformer1.php
+++ b/tests/Functional/Kernel/AddedTransformer/Transformer/AddedTransformer1.php
@@ -1,12 +1,12 @@
 <?php
 /** @noinspection PhpUnhandledExceptionInspection */
-namespace Okapi\CodeTransformer\Tests\Stubs\Transformer;
+namespace Okapi\CodeTransformer\Tests\Functional\Kernel\AddedTransformer\Transformer;
 
 use Microsoft\PhpParser\Node\Expression\AssignmentExpression;
 use Microsoft\PhpParser\Node\Expression\Variable;
 use Microsoft\PhpParser\Node\Statement\ExpressionStatement;
 use Microsoft\PhpParser\Node\StringLiteral;
-use Okapi\CodeTransformer\Tests\Stubs\ClassesToTransform\AddedTransformerClass;
+use Okapi\CodeTransformer\Tests\Functional\Kernel\AddedTransformer\Target;
 use Okapi\CodeTransformer\Transformer;
 use Okapi\CodeTransformer\Transformer\Code;
 
@@ -14,7 +14,7 @@ class AddedTransformer1 extends Transformer
 {
     public function getTargetClass(): string|array
     {
-        return AddedTransformerClass::class;
+        return Target::class;
     }
 
     public function transform(Code $code): void
diff --git a/tests/Stubs/Transformer/AddedTransformer2.php b/tests/Functional/Kernel/AddedTransformer/Transformer/AddedTransformer2.php
similarity index 85%
rename from tests/Stubs/Transformer/AddedTransformer2.php
rename to tests/Functional/Kernel/AddedTransformer/Transformer/AddedTransformer2.php
index be43361..3aaad9c 100644
--- a/tests/Stubs/Transformer/AddedTransformer2.php
+++ b/tests/Functional/Kernel/AddedTransformer/Transformer/AddedTransformer2.php
@@ -1,12 +1,12 @@
 <?php
 
-namespace Okapi\CodeTransformer\Tests\Stubs\Transformer;
+namespace Okapi\CodeTransformer\Tests\Functional\Kernel\AddedTransformer\Transformer;
 
 use Microsoft\PhpParser\Node\Expression\AssignmentExpression;
 use Microsoft\PhpParser\Node\Expression\Variable;
 use Microsoft\PhpParser\Node\Statement\ExpressionStatement;
 use Microsoft\PhpParser\Node\StringLiteral;
-use Okapi\CodeTransformer\Tests\Stubs\ClassesToTransform\AddedTransformerClass;
+use Okapi\CodeTransformer\Tests\Functional\Kernel\AddedTransformer\Target;
 use Okapi\CodeTransformer\Transformer;
 use Okapi\CodeTransformer\Transformer\Code;
 
@@ -14,7 +14,7 @@ class AddedTransformer2 extends Transformer
 {
     public function getTargetClass(): string|array
     {
-        return AddedTransformerClass::class;
+        return Target::class;
     }
 
     public function transform(Code $code): void
diff --git a/tests/Functional/AlreadyInitializedKernelTest.php b/tests/Functional/Kernel/AlreadyInitializedKernel/AlreadyInitializedKernelTest.php
similarity index 75%
rename from tests/Functional/AlreadyInitializedKernelTest.php
rename to tests/Functional/Kernel/AlreadyInitializedKernel/AlreadyInitializedKernelTest.php
index d59d468..175d16d 100644
--- a/tests/Functional/AlreadyInitializedKernelTest.php
+++ b/tests/Functional/Kernel/AlreadyInitializedKernel/AlreadyInitializedKernelTest.php
@@ -1,9 +1,8 @@
 <?php
 
-namespace Okapi\CodeTransformer\Tests\Functional;
+namespace Okapi\CodeTransformer\Tests\Functional\Kernel\AlreadyInitializedKernel;
 
 use Okapi\CodeTransformer\Tests\Stubs\Kernel\EmptyKernel;
-use Okapi\CodeTransformer\Tests\Stubs\Kernel\ExceptionOnDoubleInitializationKernel;
 use Okapi\CodeTransformer\Tests\Util;
 use Okapi\Singleton\Exceptions\AlreadyInitializedException;
 use PHPUnit\Framework\Attributes\RunTestsInSeparateProcesses;
@@ -28,7 +27,7 @@ public function testInitializeKernelTwiceWithExceptionOnDoubleInitializationOpti
 
         $this->expectException(AlreadyInitializedException::class);
 
-        ExceptionOnDoubleInitializationKernel::init();
-        ExceptionOnDoubleInitializationKernel::init();
+        Kernel::init();
+        Kernel::init();
     }
 }
diff --git a/tests/Stubs/Kernel/ExceptionOnDoubleInitializationKernel.php b/tests/Functional/Kernel/AlreadyInitializedKernel/Kernel.php
similarity index 70%
rename from tests/Stubs/Kernel/ExceptionOnDoubleInitializationKernel.php
rename to tests/Functional/Kernel/AlreadyInitializedKernel/Kernel.php
index 968ad16..f5ef477 100644
--- a/tests/Stubs/Kernel/ExceptionOnDoubleInitializationKernel.php
+++ b/tests/Functional/Kernel/AlreadyInitializedKernel/Kernel.php
@@ -1,10 +1,11 @@
 <?php
 /** @noinspection PhpUnhandledExceptionInspection */
-namespace Okapi\CodeTransformer\Tests\Stubs\Kernel;
+namespace Okapi\CodeTransformer\Tests\Functional\Kernel\AlreadyInitializedKernel;
 
 use Exception;
+use Okapi\CodeTransformer\Tests\Stubs\Kernel\EmptyKernel;
 
-class ExceptionOnDoubleInitializationKernel extends EmptyKernel
+class Kernel extends EmptyKernel
 {
     private int $initCount = 0;
 
diff --git a/tests/Functional/Kernel/CustomDependencyInjectionHandler/CustomDependencyInjectionHandlerTest.php b/tests/Functional/Kernel/CustomDependencyInjectionHandler/CustomDependencyInjectionHandlerTest.php
new file mode 100644
index 0000000..ee20c81
--- /dev/null
+++ b/tests/Functional/Kernel/CustomDependencyInjectionHandler/CustomDependencyInjectionHandlerTest.php
@@ -0,0 +1,39 @@
+<?php
+
+namespace Okapi\CodeTransformer\Tests\Functional\Kernel\CustomDependencyInjectionHandler;
+
+use Okapi\CodeTransformer\Tests\Functional\Cache\CachedFileAndDestructor\Target\StringClass;
+use Okapi\CodeTransformer\Tests\Functional\Cache\CachedFileAndDestructor\Transformer\StringTransformer;
+use Okapi\CodeTransformer\Tests\Util;
+use PHPUnit\Framework\Attributes\RunTestsInSeparateProcesses;
+use PHPUnit\Framework\TestCase;
+
+#[RunTestsInSeparateProcesses]
+class CustomDependencyInjectionHandlerTest extends TestCase
+{
+    /**
+     * @see StringTransformer::transform()
+     */
+    public function testCustomDependencyInjectionHandler(): void
+    {
+        Util::clearCache();
+
+        ob_start();
+
+        Kernel::init();
+
+        $output = ob_get_clean();
+
+        $this->assertStringContainsString(
+            'Generating transformer instance: ' . StringTransformer::class,
+            $output,
+        );
+
+        $class = new StringClass();
+
+        $this->assertSame(
+            'Hello from Code Transformer!',
+            $class->test(),
+        );
+    }
+}
diff --git a/tests/Functional/Kernel/CustomDependencyInjectionHandler/Kernel.php b/tests/Functional/Kernel/CustomDependencyInjectionHandler/Kernel.php
new file mode 100644
index 0000000..d55e433
--- /dev/null
+++ b/tests/Functional/Kernel/CustomDependencyInjectionHandler/Kernel.php
@@ -0,0 +1,26 @@
+<?php
+
+namespace Okapi\CodeTransformer\Tests\Functional\Kernel\CustomDependencyInjectionHandler;
+
+use Closure;
+use Okapi\CodeTransformer\CodeTransformerKernel;
+use Okapi\CodeTransformer\Tests\Functional\Cache\CachedFileAndDestructor\Transformer\StringTransformer;
+use Okapi\CodeTransformer\Tests\Util;
+
+class Kernel extends CodeTransformerKernel
+{
+    protected ?string $cacheDir = Util::CACHE_DIR;
+
+    protected function dependencyInjectionHandler(): ?Closure
+    {
+        return function (string $transformerClass) {
+            echo 'Generating transformer instance: ' . $transformerClass . PHP_EOL;
+
+            return new $transformerClass();
+        };
+    }
+
+    protected array $transformers = [
+        StringTransformer::class,
+    ];
+}
diff --git a/tests/Functional/DirectKernelTest.php b/tests/Functional/Kernel/DirectKernel/DirectKernelTest.php
similarity index 82%
rename from tests/Functional/DirectKernelTest.php
rename to tests/Functional/Kernel/DirectKernel/DirectKernelTest.php
index 5706bb1..6dbae03 100644
--- a/tests/Functional/DirectKernelTest.php
+++ b/tests/Functional/Kernel/DirectKernel/DirectKernelTest.php
@@ -1,6 +1,6 @@
 <?php
 
-namespace Okapi\CodeTransformer\Tests\Functional;
+namespace Okapi\CodeTransformer\Tests\Functional\Kernel\DirectKernel;
 
 use Okapi\CodeTransformer\CodeTransformerKernel;
 use Okapi\CodeTransformer\Core\Exception\Kernel\DirectKernelInitializationException;
diff --git a/tests/Functional/Kernel/Environment/EnvironmentTest.php b/tests/Functional/Kernel/Environment/EnvironmentTest.php
new file mode 100644
index 0000000..9efc04c
--- /dev/null
+++ b/tests/Functional/Kernel/Environment/EnvironmentTest.php
@@ -0,0 +1,180 @@
+<?php
+
+namespace Okapi\CodeTransformer\Tests\Functional\Kernel\Environment;
+
+use Okapi\CodeTransformer\Tests\ClassLoaderMockTrait;
+use Okapi\CodeTransformer\Tests\Functional\Kernel\Environment\Kernel\DevelopmentEnvironmentKernel;
+use Okapi\CodeTransformer\Tests\Functional\Kernel\Environment\Kernel\ProductionEnvironmentKernel;
+use Okapi\CodeTransformer\Tests\Functional\Kernel\Environment\Target\HelloWorld;
+use Okapi\CodeTransformer\Tests\Functional\Kernel\Environment\Transformer\StringTransformer;
+use Okapi\CodeTransformer\Tests\Util;
+use Okapi\Filesystem\Filesystem;
+use PHPUnit\Framework\Attributes\RunTestsInSeparateProcesses;
+use PHPUnit\Framework\TestCase;
+use Throwable;
+
+#[RunTestsInSeparateProcesses]
+class EnvironmentTest extends TestCase
+{
+    use ClassLoaderMockTrait;
+
+    /**
+     * @see StringTransformer::transform()
+     */
+    public function testDevelopmentEnvironment(): void
+    {
+        Util::clearCache();
+        DevelopmentEnvironmentKernel::init();
+
+        $class = HelloWorld::class;
+        $this->assertWillBeTransformed($class);
+
+        $helloWorldClass = new $class();
+
+        $this->assertSame(
+            'Hello from Code Transformer!',
+            $helloWorldClass->say(),
+        );
+    }
+
+    /**
+     * @see StringTransformer::transform()
+     */
+    public function testCachedDevelopmentEnvironment(): void
+    {
+        DevelopmentEnvironmentKernel::init();
+
+        $class = HelloWorld::class;
+        $this->assertTransformerLoadedFromCache($class);
+
+        $helloWorldClass = new $class();
+
+        $this->assertSame(
+            'Hello from Code Transformer!',
+            $helloWorldClass->say(),
+        );
+    }
+
+    /**
+     * @see StringTransformer::transform()
+     */
+    public function testChangedDevelopmentEnvironment(): void
+    {
+        // Change class
+        $classFilePath            = Util::getFilePath(HelloWorld::class);
+        $originalClassFileContent = Filesystem::readFile($classFilePath);
+
+        $changedFileContent = str_replace(
+            'Hello World!',
+            'Hello Changed World!',
+            $originalClassFileContent,
+        );
+
+        sleep(1);
+        Filesystem::writeFile($classFilePath, $changedFileContent);
+
+        $exception = null;
+        try {
+            DevelopmentEnvironmentKernel::init();
+
+            $class = HelloWorld::class;
+            $this->assertWillBeTransformed($class);
+
+            $classInstance = new $class();
+            $this->assertSame(
+                'Hello Changed World from Code Transformer!',
+                $classInstance->say(),
+            );
+        } catch (Throwable $e) {
+            $exception = $e;
+        }
+
+        // Restore class
+        Filesystem::writeFile($classFilePath, $originalClassFileContent);
+
+        if ($exception !== null) {
+            /** @noinspection PhpUnhandledExceptionInspection */
+            throw $exception;
+        }
+    }
+
+    /**
+     * @see StringTransformer::transform()
+     */
+    public function testProductionEnvironment(): void
+    {
+        Util::clearCache();
+        ProductionEnvironmentKernel::init();
+
+        $class = HelloWorld::class;
+        $this->assertWillBeTransformed($class);
+
+        $helloWorldClass = new $class();
+
+        $this->assertSame(
+            'Hello from Code Transformer!',
+            $helloWorldClass->say(),
+        );
+    }
+
+    /**
+     * @see StringTransformer::transform()
+     */
+    public function testCachedProductionEnvironment(): void
+    {
+        ProductionEnvironmentKernel::init();
+
+        $class = HelloWorld::class;
+        $this->assertTransformerLoadedFromCache($class);
+
+        $helloWorldClass = new $class();
+
+        $this->assertSame(
+            'Hello from Code Transformer!',
+            $helloWorldClass->say(),
+        );
+    }
+
+    /**
+     * @see StringTransformer::transform()
+     */
+    public function testChangedProductionEnvironment(): void
+    {
+        // Change class
+        $classFilePath            = Util::getFilePath(HelloWorld::class);
+        $originalClassFileContent = Filesystem::readFile($classFilePath);
+
+        $changedFileContent = str_replace(
+            'Hello World!',
+            'Hello Changed World!',
+            $originalClassFileContent,
+        );
+
+        sleep(1);
+        Filesystem::writeFile($classFilePath, $changedFileContent);
+
+        $exception = null;
+        try {
+            ProductionEnvironmentKernel::init();
+
+            $class = HelloWorld::class;
+            $this->assertTransformerLoadedFromCache($class);
+
+            $classInstance = new $class();
+            $this->assertSame(
+                'Hello from Code Transformer!',
+                $classInstance->say(),
+            );
+        } catch (Throwable $e) {
+            $exception = $e;
+        }
+
+        // Restore class
+        Filesystem::writeFile($classFilePath, $originalClassFileContent);
+
+        if ($exception !== null) {
+            /** @noinspection PhpUnhandledExceptionInspection */
+            throw $exception;
+        }
+    }
+}
diff --git a/tests/Functional/Kernel/Environment/Kernel/DevelopmentEnvironmentKernel.php b/tests/Functional/Kernel/Environment/Kernel/DevelopmentEnvironmentKernel.php
new file mode 100644
index 0000000..82937e4
--- /dev/null
+++ b/tests/Functional/Kernel/Environment/Kernel/DevelopmentEnvironmentKernel.php
@@ -0,0 +1,19 @@
+<?php
+
+namespace Okapi\CodeTransformer\Tests\Functional\Kernel\Environment\Kernel;
+
+use Okapi\CodeTransformer\CodeTransformerKernel;
+use Okapi\CodeTransformer\Core\Options\Environment;
+use Okapi\CodeTransformer\Tests\Functional\Kernel\Environment\Transformer\StringTransformer;
+use Okapi\CodeTransformer\Tests\Util;
+
+class DevelopmentEnvironmentKernel extends CodeTransformerKernel
+{
+    protected ?string $cacheDir = Util::CACHE_DIR;
+
+    protected Environment $environment = Environment::DEVELOPMENT;
+
+    protected array $transformers = [
+        StringTransformer::class,
+    ];
+}
diff --git a/tests/Functional/Kernel/Environment/Kernel/ProductionEnvironmentKernel.php b/tests/Functional/Kernel/Environment/Kernel/ProductionEnvironmentKernel.php
new file mode 100644
index 0000000..699b638
--- /dev/null
+++ b/tests/Functional/Kernel/Environment/Kernel/ProductionEnvironmentKernel.php
@@ -0,0 +1,10 @@
+<?php
+
+namespace Okapi\CodeTransformer\Tests\Functional\Kernel\Environment\Kernel;
+
+use Okapi\CodeTransformer\Core\Options\Environment;
+
+class ProductionEnvironmentKernel extends DevelopmentEnvironmentKernel
+{
+    protected Environment $environment = Environment::PRODUCTION;
+}
diff --git a/tests/Functional/Kernel/Environment/Target/HelloWorld.php b/tests/Functional/Kernel/Environment/Target/HelloWorld.php
new file mode 100755
index 0000000..ba42eb5
--- /dev/null
+++ b/tests/Functional/Kernel/Environment/Target/HelloWorld.php
@@ -0,0 +1,11 @@
+<?php
+
+namespace Okapi\CodeTransformer\Tests\Functional\Kernel\Environment\Target;
+
+class HelloWorld
+{
+    public function say(): string
+    {
+        return 'Hello World!';
+    }
+}
diff --git a/tests/Functional/Kernel/Environment/Transformer/StringTransformer.php b/tests/Functional/Kernel/Environment/Transformer/StringTransformer.php
new file mode 100644
index 0000000..82e9bfc
--- /dev/null
+++ b/tests/Functional/Kernel/Environment/Transformer/StringTransformer.php
@@ -0,0 +1,40 @@
+<?php
+
+namespace Okapi\CodeTransformer\Tests\Functional\Kernel\Environment\Transformer;
+
+use Microsoft\PhpParser\Node\StringLiteral;
+use Okapi\CodeTransformer\Tests\Functional\Kernel\Environment\Target\HelloWorld;
+use Okapi\CodeTransformer\Transformer;
+use Okapi\CodeTransformer\Transformer\Code;
+
+class StringTransformer extends Transformer
+{
+    public function getTargetClass(): string|array
+    {
+        return [HelloWorld::class];
+    }
+
+    public function transform(Code $code): void
+    {
+        $sourceFileNode = $code->getSourceFileNode();
+
+        foreach ($sourceFileNode->getDescendantNodes() as $node) {
+            // Find 'Hello World!' string
+            if ($node instanceof StringLiteral) {
+                if ($node->getStringContentsText() === 'Hello World!') {
+                    // Replace it with 'Hello from Code Transformer!'
+                    $code->edit(
+                        $node->children,
+                        "'Hello from Code Transformer!'",
+                    );
+                } else if ($node->getStringContentsText() === 'Hello Changed World!') {
+                    // Replace it with 'Hello Changed World from Code Transformer!'
+                    $code->edit(
+                        $node->children,
+                        "'Hello Changed World from Code Transformer!'",
+                    );
+                }
+            }
+        }
+    }
+}
diff --git a/tests/Functional/KernelTest.php b/tests/Functional/Kernel/KernelTest.php
similarity index 50%
rename from tests/Functional/KernelTest.php
rename to tests/Functional/Kernel/KernelTest.php
index 675818d..1b0e152 100644
--- a/tests/Functional/KernelTest.php
+++ b/tests/Functional/Kernel/KernelTest.php
@@ -1,8 +1,8 @@
 <?php
 
-namespace Okapi\CodeTransformer\Tests\Functional;
+namespace Okapi\CodeTransformer\Tests\Functional\Kernel;
 
-use Okapi\CodeTransformer\Tests\Stubs\Kernel\ApplicationKernel;
+use Okapi\CodeTransformer\Tests\Stubs\Kernel\EmptyKernel;
 use Okapi\CodeTransformer\Tests\Util;
 use PHPUnit\Framework\Attributes\RunTestsInSeparateProcesses;
 use PHPUnit\Framework\TestCase;
@@ -14,18 +14,18 @@ public function testKernel(): void
     {
         Util::clearCache();
 
-        $this->assertFalse(ApplicationKernel::isInitialized());
-        ApplicationKernel::init();
-        $this->assertTrue(ApplicationKernel::isInitialized());
+        $this->assertFalse(EmptyKernel::isInitialized());
+        EmptyKernel::init();
+        $this->assertTrue(EmptyKernel::isInitialized());
 
         $this->assertFileDoesNotExist(Util::CACHE_STATES_FILE);
     }
 
     public function testCachedKernel(): void
     {
-        $this->assertFalse(ApplicationKernel::isInitialized());
-        ApplicationKernel::init();
-        $this->assertTrue(ApplicationKernel::isInitialized());
+        $this->assertFalse(EmptyKernel::isInitialized());
+        EmptyKernel::init();
+        $this->assertTrue(EmptyKernel::isInitialized());
 
         $this->assertFileExists(Util::CACHE_STATES_FILE);
     }
diff --git a/tests/Functional/ChangedClassTest.php b/tests/Functional/Target/ChangedClass/ChangedClassTest.php
similarity index 58%
rename from tests/Functional/ChangedClassTest.php
rename to tests/Functional/Target/ChangedClass/ChangedClassTest.php
index 6947d41..dd9ba52 100644
--- a/tests/Functional/ChangedClassTest.php
+++ b/tests/Functional/Target/ChangedClass/ChangedClassTest.php
@@ -1,10 +1,8 @@
 <?php
 
-namespace Okapi\CodeTransformer\Tests\Functional;
+namespace Okapi\CodeTransformer\Tests\Functional\Target\ChangedClass;
 
 use Okapi\CodeTransformer\Tests\ClassLoaderMockTrait;
-use Okapi\CodeTransformer\Tests\Stubs\ClassesToTransform\ChangedClass;
-use Okapi\CodeTransformer\Tests\Stubs\Kernel\ApplicationKernel;
 use Okapi\CodeTransformer\Tests\Util;
 use Okapi\Filesystem\Filesystem;
 use PHPUnit\Framework\Attributes\RunTestsInSeparateProcesses;
@@ -21,9 +19,9 @@ class ChangedClassTest extends TestCase
     public function testChangedClass(): void
     {
         Util::clearCache();
-        ApplicationKernel::init();
+        Kernel::init();
 
-        $class = ChangedClass::class;
+        $class = Target::class;
         $this->assertWillBeTransformed($class);
 
         $changedClass = new $class();
@@ -31,30 +29,28 @@ public function testChangedClass(): void
             'Hello World from Code Transformer!',
             $changedClass->test(),
         );
+    }
 
+    public function testCachedChangedClass(): void
+    {
         // Change class
-        $classFilePath    = Util::CLASSES_TO_TRANSFORM_DIR . '/ChangedClass.php';
-        $classFileContent = Filesystem::readFile($classFilePath);
-        $tmpPath          = Util::TMP_DIR . '/ChangedClass.php';
-        Filesystem::writeFile($tmpPath, $classFileContent);
+        $classFilePath            = Util::getFilePath(Target::class);
+        $originalClassFileContent = Filesystem::readFile($classFilePath);
 
         $changedFileContent = str_replace(
             'Hello World!',
             'Hello Changed World!',
-            $classFileContent,
+            $originalClassFileContent,
         );
 
         sleep(1);
         Filesystem::writeFile($classFilePath, $changedFileContent);
-    }
 
-    public function testCachedChangedClass(): void
-    {
         $exception = null;
         try {
-            ApplicationKernel::init();
+            Kernel::init();
 
-            $class = ChangedClass::class;
+            $class = Target::class;
             $this->assertWillBeTransformed($class);
 
             $classInstance = new $class();
@@ -67,15 +63,7 @@ public function testCachedChangedClass(): void
         }
 
         // Restore class
-        $tmpPath        = Util::TMP_DIR . '/ChangedClass.php';
-        if (!file_exists($tmpPath)) {
-            return;
-        }
-
-        $tmpFileContent = Filesystem::readFile($tmpPath);
-        $classFilePath  = Util::CLASSES_TO_TRANSFORM_DIR . '/ChangedClass.php';
-
-        Filesystem::writeFile($classFilePath, $tmpFileContent);
+        Filesystem::writeFile($classFilePath, $originalClassFileContent);
 
         if ($exception !== null) {
             /** @noinspection PhpUnhandledExceptionInspection */
diff --git a/tests/Functional/Target/ChangedClass/Kernel.php b/tests/Functional/Target/ChangedClass/Kernel.php
new file mode 100644
index 0000000..4667028
--- /dev/null
+++ b/tests/Functional/Target/ChangedClass/Kernel.php
@@ -0,0 +1,15 @@
+<?php
+
+namespace Okapi\CodeTransformer\Tests\Functional\Target\ChangedClass;
+
+use Okapi\CodeTransformer\CodeTransformerKernel;
+use Okapi\CodeTransformer\Tests\Util;
+
+class Kernel extends CodeTransformerKernel
+{
+    protected ?string $cacheDir = Util::CACHE_DIR;
+
+    protected array $transformers = [
+        Transformer::class,
+    ];
+}
diff --git a/tests/Functional/Target/ChangedClass/Target.php b/tests/Functional/Target/ChangedClass/Target.php
new file mode 100755
index 0000000..1050574
--- /dev/null
+++ b/tests/Functional/Target/ChangedClass/Target.php
@@ -0,0 +1,11 @@
+<?php
+
+namespace Okapi\CodeTransformer\Tests\Functional\Target\ChangedClass;
+
+class Target
+{
+    public function test(): string
+    {
+        return 'Hello World!';
+    }
+}
diff --git a/tests/Stubs/Transformer/ChangedClassTransformer.php b/tests/Functional/Target/ChangedClass/Transformer.php
similarity index 79%
rename from tests/Stubs/Transformer/ChangedClassTransformer.php
rename to tests/Functional/Target/ChangedClass/Transformer.php
index cbc8ef2..51f7ee0 100644
--- a/tests/Stubs/Transformer/ChangedClassTransformer.php
+++ b/tests/Functional/Target/ChangedClass/Transformer.php
@@ -1,17 +1,16 @@
 <?php
 
-namespace Okapi\CodeTransformer\Tests\Stubs\Transformer;
+namespace Okapi\CodeTransformer\Tests\Functional\Target\ChangedClass;
 
 use Microsoft\PhpParser\Node\StringLiteral;
-use Okapi\CodeTransformer\Tests\Stubs\ClassesToTransform\ChangedClass;
-use Okapi\CodeTransformer\Transformer;
+use Okapi\CodeTransformer\Transformer as TransformerClass;
 use Okapi\CodeTransformer\Transformer\Code;
 
-class ChangedClassTransformer extends Transformer
+class Transformer extends TransformerClass
 {
     public function getTargetClass(): string|array
     {
-        return ChangedClass::class;
+        return Target::class;
     }
 
     public function transform(Code $code): void
diff --git a/tests/Functional/Target/NoChanges/Kernel.php b/tests/Functional/Target/NoChanges/Kernel.php
new file mode 100644
index 0000000..08e5cdd
--- /dev/null
+++ b/tests/Functional/Target/NoChanges/Kernel.php
@@ -0,0 +1,15 @@
+<?php
+
+namespace Okapi\CodeTransformer\Tests\Functional\Target\NoChanges;
+
+use Okapi\CodeTransformer\CodeTransformerKernel;
+use Okapi\CodeTransformer\Tests\Util;
+
+class Kernel extends CodeTransformerKernel
+{
+    protected ?string $cacheDir = Util::CACHE_DIR;
+
+    protected array $transformers = [
+        Transformer::class,
+    ];
+}
diff --git a/tests/Functional/NoChangesClassTest.php b/tests/Functional/Target/NoChanges/NoChangesTest.php
similarity index 52%
rename from tests/Functional/NoChangesClassTest.php
rename to tests/Functional/Target/NoChanges/NoChangesTest.php
index 0060f18..a1487b0 100644
--- a/tests/Functional/NoChangesClassTest.php
+++ b/tests/Functional/Target/NoChanges/NoChangesTest.php
@@ -1,25 +1,23 @@
 <?php
 
-namespace Okapi\CodeTransformer\Tests\Functional;
+namespace Okapi\CodeTransformer\Tests\Functional\Target\NoChanges;
 
 use Okapi\CodeTransformer\Tests\ClassLoaderMockTrait;
-use Okapi\CodeTransformer\Tests\Stubs\ClassesToTransform\NoChangesClass;
-use Okapi\CodeTransformer\Tests\Stubs\Kernel\ApplicationKernel;
 use Okapi\CodeTransformer\Tests\Util;
 use PHPUnit\Framework\Attributes\RunTestsInSeparateProcesses;
 use PHPUnit\Framework\TestCase;
 
 #[RunTestsInSeparateProcesses]
-class NoChangesClassTest extends TestCase
+class NoChangesTest extends TestCase
 {
     use ClassLoaderMockTrait;
 
     public function testNoChangesClass(): void
     {
         Util::clearCache();
-        ApplicationKernel::init();
+        Kernel::init();
 
-        $class = NoChangesClass::class;
+        $class = Target::class;
         $this->assertWillBeTransformed($class);
 
         new $class();
@@ -27,15 +25,15 @@ public function testNoChangesClass(): void
 
     public function testCachedNoChangesClass(): void
     {
-        ApplicationKernel::init();
+        Kernel::init();
 
-        $class = NoChangesClass::class;
+        $class = Target::class;
         $this->assertTransformerNotApplied($class);
 
         new $class();
 
-        $originalFilePath = Util::CLASSES_TO_TRANSFORM_DIR . '/NoChangesClass.php';
-        $cachedFilePath   = Util::CACHED_CLASSES_TO_TRANSFORM_DIR . '/NoChangesClass.php';
+        $originalFilePath = Util::getFilePath(Target::class);
+        $cachedFilePath   = Util::getTransformedFilePath(Target::class);
         $this->assertFileExists($originalFilePath);
         $this->assertFileDoesNotExist($cachedFilePath);
     }
diff --git a/tests/Functional/Target/NoChanges/Target.php b/tests/Functional/Target/NoChanges/Target.php
new file mode 100644
index 0000000..adf09f0
--- /dev/null
+++ b/tests/Functional/Target/NoChanges/Target.php
@@ -0,0 +1,7 @@
+<?php
+
+namespace Okapi\CodeTransformer\Tests\Functional\Target\NoChanges;
+
+class Target
+{
+}
diff --git a/tests/Functional/Target/NoChanges/Transformer.php b/tests/Functional/Target/NoChanges/Transformer.php
new file mode 100644
index 0000000..e3f2d54
--- /dev/null
+++ b/tests/Functional/Target/NoChanges/Transformer.php
@@ -0,0 +1,19 @@
+<?php
+
+namespace Okapi\CodeTransformer\Tests\Functional\Target\NoChanges;
+
+use Okapi\CodeTransformer\Transformer as TransformerClass;
+use Okapi\CodeTransformer\Transformer\Code;
+
+class Transformer extends TransformerClass
+{
+    public function getTargetClass(): string|array
+    {
+        return [Target::class];
+    }
+
+    public function transform(Code $code): void
+    {
+        // No changes
+    }
+}
diff --git a/tests/Stubs/Transformer/InvalidTransformer.php b/tests/Functional/Transformer/InvalidTransformerClass/InvalidTransformer.php
similarity index 57%
rename from tests/Stubs/Transformer/InvalidTransformer.php
rename to tests/Functional/Transformer/InvalidTransformerClass/InvalidTransformer.php
index ea3c32b..65e9dd8 100644
--- a/tests/Stubs/Transformer/InvalidTransformer.php
+++ b/tests/Functional/Transformer/InvalidTransformerClass/InvalidTransformer.php
@@ -1,8 +1,8 @@
 <?php
 
-namespace Okapi\CodeTransformer\Tests\Stubs\Transformer;
+namespace Okapi\CodeTransformer\Tests\Functional\Transformer\InvalidTransformerClass;
 
-use Okapi\CodeTransformer\Tests\Stubs\ClassesToTransform\StringClass;
+use Okapi\CodeTransformer\Tests\Functional\Cache\CachedFileAndDestructor\Target\StringClass;
 use Okapi\CodeTransformer\Transformer\Code;
 
 class InvalidTransformer
diff --git a/tests/Functional/Transformer/InvalidTransformerClass/InvalidTransformerClassTest.php b/tests/Functional/Transformer/InvalidTransformerClass/InvalidTransformerClassTest.php
new file mode 100644
index 0000000..826f683
--- /dev/null
+++ b/tests/Functional/Transformer/InvalidTransformerClass/InvalidTransformerClassTest.php
@@ -0,0 +1,53 @@
+<?php
+
+namespace Okapi\CodeTransformer\Tests\Functional\Transformer\InvalidTransformerClass;
+
+use Okapi\CodeTransformer\Core\Exception\Transformer\InvalidTransformerClassException;
+use Okapi\CodeTransformer\Core\Exception\Transformer\InvalidTransformerClassNameException;
+use Okapi\CodeTransformer\Core\Exception\Transformer\TransformerNotFoundException;
+use Okapi\CodeTransformer\Tests\Functional\Transformer\InvalidTransformerClass\Kernel\InvalidTransformerTypeKernel;
+use Okapi\CodeTransformer\Tests\Functional\Transformer\InvalidTransformerClass\Kernel\TransformerDoesNotExistKernel;
+use Okapi\CodeTransformer\Tests\Functional\Transformer\InvalidTransformerClass\Kernel\TransformerDoesNotExtendTransformerKernel;
+use Okapi\CodeTransformer\Tests\Util;
+use PHPUnit\Framework\Attributes\RunTestsInSeparateProcesses;
+use PHPUnit\Framework\TestCase;
+
+#[RunTestsInSeparateProcesses]
+class InvalidTransformerClassTest extends TestCase
+{
+    /**
+     * @see TransformerDoesNotExistKernel
+     */
+    public function testTransformerNotFound(): void
+    {
+        Util::clearCache();
+
+        $this->expectException(TransformerNotFoundException::class);
+
+        TransformerDoesNotExistKernel::init();
+    }
+
+    /**
+     * @see InvalidTransformerTypeKernel
+     */
+    public function testInvalidTransformerType(): void
+    {
+        Util::clearCache();
+
+        $this->expectException(InvalidTransformerClassNameException::class);
+
+        InvalidTransformerTypeKernel::init();
+    }
+
+    /**
+     * @see TransformerDoesNotExtendTransformerKernel
+     */
+    public function testTransformerDoesNotExtendTransformer(): void
+    {
+        Util::clearCache();
+
+        $this->expectException(InvalidTransformerClassException::class);
+
+        TransformerDoesNotExtendTransformerKernel::init();
+    }
+}
diff --git a/tests/Functional/Transformer/InvalidTransformerClass/Kernel/InvalidTransformerTypeKernel.php b/tests/Functional/Transformer/InvalidTransformerClass/Kernel/InvalidTransformerTypeKernel.php
new file mode 100644
index 0000000..b07fa30
--- /dev/null
+++ b/tests/Functional/Transformer/InvalidTransformerClass/Kernel/InvalidTransformerTypeKernel.php
@@ -0,0 +1,12 @@
+<?php
+
+namespace Okapi\CodeTransformer\Tests\Functional\Transformer\InvalidTransformerClass\Kernel;
+
+use Okapi\CodeTransformer\CodeTransformerKernel;
+
+class InvalidTransformerTypeKernel extends CodeTransformerKernel
+{
+    protected array $transformers = [
+        42,
+    ];
+}
diff --git a/tests/Stubs/Kernel/TransformerDoesNotExistKernel.php b/tests/Functional/Transformer/InvalidTransformerClass/Kernel/TransformerDoesNotExistKernel.php
similarity index 72%
rename from tests/Stubs/Kernel/TransformerDoesNotExistKernel.php
rename to tests/Functional/Transformer/InvalidTransformerClass/Kernel/TransformerDoesNotExistKernel.php
index d4cee34..8073489 100644
--- a/tests/Stubs/Kernel/TransformerDoesNotExistKernel.php
+++ b/tests/Functional/Transformer/InvalidTransformerClass/Kernel/TransformerDoesNotExistKernel.php
@@ -1,6 +1,6 @@
 <?php
 
-namespace Okapi\CodeTransformer\Tests\Stubs\Kernel;
+namespace Okapi\CodeTransformer\Tests\Functional\Transformer\InvalidTransformerClass\Kernel;
 
 use Okapi\CodeTransformer\CodeTransformerKernel;
 use Okapi\CodeTransformer\Tests\Util;
diff --git a/tests/Stubs/Kernel/TransformerDoesNotExtendTransformerKernel.php b/tests/Functional/Transformer/InvalidTransformerClass/Kernel/TransformerDoesNotExtendTransformerKernel.php
similarity index 59%
rename from tests/Stubs/Kernel/TransformerDoesNotExtendTransformerKernel.php
rename to tests/Functional/Transformer/InvalidTransformerClass/Kernel/TransformerDoesNotExtendTransformerKernel.php
index 7efc63c..b38ae4c 100644
--- a/tests/Stubs/Kernel/TransformerDoesNotExtendTransformerKernel.php
+++ b/tests/Functional/Transformer/InvalidTransformerClass/Kernel/TransformerDoesNotExtendTransformerKernel.php
@@ -1,9 +1,9 @@
 <?php
 
-namespace Okapi\CodeTransformer\Tests\Stubs\Kernel;
+namespace Okapi\CodeTransformer\Tests\Functional\Transformer\InvalidTransformerClass\Kernel;
 
 use Okapi\CodeTransformer\CodeTransformerKernel;
-use Okapi\CodeTransformer\Tests\Stubs\Transformer\InvalidTransformer;
+use Okapi\CodeTransformer\Tests\Functional\Transformer\InvalidTransformerClass\InvalidTransformer;
 use Okapi\CodeTransformer\Tests\Util;
 
 class TransformerDoesNotExtendTransformerKernel extends CodeTransformerKernel
diff --git a/tests/Functional/Transformer/MultipleTransformer/Kernel.php b/tests/Functional/Transformer/MultipleTransformer/Kernel.php
new file mode 100644
index 0000000..83bed4e
--- /dev/null
+++ b/tests/Functional/Transformer/MultipleTransformer/Kernel.php
@@ -0,0 +1,18 @@
+<?php
+
+namespace Okapi\CodeTransformer\Tests\Functional\Transformer\MultipleTransformer;
+
+use Okapi\CodeTransformer\CodeTransformerKernel;
+use Okapi\CodeTransformer\Tests\Functional\Cache\CachedFileAndDestructor\Transformer\StringTransformer;
+use Okapi\CodeTransformer\Tests\Functional\Transformer\MultipleTransformer\Transformer\UnPrivateTransformer;
+use Okapi\CodeTransformer\Tests\Util;
+
+class Kernel extends CodeTransformerKernel
+{
+    protected ?string $cacheDir = Util::CACHE_DIR;
+
+    protected array $transformers = [
+        StringTransformer::class,
+        UnPrivateTransformer::class,
+    ];
+}
diff --git a/tests/Functional/MultipleTransformersTest.php b/tests/Functional/Transformer/MultipleTransformer/MultipleTransformersTest.php
similarity index 73%
rename from tests/Functional/MultipleTransformersTest.php
rename to tests/Functional/Transformer/MultipleTransformer/MultipleTransformersTest.php
index 36668b5..25c88aa 100644
--- a/tests/Functional/MultipleTransformersTest.php
+++ b/tests/Functional/Transformer/MultipleTransformer/MultipleTransformersTest.php
@@ -1,10 +1,8 @@
 <?php
 
-namespace Okapi\CodeTransformer\Tests\Functional;
+namespace Okapi\CodeTransformer\Tests\Functional\Transformer\MultipleTransformer;
 
 use Okapi\CodeTransformer\Tests\ClassLoaderMockTrait;
-use Okapi\CodeTransformer\Tests\Stubs\ClassesToTransform\MultipleTransformersClass;
-use Okapi\CodeTransformer\Tests\Stubs\Kernel\ApplicationKernel;
 use Okapi\CodeTransformer\Tests\Util;
 use PHPUnit\Framework\Attributes\RunTestsInSeparateProcesses;
 use PHPUnit\Framework\TestCase;
@@ -17,9 +15,9 @@ class MultipleTransformersTest extends TestCase
     public function testMultipleTransformers(): void
     {
         Util::clearCache();
-        ApplicationKernel::init();
+        Kernel::init();
 
-        $class = MultipleTransformersClass::class;
+        $class = TargetClass::class;
         $this->assertWillBeTransformed($class);
 
         $multipleTransformersClass = new $class();
@@ -37,9 +35,9 @@ public function testMultipleTransformers(): void
 
     public function testCachedMultipleTransformers(): void
     {
-        ApplicationKernel::init();
+        Kernel::init();
 
-        $class = MultipleTransformersClass::class;
+        $class = TargetClass::class;
         $this->assertTransformerLoadedFromCache($class);
 
         $multipleTransformersClass = new $class();
diff --git a/tests/Stubs/ClassesToTransform/MultipleTransformersClass.php b/tests/Functional/Transformer/MultipleTransformer/TargetClass.php
similarity index 60%
rename from tests/Stubs/ClassesToTransform/MultipleTransformersClass.php
rename to tests/Functional/Transformer/MultipleTransformer/TargetClass.php
index c5b9079..4cb8be8 100644
--- a/tests/Stubs/ClassesToTransform/MultipleTransformersClass.php
+++ b/tests/Functional/Transformer/MultipleTransformer/TargetClass.php
@@ -1,8 +1,8 @@
 <?php
 /** @noinspection ALL */
-namespace Okapi\CodeTransformer\Tests\Stubs\ClassesToTransform;
+namespace Okapi\CodeTransformer\Tests\Functional\Transformer\MultipleTransformer;
 
-class MultipleTransformersClass
+class TargetClass
 {
     private string $privateProperty = "You can't get me!";
 
diff --git a/tests/Stubs/Transformer/UnPrivateTransformer.php b/tests/Functional/Transformer/MultipleTransformer/Transformer/UnPrivateTransformer.php
similarity index 69%
rename from tests/Stubs/Transformer/UnPrivateTransformer.php
rename to tests/Functional/Transformer/MultipleTransformer/Transformer/UnPrivateTransformer.php
index 77ab019..a90d539 100644
--- a/tests/Stubs/Transformer/UnPrivateTransformer.php
+++ b/tests/Functional/Transformer/MultipleTransformer/Transformer/UnPrivateTransformer.php
@@ -1,9 +1,9 @@
 <?php
 
-namespace Okapi\CodeTransformer\Tests\Stubs\Transformer;
+namespace Okapi\CodeTransformer\Tests\Functional\Transformer\MultipleTransformer\Transformer;
 
 use Microsoft\PhpParser\TokenKind;
-use Okapi\CodeTransformer\Tests\Stubs\ClassesToTransform\MultipleTransformersClass;
+use Okapi\CodeTransformer\Tests\Functional\Transformer\MultipleTransformer\TargetClass;
 use Okapi\CodeTransformer\Transformer;
 use Okapi\CodeTransformer\Transformer\Code;
 
@@ -11,7 +11,7 @@ class UnPrivateTransformer extends Transformer
 {
     public function getTargetClass(): string|array
     {
-        return MultipleTransformersClass::class;
+        return TargetClass::class;
     }
 
     public function transform(Code $code): void
diff --git a/tests/Functional/Transformer/SyntaxErrorInTransformedClass/Kernel.php b/tests/Functional/Transformer/SyntaxErrorInTransformedClass/Kernel.php
new file mode 100644
index 0000000..5d0858c
--- /dev/null
+++ b/tests/Functional/Transformer/SyntaxErrorInTransformedClass/Kernel.php
@@ -0,0 +1,15 @@
+<?php
+
+namespace Okapi\CodeTransformer\Tests\Functional\Transformer\SyntaxErrorInTransformedClass;
+
+use Okapi\CodeTransformer\CodeTransformerKernel;
+use Okapi\CodeTransformer\Tests\Util;
+
+class Kernel extends CodeTransformerKernel
+{
+    protected ?string $cacheDir = Util::CACHE_DIR;
+
+    protected array $transformers = [
+        Transformer::class,
+    ];
+}
diff --git a/tests/Functional/SyntaxErrorClassTest.php b/tests/Functional/Transformer/SyntaxErrorInTransformedClass/SyntaxErrorInTransformedClassTest.php
similarity index 60%
rename from tests/Functional/SyntaxErrorClassTest.php
rename to tests/Functional/Transformer/SyntaxErrorInTransformedClass/SyntaxErrorInTransformedClassTest.php
index 01ac0f7..861042e 100644
--- a/tests/Functional/SyntaxErrorClassTest.php
+++ b/tests/Functional/Transformer/SyntaxErrorInTransformedClass/SyntaxErrorInTransformedClassTest.php
@@ -1,28 +1,26 @@
 <?php
 
-namespace Okapi\CodeTransformer\Tests\Functional;
+namespace Okapi\CodeTransformer\Tests\Functional\Transformer\SyntaxErrorInTransformedClass;
 
 use Okapi\CodeTransformer\Core\Exception\Transformer\SyntaxError;
 use Okapi\CodeTransformer\Tests\ClassLoaderMockTrait;
-use Okapi\CodeTransformer\Tests\Stubs\ClassesToTransform\SyntaxErrorClass;
-use Okapi\CodeTransformer\Tests\Stubs\Kernel\ApplicationKernel;
 use Okapi\CodeTransformer\Tests\Util;
 use PHPUnit\Framework\Attributes\RunTestsInSeparateProcesses;
 use PHPUnit\Framework\TestCase;
 
 #[RunTestsInSeparateProcesses]
-class SyntaxErrorClassTest extends TestCase
+class SyntaxErrorInTransformedClassTest extends TestCase
 {
     use ClassLoaderMockTrait;
 
     public function testSyntaxErrorClass(): void
     {
         Util::clearCache();
-        ApplicationKernel::init();
+        Kernel::init();
 
         $this->expectException(SyntaxError::class);
 
         /** @noinspection PhpUnusedLocalVariableInspection */
-        $syntaxErrorClass = new SyntaxErrorClass();
+        $syntaxErrorClass = new Target();
     }
 }
diff --git a/tests/Functional/Transformer/SyntaxErrorInTransformedClass/Target.php b/tests/Functional/Transformer/SyntaxErrorInTransformedClass/Target.php
new file mode 100644
index 0000000..74cb482
--- /dev/null
+++ b/tests/Functional/Transformer/SyntaxErrorInTransformedClass/Target.php
@@ -0,0 +1,7 @@
+<?php
+
+namespace Okapi\CodeTransformer\Tests\Functional\Transformer\SyntaxErrorInTransformedClass;
+
+class Target
+{
+}
diff --git a/tests/Stubs/Transformer/SyntaxErrorTransformer.php b/tests/Functional/Transformer/SyntaxErrorInTransformedClass/Transformer.php
similarity index 50%
rename from tests/Stubs/Transformer/SyntaxErrorTransformer.php
rename to tests/Functional/Transformer/SyntaxErrorInTransformedClass/Transformer.php
index 9c07c6a..2fc3773 100644
--- a/tests/Stubs/Transformer/SyntaxErrorTransformer.php
+++ b/tests/Functional/Transformer/SyntaxErrorInTransformedClass/Transformer.php
@@ -1,16 +1,15 @@
 <?php
 
-namespace Okapi\CodeTransformer\Tests\Stubs\Transformer;
+namespace Okapi\CodeTransformer\Tests\Functional\Transformer\SyntaxErrorInTransformedClass;
 
-use Okapi\CodeTransformer\Tests\Stubs\ClassesToTransform\SyntaxErrorClass;
-use Okapi\CodeTransformer\Transformer;
+use Okapi\CodeTransformer\Transformer as TransformerClass;
 use Okapi\CodeTransformer\Transformer\Code;
 
-class SyntaxErrorTransformer extends Transformer
+class Transformer extends TransformerClass
 {
     public function getTargetClass(): string|array
     {
-        return SyntaxErrorClass::class;
+        return Target::class;
     }
 
     public function transform(Code $code): void
@@ -18,7 +17,7 @@ public function transform(Code $code): void
         $code->append('}');
 
         $refClass = $code->getReflectionClass();
-        assert($refClass->getName() === SyntaxErrorClass::class);
+        assert($refClass->getName() === Target::class);
 
         $className = $code->getClassName();
         assert($className === 'SyntaxErrorClass');
diff --git a/tests/Stubs/ClassesToTransform/ChangedClass.php b/tests/Stubs/ClassesToTransform/ChangedClass.php
deleted file mode 100644
index b7f6e90..0000000
--- a/tests/Stubs/ClassesToTransform/ChangedClass.php
+++ /dev/null
@@ -1,11 +0,0 @@
-<?php
-
-namespace Okapi\CodeTransformer\Tests\Stubs\ClassesToTransform;
-
-class ChangedClass
-{
-    public function test(): string
-    {
-        return 'Hello World!';
-    }
-}
diff --git a/tests/Stubs/ClassesToTransform/DeleteCacheFileClass.php b/tests/Stubs/ClassesToTransform/DeleteCacheFileClass.php
deleted file mode 100644
index 7f1a5fb..0000000
--- a/tests/Stubs/ClassesToTransform/DeleteCacheFileClass.php
+++ /dev/null
@@ -1,11 +0,0 @@
-<?php
-
-namespace Okapi\CodeTransformer\Tests\Stubs\ClassesToTransform;
-
-class DeleteCacheFileClass
-{
-    public function test(): string
-    {
-        return 'Hello World!';
-    }
-}
diff --git a/tests/Stubs/ClassesToTransform/NoChangesClass.php b/tests/Stubs/ClassesToTransform/NoChangesClass.php
deleted file mode 100644
index cb5bae9..0000000
--- a/tests/Stubs/ClassesToTransform/NoChangesClass.php
+++ /dev/null
@@ -1,8 +0,0 @@
-<?php
-
-namespace Okapi\CodeTransformer\Tests\Stubs\ClassesToTransform;
-
-class NoChangesClass
-{
-
-}
diff --git a/tests/Stubs/ClassesToTransform/SyntaxErrorClass.php b/tests/Stubs/ClassesToTransform/SyntaxErrorClass.php
deleted file mode 100644
index de96d57..0000000
--- a/tests/Stubs/ClassesToTransform/SyntaxErrorClass.php
+++ /dev/null
@@ -1,8 +0,0 @@
-<?php
-
-namespace Okapi\CodeTransformer\Tests\Stubs\ClassesToTransform;
-
-class SyntaxErrorClass
-{
-
-}
diff --git a/tests/Stubs/Kernel/AddedTransformerKernel.php b/tests/Stubs/Kernel/AddedTransformerKernel.php
deleted file mode 100644
index aa2a8aa..0000000
--- a/tests/Stubs/Kernel/AddedTransformerKernel.php
+++ /dev/null
@@ -1,19 +0,0 @@
-<?php
-
-namespace Okapi\CodeTransformer\Tests\Stubs\Kernel;
-
-use Okapi\CodeTransformer\Tests\Stubs\Transformer\AddedTransformer2;
-
-class AddedTransformerKernel extends ApplicationKernel
-{
-    protected array $addedTransformers = [
-        AddedTransformer2::class,
-    ];
-
-    protected function preInit(): void
-    {
-        parent::preInit();
-
-        $this->transformerManager->addTransformers($this->addedTransformers);
-    }
-}
diff --git a/tests/Stubs/Kernel/ApplicationKernel.php b/tests/Stubs/Kernel/ApplicationKernel.php
deleted file mode 100644
index 9546482..0000000
--- a/tests/Stubs/Kernel/ApplicationKernel.php
+++ /dev/null
@@ -1,28 +0,0 @@
-<?php
-
-namespace Okapi\CodeTransformer\Tests\Stubs\Kernel;
-
-use Okapi\CodeTransformer\CodeTransformerKernel;
-use Okapi\CodeTransformer\Tests\Stubs\Transformer\AddedTransformer1;
-use Okapi\CodeTransformer\Tests\Stubs\Transformer\ChangedClassTransformer;
-use Okapi\CodeTransformer\Tests\Stubs\Transformer\DeleteCacheFileTransformer;
-use Okapi\CodeTransformer\Tests\Stubs\Transformer\NoChangesTransformer;
-use Okapi\CodeTransformer\Tests\Stubs\Transformer\StringTransformer;
-use Okapi\CodeTransformer\Tests\Stubs\Transformer\SyntaxErrorTransformer;
-use Okapi\CodeTransformer\Tests\Stubs\Transformer\UnPrivateTransformer;
-use Okapi\CodeTransformer\Tests\Util;
-
-class ApplicationKernel extends CodeTransformerKernel
-{
-    protected ?string $cacheDir = Util::CACHE_DIR;
-
-    protected array $transformers = [
-        StringTransformer::class,
-        NoChangesTransformer::class,
-        SyntaxErrorTransformer::class,
-        ChangedClassTransformer::class,
-        DeleteCacheFileTransformer::class,
-        UnPrivateTransformer::class,
-        AddedTransformer1::class,
-    ];
-}
diff --git a/tests/Stubs/Transformer/DeleteCacheFileTransformer.php b/tests/Stubs/Transformer/DeleteCacheFileTransformer.php
deleted file mode 100644
index bb6831f..0000000
--- a/tests/Stubs/Transformer/DeleteCacheFileTransformer.php
+++ /dev/null
@@ -1,20 +0,0 @@
-<?php
-
-namespace Okapi\CodeTransformer\Tests\Stubs\Transformer;
-
-use Okapi\CodeTransformer\Tests\Stubs\ClassesToTransform\DeleteCacheFileClass;
-use Okapi\CodeTransformer\Transformer;
-use Okapi\CodeTransformer\Transformer\Code;
-
-class DeleteCacheFileTransformer extends Transformer
-{
-    public function getTargetClass(): string|array
-    {
-        return DeleteCacheFileClass::class;
-    }
-
-    public function transform(Code $code): void
-    {
-        $code->append('// Hello from Code Transformer!');
-    }
-}
diff --git a/tests/Stubs/Transformer/NoChangesTransformer.php b/tests/Stubs/Transformer/NoChangesTransformer.php
deleted file mode 100644
index d5a9150..0000000
--- a/tests/Stubs/Transformer/NoChangesTransformer.php
+++ /dev/null
@@ -1,20 +0,0 @@
-<?php
-
-namespace Okapi\CodeTransformer\Tests\Stubs\Transformer;
-
-use Okapi\CodeTransformer\Tests\Stubs\ClassesToTransform\NoChangesClass;
-use Okapi\CodeTransformer\Transformer;
-use Okapi\CodeTransformer\Transformer\Code;
-
-class NoChangesTransformer extends Transformer
-{
-    public function getTargetClass(): string|array
-    {
-        return [NoChangesClass::class];
-    }
-
-    public function transform(Code $code): void
-    {
-        // No changes
-    }
-}
diff --git a/tests/Util.php b/tests/Util.php
index 653006f..d6209d4 100644
--- a/tests/Util.php
+++ b/tests/Util.php
@@ -6,12 +6,10 @@
 
 class Util
 {
-    public const CACHE_DIR                       = __DIR__ . '/cache';
-    public const STUBS_DIR                       = __DIR__ . '/Stubs';
-    public const CACHED_STUBS_DIR                = self::CACHE_DIR . '/transformed/tests/Stubs';
-    public const CLASSES_TO_TRANSFORM_DIR        = self::STUBS_DIR . '/ClassesToTransform';
-    public const CACHED_CLASSES_TO_TRANSFORM_DIR = self::CACHED_STUBS_DIR . '/ClassesToTransform';
-    public const TMP_DIR                         = __DIR__ . '/tmp';
+    private const TESTS_DIR                   = __DIR__;
+
+    public const CACHE_DIR                    = self::TESTS_DIR . '/cache';
+    private const CACHE_DIR_TRANSFORMED_TESTS = self::CACHE_DIR . '/transformed/tests';
 
     public const CACHE_STATES_FILE = self::CACHE_DIR . '/cache_states.php';
 
@@ -22,10 +20,39 @@ public static function clearCache(): void
             recursive: true,
             force: true,
         );
-        Filesystem::rm(
-            path: Util::TMP_DIR,
-            recursive: true,
-            force: true,
+    }
+
+    public static function getFilePath(string $class): string
+    {
+        $class = str_replace(
+            search: 'Okapi\CodeTransformer\Tests\\',
+            replace: '',
+            subject: $class,
+        );
+
+        $class = str_replace(
+            search: '\\',
+            replace: '/',
+            subject: $class,
         );
+
+        return Util::TESTS_DIR . '/' . $class . '.php';
+    }
+
+    public static function getTransformedFilePath(string $class): string
+    {
+        $class = str_replace(
+            search: 'Okapi\CodeTransformer\Tests\\',
+            replace: '',
+            subject: $class,
+        );
+
+        $class = str_replace(
+            search: '\\',
+            replace: '/',
+            subject: $class,
+        );
+
+        return Util::CACHE_DIR_TRANSFORMED_TESTS . '/' . $class . '.php';
     }
 }