@@ -13,9 +13,18 @@
 
 namespace CodeIgniter\Cache\FactoriesCache;
 
-final class FileVarExportHandler
+final readonly class FileVarExportHandler
 {
-    private string $path = WRITEPATH . 'cache';
+    private string $path;
+
+    /**
+     * @param string|null $path The directory where the cache files are stored.
+     *                          Defaults to the "writable/cache" directory.
+     */
+    public function __construct(?string $path = null)
+    {
+        $this->path = rtrim($path ?? WRITEPATH . 'cache', '/');
+    }
 
     public function save(string $key, mixed $val): void
     {
 
@@ -0,0 +1,72 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * This file is part of CodeIgniter 4 framework.
+ *
+ * (c) CodeIgniter Foundation <admin@codeigniter.com>
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+namespace Tests\Support\Cache;
+
+use CodeIgniter\Cache\FactoriesCache\FileVarExportHandler;
+
+/**
+ * Gives the test class its own directory for the files created
+ * by the FileVarExportHandler.
+ *
+ * The handler stores its files in the shared "writable/cache" directory by
+ * default. Since the random test execution runs the components in parallel,
+ * one component may delete the cache file that another component is
+ * asserting on. A dedicated directory per test class avoids that.
+ */
+trait IsolatedCacheTrait
+{
+    /**
+     * The directory used to store the cache files of the test class.
+     */
+    private static string $isolatedCachePath;
+
+    public static function setUpBeforeClassIsolatedCache(): void
+    {
+        helper('filesystem');
+
+        self::$isolatedCachePath = WRITEPATH . 'cache_test_' . str_replace('\\', '_', static::class);
+
+        // Remove the files left over by a previous run.
+        if (is_dir(self::$isolatedCachePath)) {
+            delete_files(self::$isolatedCachePath, true);
+            @rmdir(self::$isolatedCachePath);
+        }
+    }
+
+    public static function tearDownAfterClassIsolatedCache(): void
+    {
+        if (! isset(self::$isolatedCachePath) || ! is_dir(self::$isolatedCachePath)) {
+            return;
+        }
+
+        delete_files(self::$isolatedCachePath, true);
+        @rmdir(self::$isolatedCachePath);
+    }
+
+    /**
+     * Returns a handler that stores its files in the isolated directory.
+     */
+    protected function getIsolatedCacheHandler(): FileVarExportHandler
+    {
+        return new FileVarExportHandler(self::$isolatedCachePath);
+    }
+
+    /**
+     * Returns the path of the isolated cache directory.
+     */
+    protected static function getIsolatedCachePath(): string
+    {
+        return self::$isolatedCachePath;
+    }
+}
@@ -17,25 +17,37 @@
 use Config\Autoload;
 use Config\Modules;
 use PHPUnit\Framework\Attributes\Group;
+use Tests\Support\Cache\IsolatedCacheTrait;
 
 /**
  * @internal
  */
 #[Group('Others')]
 final class FileLocatorCachedTest extends FileLocatorTest
 {
+    use IsolatedCacheTrait;
+
     private FileVarExportHandler $handler;
 
-    public static function tearDownAfterClass(): void
+    public static function setUpBeforeClass(): void
     {
-        parent::tearDownAfterClass();
+        parent::setUpBeforeClass();
 
+        self::setUpBeforeClassIsolatedCache();
+    }
+
+    public static function tearDownAfterClass(): void
+    {
         // Delete cache file.
         $autoloader  = new Autoloader();
-        $handler     = new FileVarExportHandler();
+        $handler     = new FileVarExportHandler(self::getIsolatedCachePath());
         $fileLocator = new FileLocator($autoloader);
         $locator     = new FileLocatorCached($fileLocator, $handler);
         $locator->deleteCache();
+
+        self::tearDownAfterClassIsolatedCache();
+
+        parent::tearDownAfterClass();
     }
 
     protected function setUp(): void
@@ -61,7 +73,7 @@ protected function setUp(): void
             'Acme\Sample'        => TESTPATH . '_support/does/not/exists',
         ]);
 
-        $this->handler = new FileVarExportHandler();
+        $this->handler = $this->getIsolatedCacheHandler();
         $fileLocator   = new FileLocator($autoloader);
         $this->locator = new FileLocatorCached($fileLocator, $this->handler);
     }
@@ -70,6 +82,10 @@ protected function tearDown(): void
     {
         $this->locator->__destruct();
 
+        // Prevent the destructor from writing the cache file
+        // when the test object is destroyed.
+        $this->locator->deleteCache();
+
         parent::tearDown();
     }
 
 
@@ -15,34 +15,52 @@
 
 use CodeIgniter\Cache\FactoriesCache\FileVarExportHandler;
 use PHPUnit\Framework\Attributes\Group;
+use Tests\Support\Cache\IsolatedCacheTrait;
 
 /**
  * @internal
  */
 #[Group('Others')]
 final class FactoriesCacheFileVarExportHandlerTest extends AbstractFactoriesCacheHandlerTestCase
 {
+    use IsolatedCacheTrait;
+
     public static function setUpBeforeClass(): void
     {
         parent::setUpBeforeClass();
 
+        self::setUpBeforeClassIsolatedCache();
+
         helper('filesystem');
     }
 
+    public static function tearDownAfterClass(): void
+    {
+        self::tearDownAfterClassIsolatedCache();
+
+        parent::tearDownAfterClass();
+    }
+
     protected function createFactoriesCache(): void
     {
-        $this->handler = new FileVarExportHandler();
+        $this->handler = $this->getIsolatedCacheHandler();
         $this->cache   = new FactoriesCache($this->handler);
     }
 
+    public function testUsesTheWritableCacheDirectoryByDefault(): void
+    {
+        $handler = new FileVarExportHandler();
+
+        $this->assertSame(WRITEPATH . 'cache', $this->getPrivateProperty($handler, 'path'));
+    }
+
     public function testSaveCreatesDirectoryAndFileWithCorrectPermissions(): void
     {
         $dir      = WRITEPATH . 'cache_test_dir_' . uniqid('', true);
         $oldUmask = umask(0000);
 
         try {
-            $handler = new FileVarExportHandler();
-            $this->setPrivateProperty($handler, 'path', $dir);
+            $handler = new FileVarExportHandler($dir);
 
             $handler->save('test_key', ['data']);
 
 
@@ -16,7 +16,6 @@
 use CodeIgniter\Autoloader\FileLocator;
 use CodeIgniter\Autoloader\FileLocatorCached;
 use CodeIgniter\Cache\CacheFactory;
-use CodeIgniter\Cache\FactoriesCache\FileVarExportHandler;
 use CodeIgniter\Cache\Handlers\FileHandler;
 use CodeIgniter\CLI\CLI;
 use CodeIgniter\Config\Factories;
@@ -25,17 +24,33 @@
 use Config\Cache;
 use Config\Services;
 use PHPUnit\Framework\Attributes\Group;
+use Tests\Support\Cache\IsolatedCacheTrait;
 
 /**
  * @internal
  */
 #[Group('Others')]
 final class ClearCacheTest extends CIUnitTestCase
 {
+    use IsolatedCacheTrait;
     use StreamFilterTrait;
 
     private Cache $config;
 
+    public static function setUpBeforeClass(): void
+    {
+        parent::setUpBeforeClass();
+
+        self::setUpBeforeClassIsolatedCache();
+    }
+
+    public static function tearDownAfterClass(): void
+    {
+        self::tearDownAfterClassIsolatedCache();
+
+        parent::tearDownAfterClass();
+    }
+
     protected function setUp(): void
     {
         parent::setUp();
@@ -98,7 +113,7 @@ public function testClearCacheWorks(): void
 
     public function testClearCacheDiscardsSharedLocatorCache(): void
     {
-        $handler = new FileVarExportHandler();
+        $handler = $this->getIsolatedCacheHandler();
         $handler->delete('FileLocatorCache');
 
         $locator = new FileLocatorCached(new FileLocator(service('autoloader')), $handler);
@@ -117,6 +132,10 @@ public function testClearCacheDiscardsSharedLocatorCache(): void
         $this->assertArrayHasKey('Config/Cache', $cached['search']);
 
         $handler->delete('FileLocatorCache');
+
+        // Prevent the destructor from writing the cache file
+        // when the locator is destroyed.
+        $locator->deleteCache();
     }
 
     public function testClearCacheFails(): void
 
@@ -22,23 +22,39 @@
 use CodeIgniter\Test\StreamFilterTrait;
 use Config\Services;
 use PHPUnit\Framework\Attributes\Group;
+use Tests\Support\Cache\IsolatedCacheTrait;
 
 /**
  * @internal
  */
 #[Group('Others')]
 final class OptimizeTest extends CIUnitTestCase
 {
+    use IsolatedCacheTrait;
     use ReflectionHelper;
     use StreamFilterTrait;
 
     private FileVarExportHandler $handler;
 
+    public static function setUpBeforeClass(): void
+    {
+        parent::setUpBeforeClass();
+
+        self::setUpBeforeClassIsolatedCache();
+    }
+
+    public static function tearDownAfterClass(): void
+    {
+        self::tearDownAfterClassIsolatedCache();
+
+        parent::tearDownAfterClass();
+    }
+
     protected function setUp(): void
     {
         parent::setUp();
 
-        $this->handler = new FileVarExportHandler();
+        $this->handler = $this->getIsolatedCacheHandler();
         $this->handler->delete('FileLocatorCache');
     }
 
@@ -74,12 +90,19 @@ public function testClearCacheDiscardsSharedLocatorCache(): void
         $this->assertArrayNotHasKey('Config/App', $cached['search']);
         $this->assertArrayHasKey('Config/Cache', $cached['search']);
         $this->assertStringContainsString('Removed FileLocatorCache.', $this->getStreamFilterBuffer());
+
+        // Prevent the destructor from writing the cache file
+        // when the locator is destroyed.
+        $locator->deleteCache();
     }
 
     public function testClearCacheDeletesTheFileWithoutSharedLocatorCache(): void
     {
         $this->handler->save('FileLocatorCache', ['search' => []]);
 
+        $locator = new FileLocatorCached(new FileLocator(service('autoloader')), $this->handler);
+        Services::injectMock('locator', $locator);
+
         ($this->getClearCache())();
 
         $this->assertFalse($this->handler->get('FileLocatorCache'));
 
@@ -24,6 +24,10 @@ Message Changes
 Changes
 *******
 
+- **Cache:** Added an optional ``$path`` parameter to
+  ``FileVarExportHandler::__construct()`` so the cache files can be stored in
+  a custom directory.
+
 ************
 Deprecations
 ************