WebSVN – Moodle – Diff – /cache/tests/cache_test.php

 // You should have received a copy of the GNU General Public License
 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
-namespace core_cache;
-use cache;
-use cache_application;
-use cache_config;
+namespace core_cache;
-use cache_config_disabled;
-use cache_config_testing;
-use cache_definition;
-use cache_disabled;
-use cache_factory;
-use cache_factory_disabled;
 use cache_helper;
-use cache_loader;
+use cache_config_testing;
 use cache_phpunit_application;
 use cache_phpunit_cache;
 use cache_phpunit_dummy_object;
 use cache_phpunit_dummy_overrideclass;
 use cache_phpunit_factory;
 use cache_phpunit_request;
 use cache_phpunit_session;
-use cache_request;
+use cachestore_file;
+use cachestore_session;
-use cache_session;
+use cachestore_static;
-use cache_store;
+use core\exception\coding_exception;
-use cacheable_object_array;
+use core\exception\moodle_exception;
 /**
  * PHPunit tests for the cache API
+ *
  * This file is part of Moodle's cache API, affectionately called MUC.
  * It contains the components that are requried in order to use caching.
+ *
- * @package    core
+ * @package    core_cache
  * @category   cache
- * @copyright  2012 Sam Hemelryk
- * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ * @copyright  2012 Sam Hemelryk
- * @coversDefaultClass \cache
+ * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- * @covers \cache
- */
+ * @covers \core_cache\cache
-class cache_test extends \advanced_testcase {
+ */
 final class cache_test extends \advanced_testcase {
     /**
      * Load required libraries and fixtures.
-     */
-    public static function setUpBeforeClass(): void {
+     */
-        global $CFG;
+    public static function setUpBeforeClass(): void {
+        global $CFG;
-        require_once($CFG->dirroot . '/cache/locallib.php');
+        require_once($CFG->dirroot . '/cache/tests/fixtures/lib.php');
-        require_once($CFG->dirroot . '/cache/tests/fixtures/lib.php');
+        require_once($CFG->dirroot . '/cache/tests/fixtures/cache_phpunit_dummy_datasource_versionable.php');
-        require_once($CFG->dirroot . '/cache/tests/fixtures/cache_phpunit_dummy_datasource_versionable.php');
+        parent::setUpBeforeClass();
+    }
     /**
      * Set things back to the default before each test.
      */
     public function setUp(): void {
         parent::setUp();
-        cache_factory::reset();
+        factory::reset();
         cache_config_testing::create_default_configuration();
+    }
+    /**
+     * Final task is to reset the cache system
+     */
+    public static function tearDownAfterClass(): void {
+        parent::tearDownAfterClass();
+        factory::reset();
+    }
+    /**
+     * Check if the $CFG->altcacheconfigpath tests can be run and skip the test if not.
+     *
+     * @throws \PHPUnit\Framework\SkippedTestError if the test is skipped
+     */
+    protected function skip_if_empty_alt_cache_path(): void {
+        if ((defined('TEST_CACHE_USING_ALT_CACHE_CONFIG_PATH') && TEST_CACHE_USING_ALT_CACHE_CONFIG_PATH)) {
-    /**
+            if (!empty($CFG->altcacheconfigpath)) {
-     * Final task is to reset the cache system
+                // We can't run this test as it requires us to delete the cache configuration script which we just
-     */
+                // cant do with a custom path in play.
+                $this->markTestSkipped('Skipped testing cache disable functionality as alt cache path is being used.');
     public static function tearDownAfterClass(): void {
         parent::tearDownAfterClass();
-        cache_factory::reset();
+    }
+    /**
-    /**
+     * Returns the expected application cache store.
-     * Returns the expected application cache store.
+     *
      * @return string
      */
-    protected function get_expected_application_cache_store() {
+    protected function get_expected_application_store(): string {
+        global $CFG;
+        $expected = cachestore_file::class;
-        global $CFG;
+        // Verify if we are using any of the available ways to use a different application store within tests.
-        $expected = 'cachestore_file';
+        if (!defined('TEST_CACHE_USING_APPLICATION_STORE') || empty(TEST_CACHE_USING_ALT_CACHE_CONFIG_PATH)) {
+            return $expected;
         // Verify if we are using any of the available ways to use a different application store within tests.
         if (defined('TEST_CACHE_USING_APPLICATION_STORE') && preg_match('#[a-zA-Z][a-zA-Z0-9_]*#', TEST_CACHE_USING_APPLICATION_STORE)) {
-            // 1st way. Using some of the testing servers.
+        if (preg_match('#[a-zA-Z][a-zA-Z0-9_]*#', TEST_CACHE_USING_APPLICATION_STORE)) {
-            $expected = 'cachestore_'.(string)TEST_CACHE_USING_APPLICATION_STORE;
+            // 1st way. Using some of the testing servers.
             $expected = 'cachestore_' . (string) TEST_CACHE_USING_APPLICATION_STORE;
-        } else if (defined('TEST_CACHE_USING_ALT_CACHE_CONFIG_PATH') && TEST_CACHE_USING_ALT_CACHE_CONFIG_PATH && !empty($CFG->altcacheconfigpath)) {
+        } else if (!empty($CFG->altcacheconfigpath)) {
             // 2nd way. Using an alternative configuration.
+            $defaultstores = helper::get_stores_suitable_for_mode_default();
-            $defaultstores = cache_helper::get_stores_suitable_for_mode_default();
+            $instance = config::instance();
-            $instance = cache_config::instance();
+            // Iterate over defined mode mappings until we get an application one not being the default.
+            foreach ($instance->get_mode_mappings() as $mapping) {
-            // Iterate over defined mode mappings until we get an application one not being the default.
+                // If the store is not for application mode, ignore.
-            foreach ($instance->get_mode_mappings() as $mapping) {
+                if ($mapping['mode'] !== store::MODE_APPLICATION) {
-                // If the store is not for application mode, ignore.
+                    continue;
-                if ($mapping['mode'] !== cache_store::MODE_APPLICATION) {
+                }
-                    continue;
+                // If the store matches some default mapping store name, ignore.
                 if (array_key_exists($mapping['store'], $defaultstores)) {
-                // If the store matches some default mapping store name, ignore.
+                    if (!empty($defaultstores[$mapping['store']]['default'])) {
-                if (array_key_exists($mapping['store'], $defaultstores) && !empty($defaultstores[$mapping['store']]['default'])) {
+                        continue;
      * Tests cache configuration
      */
     public function test_cache_config(): void {
         global $CFG;
-        if (defined('TEST_CACHE_USING_ALT_CACHE_CONFIG_PATH') && TEST_CACHE_USING_ALT_CACHE_CONFIG_PATH &&
-            !empty($CFG->altcacheconfigpath)) {
-            // We need to skip this test - it checks the default config structure, but very likely we arn't using the
-            // default config structure here so theres no point in running the test.
-            $this->markTestSkipped('Skipped testing default cache config structure as alt cache path is being used.');
-        }
-        if (defined('TEST_CACHE_USING_APPLICATION_STORE')) {
-            // We need to skip this test - it checks the default config structure, but very likely we arn't using the
-            // default config structure here because we are testing against an alternative application store.
-            $this->markTestSkipped('Skipped testing default cache config structure as alt application store is being used.');
-        }
+        $this->skip_if_empty_alt_cache_path();
-        $instance = cache_config::instance();
+        $instance = config::instance();
         $this->assertInstanceOf(cache_config_testing::class, $instance);
             $this->assertArrayHasKey('features', $store);
+        }
         $modemappings = $instance->get_mode_mappings();
         $this->assertCount(3, $modemappings);
-        $modes = array(
+        $modes = [
-            cache_store::MODE_APPLICATION => false,
+            store::MODE_APPLICATION => false,
-            cache_store::MODE_SESSION => false,
+            store::MODE_SESSION => false,
-            cache_store::MODE_REQUEST => false,
+            store::MODE_REQUEST => false,
-        );
+        ];
         foreach ($modemappings as $mapping) {
             // We expect 3 properties.
             $this->assertCount(3, $mapping);
             // Required attributes = mode + store.
     /**
      * Tests for cache keys that would break on windows.
      */
     public function test_windows_nasty_keys(): void {
         $instance = cache_config_testing::instance();
-        $instance->phpunit_add_definition('phpunit/windowskeytest', array(
+        $instance->phpunit_add_definition('phpunit/windowskeytest', [
-            'mode' => cache_store::MODE_APPLICATION,
+            'mode' => store::MODE_APPLICATION,
             'component' => 'phpunit',
             'area' => 'windowskeytest',
             'simplekeys' => true,
-            'simpledata' => true
+            'simpledata' => true,
-        ));
+        ]);
         $cache = cache::make('phpunit', 'windowskeytest');
         $this->assertTrue($cache->set('contest', 'test data 1'));
         $this->assertEquals('test data 1', $cache->get('contest'));
+    }
+     *
      * set_identifiers cannot be called after initial cache instantiation, as you need to create a difference cache.
      */
     public function test_set_identifiers(): void {
         $instance = cache_config_testing::instance();
-        $instance->phpunit_add_definition('phpunit/identifier', array(
+        $instance->phpunit_add_definition('phpunit/identifier', [
-            'mode' => cache_store::MODE_APPLICATION,
+            'mode' => store::MODE_APPLICATION,
             'component' => 'phpunit',
             'area' => 'identifier',
             'simplekeys' => true,
             'simpledata' => true,
-            'staticacceleration' => true
+            'staticacceleration' => true,
-        ));
+        ]);
-        $cache = cache::make('phpunit', 'identifier', array('area'));
+        $cache = cache::make('phpunit', 'identifier', ['area']);
         $this->assertTrue($cache->set('contest', 'test data 1'));
         $this->assertEquals('test data 1', $cache->get('contest'));
-        $this->expectException('coding_exception');
+        $this->expectException(coding_exception::class);
-        $cache->set_identifiers(array());
+        $cache->set_identifiers([]);
+    }
     /**
      * Tests the default application cache
      */
     public function test_default_application_cache(): void {
-        $cache = cache::make_from_params(cache_store::MODE_APPLICATION, 'phpunit', 'applicationtest');
+        $cache = cache::make_from_params(store::MODE_APPLICATION, 'phpunit', 'applicationtest');
-        $this->assertInstanceOf(cache_application::class, $cache);
+        $this->assertInstanceOf(application_cache::class, $cache);
         $this->run_on_cache($cache);
-        $instance = cache_config_testing::instance(true);
+        $instance = cache_config_testing::instance();
-        $instance->phpunit_add_definition('phpunit/test_default_application_cache', array(
+        $instance->phpunit_add_definition('phpunit/test_default_application_cache', [
-            'mode' => cache_store::MODE_APPLICATION,
+            'mode' => store::MODE_APPLICATION,
             'component' => 'phpunit',
             'area' => 'test_default_application_cache',
             'staticacceleration' => true,
-            'staticaccelerationsize' => 1
+            'staticaccelerationsize' => 1,
-        ));
+        ]);
         $cache = cache::make('phpunit', 'test_default_application_cache');
-        $this->assertInstanceOf(cache_application::class, $cache);
+        $this->assertInstanceOf(application_cache::class, $cache);
         $this->run_on_cache($cache);
+    }
     /**
      * Tests the default session cache
      */
     public function test_default_session_cache(): void {
-        $cache = cache::make_from_params(cache_store::MODE_SESSION, 'phpunit', 'applicationtest');
+        $cache = cache::make_from_params(store::MODE_SESSION, 'phpunit', 'applicationtest');
-        $this->assertInstanceOf(cache_session::class, $cache);
+        $this->assertInstanceOf(session_cache::class, $cache);
         $this->run_on_cache($cache);
+    }
     /**
      * Tests the default request cache
      */
     public function test_default_request_cache(): void {
-        $cache = cache::make_from_params(cache_store::MODE_REQUEST, 'phpunit', 'applicationtest');
+        $cache = cache::make_from_params(store::MODE_REQUEST, 'phpunit', 'applicationtest');
-        $this->assertInstanceOf(cache_request::class, $cache);
+        $this->assertInstanceOf(request_cache::class, $cache);
         $this->run_on_cache($cache);
     }
     /**
      * Tests using a cache system when there are no stores available (who knows what the admin did to achieve this).
      */
     public function test_on_cache_without_store(): void {
-        $instance = cache_config_testing::instance(true);
+        $instance = cache_config_testing::instance();
-        $instance->phpunit_add_definition('phpunit/nostoretest1', array(
+        $instance->phpunit_add_definition('phpunit/nostoretest1', [
-            'mode' => cache_store::MODE_APPLICATION,
+            'mode' => store::MODE_APPLICATION,
             'component' => 'phpunit',
             'area' => 'nostoretest1',
-        ));
+        ]);
-        $instance->phpunit_add_definition('phpunit/nostoretest2', array(
+        $instance->phpunit_add_definition('phpunit/nostoretest2', [
-            'mode' => cache_store::MODE_APPLICATION,
+            'mode' => store::MODE_APPLICATION,
             'component' => 'phpunit',
     /**
      * Runs a standard series of access and use tests on a cache instance.
+     *
      * This function is great because we can use it to ensure all of the loaders perform exactly the same way.
+     *
-     * @param cache_loader $cache
+     * @param loader_interface $cache
      */
-    protected function run_on_cache(cache_loader $cache) {
+    protected function run_on_cache(loader_interface $cache) {
         $key = 'contestkey';
-        $datascalars = array('test data', null);
+        $datascalars = ['test data', null];
-        $dataarray = array('contest' => 'data', 'part' => 'two');
+        $dataarray = ['contest' => 'data', 'part' => 'two'];
         $dataobject = (object)$dataarray;
         foreach ($datascalars as $datascalar) {
             $this->assertTrue($cache->purge());
             // Check all read methods.
             $this->assertFalse($cache->get($key));
             $this->assertFalse($cache->has($key));
-            $result = $cache->get_many(array($key));
+            $result = $cache->get_many([$key]);
             $this->assertCount(1, $result);
             $this->assertFalse(reset($result));
-            $this->assertFalse($cache->has_any(array($key)));
+            $this->assertFalse($cache->has_any([$key]));
-            $this->assertFalse($cache->has_all(array($key)));
+            $this->assertFalse($cache->has_all([$key]));
             // Set the data.
             $this->assertTrue($cache->set($key, $datascalar));
             // Setting it more than once should be permitted.
             $this->assertTrue($cache->set($key, $datascalar));
             // Recheck the read methods.
             $this->assertEquals($datascalar, $cache->get($key));
             $this->assertTrue($cache->has($key));
-            $result = $cache->get_many(array($key));
+            $result = $cache->get_many([$key]);
             $this->assertCount(1, $result);
             $this->assertEquals($datascalar, reset($result));
-            $this->assertTrue($cache->has_any(array($key)));
+            $this->assertTrue($cache->has_any([$key]));
         $this->assertEquals('blue_ptc_wfc', $result->property2);
         $this->assertGreaterThan($starttime, $result->propertytime);
         // Test array of objects.
         $specobject = new cache_phpunit_dummy_object('red', 'blue', $starttime);
-        $data = new cacheable_object_array(array(
+        $data = new cacheable_object_array([
             clone($specobject),
             clone($specobject),
-            clone($specobject))
-        );
+            clone($specobject), ]);
         $this->assertTrue($cache->set($key, $data));
         $result = $cache->get($key);
         $this->assertInstanceOf(cacheable_object_array::class, $result);
         $this->assertCount(3, $data);
             // Ensure that wake from cache is called in all cases.
             $this->assertGreaterThan($starttime, $item->propertytime);
+        }
         // Test set many.
-        $cache->set_many(array('key1' => 'data1', 'key2' => 'data2', 'key3' => null));
+        $cache->set_many(['key1' => 'data1', 'key2' => 'data2', 'key3' => null]);
         $this->assertEquals('data1', $cache->get('key1'));
         $this->assertEquals('data2', $cache->get('key2'));
         $this->assertEquals(null, $cache->get('key3'));
         $this->assertTrue($cache->delete('key1'));
         $this->assertTrue($cache->delete('key2'));
         $this->assertTrue($cache->delete('key3'));
-        $cache->set_many(array(
+        $cache->set_many([
-            'key1' => array(1, 2, 3),
+            'key1' => [1, 2, 3],
-            'key2' => array(3, 2, 1),
+            'key2' => [3, 2, 1],
-        ));
+        ]);
         $this->assertIsArray($cache->get('key1'));
         $this->assertIsArray($cache->get('key2'));
         $this->assertCount(3, $cache->get('key1'));
         $this->assertCount(3, $cache->get('key2'));
-        $this->assertIsArray($cache->get_many(array('key1', 'key2')));
+        $this->assertIsArray($cache->get_many(['key1', 'key2']));
-        $this->assertCount(2, $cache->get_many(array('key1', 'key2')));
+        $this->assertCount(2, $cache->get_many(['key1', 'key2']));
-        $this->assertEquals(2, $cache->delete_many(array('key1', 'key2')));
+        $this->assertEquals(2, $cache->delete_many(['key1', 'key2']));
         // Test delete many.
         $this->assertTrue($cache->set('key1', 'data1'));
         $this->assertTrue($cache->set('key2', 'data2'));
         $this->assertTrue($cache->set('key3', null));
         $this->assertEquals('data1', $cache->get('key1'));
         $this->assertEquals('data2', $cache->get('key2'));
         $this->assertEquals(null, $cache->get('key3'));
-        $this->assertEquals(3, $cache->delete_many(array('key1', 'key2', 'key3')));
+        $this->assertEquals(3, $cache->delete_many(['key1', 'key2', 'key3']));
         $this->assertFalse($cache->get('key1'));
         $this->assertFalse($cache->get('key2'));
         $this->assertFalse($cache->get('key3'));
         $this->assertEquals('value', $var->key);
         $this->assertTrue($cache->delete('obj'));
         // Deep reference test.
-        $obj1 = new \stdClass;
+        $obj1 = new \stdClass();
         $obj1->key = 'value';
-        $obj2 = new \stdClass;
+        $obj2 = new \stdClass();
         $obj2->key = 'test';
-        $obj3 = new \stdClass;
+        $obj3 = new \stdClass();
         $obj3->key = 'pork';
         $obj1->subobj =& $obj2;
         $this->assertInstanceOf(\stdClass::class, $var->subobj->subobj);
         $this->assertEquals('pork', $var->subobj->subobj->key);
         $this->assertTrue($cache->delete('obj'));
         // Death reference test... basically we don't want this to die.
-        $obj = new \stdClass;
+        $obj = new \stdClass();
         $obj->key = 'value';
         $obj->self =& $obj;
         $this->assertTrue($cache->set('obj', $obj));
         $var = $cache->get('obj');
         $this->assertInstanceOf(\stdClass::class, $var);
         $this->assertEquals('value', $var->key);
         // Reference test after retrieve.
-        $obj = new \stdClass;
+        $obj = new \stdClass();
         $obj->key = 'value';
         $this->assertTrue($cache->set('obj', $obj));
         $this->assertEquals('value', $var2->key);
         $this->assertTrue($cache->delete('obj'));
         // Death reference test on get_many... basically we don't want this to die.
-        $obj = new \stdClass;
+        $obj = new \stdClass();
         $obj->key = 'value';
         $obj->self =& $obj;
-        $this->assertEquals(1, $cache->set_many(array('obj' => $obj)));
+        $this->assertEquals(1, $cache->set_many(['obj' => $obj]));
-        $var = $cache->get_many(array('obj'));
+        $var = $cache->get_many(['obj']);
         $this->assertInstanceOf(\stdClass::class, $var['obj']);
         $this->assertEquals('value', $var['obj']->key);
         // Reference test after retrieve.
-        $obj = new \stdClass;
+        $obj = new \stdClass();
         $obj->key = 'value';
-        $this->assertEquals(1, $cache->set_many(array('obj' => $obj)));
+        $this->assertEquals(1, $cache->set_many(['obj' => $obj]));
-        $var1 = $cache->get_many(array('obj'));
+        $var1 = $cache->get_many(['obj']);
         $this->assertInstanceOf(\stdClass::class, $var1['obj']);
         $this->assertEquals('value', $var1['obj']->key);
         $var1['obj']->key = 'eulav';
         $this->assertEquals('eulav', $var1['obj']->key);
             $this->fail('Exception expected from cache::get using MUST_EXIST');
         } catch (\Exception $e) {
             $this->assertTrue(true);
+        }
         try {
-            $cache->get_many(array('exception1', 'exception2'), MUST_EXIST);
+            $cache->get_many(['exception1', 'exception2'], MUST_EXIST);
             $this->fail('Exception expected from cache::get_many using MUST_EXIST');
         } catch (\Exception $e) {
             $this->assertTrue(true);
+        }
         $cache->set('test', 'test');
         try {
-            $cache->get_many(array('test', 'exception'), MUST_EXIST);
+            $cache->get_many(['test', 'exception'], MUST_EXIST);
             $this->fail('Exception expected from cache::get_many using MUST_EXIST');
         } catch (\Exception $e) {
             $this->assertTrue(true);
+        }
+    }
     /**
      * Tests a definition using a data loader
      */
     public function test_definition_data_loader(): void {
-        $instance = cache_config_testing::instance(true);
+        $instance = cache_config_testing::instance();
-        $instance->phpunit_add_definition('phpunit/datasourcetest', array(
+        $instance->phpunit_add_definition('phpunit/datasourcetest', [
-            'mode' => cache_store::MODE_APPLICATION,
+            'mode' => store::MODE_APPLICATION,
             'component' => 'phpunit',
             'area' => 'datasourcetest',
             'datasource' => 'cache_phpunit_dummy_datasource',
-            'datasourcefile' => 'cache/tests/fixtures/lib.php'
+            'datasourcefile' => 'cache/tests/fixtures/lib.php',
-        ));
+        ]);
         $cache = cache::make('phpunit', 'datasourcetest');
-        $this->assertInstanceOf(cache_application::class, $cache);
+        $this->assertInstanceOf(application_cache::class, $cache);
         // Purge it to be sure.
         $this->assertEquals('Test has no value really.', $cache->get('Test'));
         // Test multiple values.
         $this->assertTrue($cache->purge());
         $this->assertTrue($cache->set('b', 'B'));
-        $result = $cache->get_many(array('a', 'b', 'c'));
+        $result = $cache->get_many(['a', 'b', 'c']);
         $this->assertIsArray($result);
         $this->assertCount(3, $result);
         $this->assertArrayHasKey('a', $result);
         $this->assertArrayHasKey('b', $result);
         $this->assertEquals('c has no value really.', $result['c']);
+    }
     /**
-     * Tests a definition using a data loader with versioned keys.
-     *
-     * @covers ::get_versioned
-     * @covers ::set_versioned
+     * Tests a definition using a data loader with versioned keys.
      */
     public function test_definition_data_loader_versioned(): void {
         // Create two definitions, one using a non-versionable data source and the other using
         // a versionable one.
-        $instance = cache_config_testing::instance(true);
+        $instance = cache_config_testing::instance();
-        $instance->phpunit_add_definition('phpunit/datasourcetest1', array(
+        $instance->phpunit_add_definition('phpunit/datasourcetest1', [
-            'mode' => cache_store::MODE_APPLICATION,
+            'mode' => store::MODE_APPLICATION,
             'component' => 'phpunit',
             'area' => 'datasourcetest1',
             'datasource' => 'cache_phpunit_dummy_datasource',
-            'datasourcefile' => 'cache/tests/fixtures/lib.php'
+            'datasourcefile' => 'cache/tests/fixtures/lib.php',
-        ));
+        ]);
-        $instance->phpunit_add_definition('phpunit/datasourcetest2', array(
+        $instance->phpunit_add_definition('phpunit/datasourcetest2', [
-            'mode' => cache_store::MODE_APPLICATION,
+            'mode' => store::MODE_APPLICATION,
             'component' => 'phpunit',
             'area' => 'datasourcetest2',
-            'datasource' => 'cache_phpunit_dummy_datasource_versionable',
+            'datasource' => \cache_phpunit_dummy_datasource_versionable::class,
-            'datasourcefile' => 'cache/tests/fixtures/lib.php'
+            'datasourcefile' => 'cache/tests/fixtures/lib.php',
-        ));
+        ]);
         // The first data source works for normal 'get'.
         $cache1 = cache::make('phpunit', 'datasourcetest1');
         $this->assertEquals('Frog has no value really.', $cache1->get('Frog'));
         // But it doesn't work for get_versioned.
         try {
             $cache1->get_versioned('zombie', 1);
             $this->fail();
-        } catch (\coding_exception $e) {
+        } catch (coding_exception $e) {
             $this->assertStringContainsString('Data source is not versionable', $e->getMessage());
     /**
      * Tests a definition using an overridden loader
      */
     public function test_definition_overridden_loader(): void {
-        $instance = cache_config_testing::instance(true);
+        $instance = cache_config_testing::instance();
-        $instance->phpunit_add_definition('phpunit/overridetest', array(
+        $instance->phpunit_add_definition('phpunit/overridetest', [
-            'mode' => cache_store::MODE_APPLICATION,
+            'mode' => store::MODE_APPLICATION,
             'component' => 'phpunit',
             'area' => 'overridetest',
             'overrideclass' => 'cache_phpunit_dummy_overrideclass',
-            'overrideclassfile' => 'cache/tests/fixtures/lib.php'
+            'overrideclassfile' => 'cache/tests/fixtures/lib.php',
-        ));
+        ]);
         $cache = cache::make('phpunit', 'overridetest');
         $this->assertInstanceOf(cache_phpunit_dummy_overrideclass::class, $cache);
-        $this->assertInstanceOf(cache_application::class, $cache);
+        $this->assertInstanceOf(application_cache::class, $cache);
         // Purge it to be sure.
         $this->assertTrue($cache->purge());
         // It won't be there yet.
         $this->assertFalse($cache->has('Test'));
     /**
      * Test the mappingsonly setting.
      */
     public function test_definition_mappings_only(): void {
         /** @var cache_config_testing $instance */
-        $instance = cache_config_testing::instance(true);
+        $instance = cache_config_testing::instance();
-        $instance->phpunit_add_definition('phpunit/mappingsonly', array(
+        $instance->phpunit_add_definition('phpunit/mappingsonly', [
-            'mode' => cache_store::MODE_APPLICATION,
+            'mode' => store::MODE_APPLICATION,
             'component' => 'phpunit',
             'area' => 'mappingsonly',
-            'mappingsonly' => true
+            'mappingsonly' => true,
-        ), false);
+        ], false);
-        $instance->phpunit_add_definition('phpunit/nonmappingsonly', array(
+        $instance->phpunit_add_definition('phpunit/nonmappingsonly', [
-            'mode' => cache_store::MODE_APPLICATION,
+            'mode' => store::MODE_APPLICATION,
             'component' => 'phpunit',
             'area' => 'nonmappingsonly',
-            'mappingsonly' => false
+            'mappingsonly' => false,
-        ), false);
+        ], false);
         $cacheonly = cache::make('phpunit', 'mappingsonly');
-        $this->assertInstanceOf(cache_application::class, $cacheonly);
+        $this->assertInstanceOf(application_cache::class, $cacheonly);
-        $this->assertEquals('cachestore_dummy', $cacheonly->phpunit_get_store_class());
+        $this->assertInstanceOf(dummy_cachestore::class, $cacheonly->get_store());
-        $expected = $this->get_expected_application_cache_store();
+        $expected = $this->get_expected_application_store();
         $cachenon = cache::make('phpunit', 'nonmappingsonly');
-        $this->assertInstanceOf(cache_application::class, $cachenon);
+        $this->assertInstanceOf(application_cache::class, $cachenon);
-        $this->assertEquals($expected, $cachenon->phpunit_get_store_class());
+        $this->assertInstanceOf($expected, $cachenon->get_store());
+    }
     /**
      * Test a very basic definition.
      */
     public function test_definition(): void {
         $instance = cache_config_testing::instance();
-        $instance->phpunit_add_definition('phpunit/test', array(
+        $instance->phpunit_add_definition('phpunit/test', [
-            'mode' => cache_store::MODE_APPLICATION,
+            'mode' => store::MODE_APPLICATION,
             'component' => 'phpunit',
             'area' => 'test',
-        ));
+        ]);
         $cache = cache::make('phpunit', 'test');
     /**
      * Test a definition using the simple keys.
      */
     public function test_definition_simplekeys(): void {
         $instance = cache_config_testing::instance();
-        $instance->phpunit_add_definition('phpunit/simplekeytest', array(
+        $instance->phpunit_add_definition('phpunit/simplekeytest', [
-            'mode' => cache_store::MODE_APPLICATION,
+            'mode' => store::MODE_APPLICATION,
             'component' => 'phpunit',
             'area' => 'simplekeytest',
-            'simplekeys' => true
+            'simplekeys' => true,
-        ));
+        ]);
         $cache = cache::make('phpunit', 'simplekeytest');
         $this->assertTrue($cache->set('testkey1', 'test data 1'));
         $this->assertEquals('test data 1', $cache->get('testkey1'));
     /**
      * Test a negative TTL on an application cache.
      */
     public function test_application_ttl_negative(): void {
-        $instance = cache_config_testing::instance(true);
+        $instance = cache_config_testing::instance();
-        $instance->phpunit_add_definition('phpunit/ttltest', array(
+        $instance->phpunit_add_definition('phpunit/ttltest', [
-            'mode' => cache_store::MODE_APPLICATION,
+            'mode' => store::MODE_APPLICATION,
             'component' => 'phpunit',
             'area' => 'ttltest',
-            'ttl' => -86400 // Set to a day in the past to be extra sure.
+            'ttl' => -86400, // Set to a day in the past to be extra sure.
-        ));
+        ]);
         $cache = cache::make('phpunit', 'ttltest');
-        $this->assertInstanceOf(cache_application::class, $cache);
+        $this->assertInstanceOf(application_cache::class, $cache);
         // Purge it to be sure.
         $this->assertTrue($cache->purge());
         $this->assertFalse($cache->has('Test'));
         // Double check by trying to get it.
         $this->assertFalse($cache->get('Test'));
         // Test with multiple keys.
-        $this->assertEquals(3, $cache->set_many(array('a' => 'A', 'b' => 'B', 'c' => 'C')));
+        $this->assertEquals(3, $cache->set_many(['a' => 'A', 'b' => 'B', 'c' => 'C']));
-        $result = $cache->get_many(array('a', 'b', 'c'));
+        $result = $cache->get_many(['a', 'b', 'c']);
         $this->assertIsArray($result);
         $this->assertCount(3, $result);
         $this->assertArrayHasKey('a', $result);
         $this->assertArrayHasKey('b', $result);
         $this->assertArrayHasKey('c', $result);
         $this->assertFalse($result['a']);
         $this->assertFalse($result['b']);
         $this->assertFalse($result['c']);
         // Test with multiple keys including missing ones.
-        $result = $cache->get_many(array('a', 'c', 'e'));
+        $result = $cache->get_many(['a', 'c', 'e']);
         $this->assertIsArray($result);
         $this->assertCount(3, $result);
         $this->assertArrayHasKey('a', $result);
     /**
      * Test a positive TTL on an application cache.
      */
     public function test_application_ttl_positive(): void {
-        $instance = cache_config_testing::instance(true);
+        $instance = cache_config_testing::instance();
-        $instance->phpunit_add_definition('phpunit/ttltest', array(
+        $instance->phpunit_add_definition('phpunit/ttltest', [
-            'mode' => cache_store::MODE_APPLICATION,
+            'mode' => store::MODE_APPLICATION,
             'component' => 'phpunit',
             'area' => 'ttltest',
-            'ttl' => 86400 // Set to a day in the future to be extra sure.
+            'ttl' => 86400, // Set to a day in the future to be extra sure.
-        ));
+        ]);
         $cache = cache::make('phpunit', 'ttltest');
-        $this->assertInstanceOf(cache_application::class, $cache);
+        $this->assertInstanceOf(application_cache::class, $cache);
         // Purge it to be sure.
         $this->assertTrue($cache->purge());
         $this->assertTrue($cache->has('Test'));
         // Double check by trying to get it.
         $this->assertEquals('Test', $cache->get('Test'));
         // Test with multiple keys.
-        $this->assertEquals(3, $cache->set_many(array('a' => 'A', 'b' => 'B', 'c' => 'C')));
+        $this->assertEquals(3, $cache->set_many(['a' => 'A', 'b' => 'B', 'c' => 'C']));
-        $result = $cache->get_many(array('a', 'b', 'c'));
+        $result = $cache->get_many(['a', 'b', 'c']);
         $this->assertIsArray($result);
         $this->assertCount(3, $result);
         $this->assertArrayHasKey('a', $result);
         $this->assertArrayHasKey('b', $result);
         $this->assertArrayHasKey('c', $result);
         $this->assertEquals('A', $result['a']);
         $this->assertEquals('B', $result['b']);
         $this->assertEquals('C', $result['c']);
         // Test with multiple keys including missing ones.
-        $result = $cache->get_many(array('a', 'c', 'e'));
+        $result = $cache->get_many(['a', 'c', 'e']);
         $this->assertIsArray($result);
         $this->assertCount(3, $result);
         $this->assertArrayHasKey('a', $result);
     /**
      * Test a negative TTL on an session cache.
      */
     public function test_session_ttl_positive(): void {
-        $instance = cache_config_testing::instance(true);
+        $instance = cache_config_testing::instance();
-        $instance->phpunit_add_definition('phpunit/ttltest', array(
+        $instance->phpunit_add_definition('phpunit/ttltest', [
-            'mode' => cache_store::MODE_SESSION,
+            'mode' => store::MODE_SESSION,
             'component' => 'phpunit',
             'area' => 'ttltest',
-            'ttl' => 86400 // Set to a day in the future to be extra sure.
+            'ttl' => 86400, // Set to a day in the future to be extra sure.
-        ));
+        ]);
         $cache = cache::make('phpunit', 'ttltest');
-        $this->assertInstanceOf(cache_session::class, $cache);
+        $this->assertInstanceOf(session_cache::class, $cache);
         // Purge it to be sure.
         $this->assertTrue($cache->purge());
         $this->assertTrue($cache->has('Test'));
         // Double check by trying to get it.
         $this->assertEquals('Test', $cache->get('Test'));
         // Test with multiple keys.
-        $this->assertEquals(3, $cache->set_many(array('a' => 'A', 'b' => 'B', 'c' => 'C')));
+        $this->assertEquals(3, $cache->set_many(['a' => 'A', 'b' => 'B', 'c' => 'C']));
-        $result = $cache->get_many(array('a', 'b', 'c'));
+        $result = $cache->get_many(['a', 'b', 'c']);
         $this->assertIsArray($result);
         $this->assertCount(3, $result);
         $this->assertArrayHasKey('a', $result);
         $this->assertArrayHasKey('b', $result);
         $this->assertArrayHasKey('c', $result);
         $this->assertEquals('A', $result['a']);
         $this->assertEquals('B', $result['b']);
         $this->assertEquals('C', $result['c']);
         // Test with multiple keys including missing ones.
-        $result = $cache->get_many(array('a', 'c', 'e'));
+        $result = $cache->get_many(['a', 'c', 'e']);
         $this->assertIsArray($result);
         $this->assertCount(3, $result);
         $this->assertArrayHasKey('a', $result);
     /**
      * Tests manual locking operations on an application cache
      */
     public function test_application_manual_locking(): void {
         $instance = cache_config_testing::instance();
-        $instance->phpunit_add_definition('phpunit/lockingtest', array(
+        $instance->phpunit_add_definition('phpunit/lockingtest', [
-            'mode' => cache_store::MODE_APPLICATION,
+            'mode' => store::MODE_APPLICATION,
             'component' => 'phpunit',
-            'area' => 'lockingtest'
+            'area' => 'lockingtest',
-        ));
+        ]);
         // Configure the lock timeout so the test doesn't take too long to run.
         $instance->phpunit_edit_store_config('default_application', ['lockwait' => 2]);
         $cache1 = cache::make('phpunit', 'lockingtest');
         $cache2 = clone($cache1);
         $cache1->acquire_lock('testkey');
         try {
             $cache2->acquire_lock('testkey');
             $this->fail();
-        } catch (\moodle_exception $e) {
+        } catch (moodle_exception $e) {
+            // Check the right exception message, and debug info mentions the store type.
-            // Check the right exception message, and debug info mentions the store type.
+            $this->assertMatchesRegularExpression(
-            $this->assertMatchesRegularExpression('~Unable to acquire a lock.*cachestore_file.*~',
+                '~Unable to acquire a lock.*cachestore_file.*~',
+                $e->getMessage()
-                    $e->getMessage());
+            );
+        }
     /**
      * Tests application cache event invalidation
      */
     public function test_application_event_invalidation(): void {
         $instance = cache_config_testing::instance();
-        $instance->phpunit_add_definition('phpunit/eventinvalidationtest', array(
+        $instance->phpunit_add_definition('phpunit/eventinvalidationtest', [
-            'mode' => cache_store::MODE_APPLICATION,
+            'mode' => store::MODE_APPLICATION,
             'component' => 'phpunit',
             'area' => 'eventinvalidationtest',
-            'invalidationevents' => array(
+            'invalidationevents' => [
-                'crazyevent'
+                'crazyevent',
-            )
+            ],
-        ));
+        ]);
         $cache = cache::make('phpunit', 'eventinvalidationtest');
         $this->assertTrue($cache->set('testkey1', 'test data 1'));
         $this->assertEquals('test data 1', $cache->get('testkey1'));
         $this->assertTrue($cache->set('testkey2', 'test data 2'));
         $this->assertEquals('test data 2', $cache->get('testkey2'));
         // Test invalidating a single entry.
-        cache_helper::invalidate_by_event('crazyevent', array('testkey1'));
+        helper::invalidate_by_event('crazyevent', ['testkey1']);
         $this->assertFalse($cache->get('testkey1'));
         $this->assertEquals('test data 2', $cache->get('testkey2'));
         $this->assertTrue($cache->set('testkey1', 'test data 1'));
         // Test invalidating both entries.
-        cache_helper::invalidate_by_event('crazyevent', array('testkey1', 'testkey2'));
+        helper::invalidate_by_event('crazyevent', ['testkey1', 'testkey2']);
         $this->assertFalse($cache->get('testkey1'));
         $this->assertFalse($cache->get('testkey2'));
     }
     /**
      * Tests session cache event invalidation
      */
     public function test_session_event_invalidation(): void {
         $instance = cache_config_testing::instance();
-        $instance->phpunit_add_definition('phpunit/test_session_event_invalidation', array(
+        $instance->phpunit_add_definition('phpunit/test_session_event_invalidation', [
-            'mode' => cache_store::MODE_SESSION,
+            'mode' => store::MODE_SESSION,
             'component' => 'phpunit',
             'area' => 'test_session_event_invalidation',
-            'invalidationevents' => array(
+            'invalidationevents' => [
-                'crazyevent'
+                'crazyevent',
             ],
-        ));
+        ]);
         $cache = cache::make('phpunit', 'test_session_event_invalidation');
-        $this->assertInstanceOf(cache_session::class, $cache);
+        $this->assertInstanceOf(session_cache::class, $cache);
         $this->assertTrue($cache->set('testkey1', 'test data 1'));
         $this->assertEquals('test data 1', $cache->get('testkey1'));
         $this->assertTrue($cache->set('testkey2', 'test data 2'));
         $this->assertEquals('test data 2', $cache->get('testkey2'));
         // Test invalidating a single entry.
-        cache_helper::invalidate_by_event('crazyevent', array('testkey1'));
+        helper::invalidate_by_event('crazyevent', ['testkey1']);
         $this->assertFalse($cache->get('testkey1'));
         $this->assertEquals('test data 2', $cache->get('testkey2'));
         $this->assertTrue($cache->set('testkey1', 'test data 1'));
         // Test invalidating both entries.
-        cache_helper::invalidate_by_event('crazyevent', array('testkey1', 'testkey2'));
+        helper::invalidate_by_event('crazyevent', ['testkey1', 'testkey2']);
         $this->assertFalse($cache->get('testkey1'));
         $this->assertFalse($cache->get('testkey2'));
+    }
     /**
      * Tests application cache definition invalidation
      */
     public function test_application_definition_invalidation(): void {
         $instance = cache_config_testing::instance();
-        $instance->phpunit_add_definition('phpunit/definitioninvalidation', array(
+        $instance->phpunit_add_definition('phpunit/definitioninvalidation', [
-            'mode' => cache_store::MODE_APPLICATION,
+            'mode' => store::MODE_APPLICATION,
             'component' => 'phpunit',
-            'area' => 'definitioninvalidation'
+            'area' => 'definitioninvalidation',
-        ));
+        ]);
         $cache = cache::make('phpunit', 'definitioninvalidation');
         $this->assertTrue($cache->set('testkey1', 'test data 1'));
         $this->assertEquals('test data 1', $cache->get('testkey1'));
         $this->assertTrue($cache->set('testkey2', 'test data 2'));
         $this->assertEquals('test data 2', $cache->get('testkey2'));
-        cache_helper::invalidate_by_definition('phpunit', 'definitioninvalidation', array(), 'testkey1');
+        helper::invalidate_by_definition('phpunit', 'definitioninvalidation', [], 'testkey1');
         $this->assertFalse($cache->get('testkey1'));
         $this->assertEquals('test data 2', $cache->get('testkey2'));
         $this->assertTrue($cache->set('testkey1', 'test data 1'));
-        cache_helper::invalidate_by_definition('phpunit', 'definitioninvalidation', array(), array('testkey1'));
+        helper::invalidate_by_definition('phpunit', 'definitioninvalidation', [], ['testkey1']);
         $this->assertFalse($cache->get('testkey1'));
         $this->assertEquals('test data 2', $cache->get('testkey2'));
         $this->assertTrue($cache->set('testkey1', 'test data 1'));
-        cache_helper::invalidate_by_definition('phpunit', 'definitioninvalidation', array(), array('testkey1', 'testkey2'));
+        helper::invalidate_by_definition('phpunit', 'definitioninvalidation', [], ['testkey1', 'testkey2']);
         $this->assertFalse($cache->get('testkey1'));
+        $this->assertFalse($cache->get('testkey2'));
+    }
-        $this->assertFalse($cache->get('testkey2'));
+    /**
-    }
+     * Tests session cache definition invalidation
+     */
     public function test_session_definition_invalidation(): void {
-    /**
+        $instance = cache_config_testing::instance();
-     * Tests session cache definition invalidation
+        $instance->phpunit_add_definition('phpunit/test_session_definition_invalidation', [
+            'mode' => store::MODE_SESSION,
+            'component' => 'phpunit',
-     */
+            'area' => 'test_session_definition_invalidation',
+        ]);
-    public function test_session_definition_invalidation(): void {
+        $cache = cache::make('phpunit', 'test_session_definition_invalidation');
+        $this->assertInstanceOf(session_cache::class, $cache);
-        $instance = cache_config_testing::instance();
+        $this->assertTrue($cache->set('testkey1', 'test data 1'));
-        $instance->phpunit_add_definition('phpunit/test_session_definition_invalidation', array(
+        $this->assertEquals('test data 1', $cache->get('testkey1'));
-            'mode' => cache_store::MODE_SESSION,
+        $this->assertTrue($cache->set('testkey2', 'test data 2'));
         // This is going to be an intense wee test.
         // We need to add data the to cache, invalidate it by event, manually force it back without MUC knowing to simulate a
         // disconnected/distributed setup (think load balanced server using local cache), instantiate the cache again and finally
         // check that it is not picked up.
         $instance = cache_config_testing::instance();
-        $instance->phpunit_add_definition('phpunit/eventinvalidationtest', array(
+        $instance->phpunit_add_definition('phpunit/eventinvalidationtest', [
-            'mode' => cache_store::MODE_APPLICATION,
+            'mode' => store::MODE_APPLICATION,
             'component' => 'phpunit',
             'area' => 'eventinvalidationtest',
             'simplekeys' => true,
             'simpledata' => true,
-            'invalidationevents' => array(
+            'invalidationevents' => [
-                'crazyevent'
+                'crazyevent',
-            )
+            ],
-        ));
+        ]);
         $cache = cache::make('phpunit', 'eventinvalidationtest');
         $this->assertTrue($cache->set('testkey1', 'test data 1'));
         $this->assertEquals('test data 1', $cache->get('testkey1'));
-        cache_helper::invalidate_by_event('crazyevent', array('testkey1'));
+        helper::invalidate_by_event('crazyevent', ['testkey1']);
         $this->assertFalse($cache->get('testkey1'));
+        // OK data added, data invalidated, and invalidation time has been set.
-        // OK data added, data invalidated, and invalidation time has been set.
+        // Now we need to manually add back the data and adjust the invalidation time.
-        // Now we need to manually add back the data and adjust the invalidation time.
+        $hash = md5(store::MODE_APPLICATION . '/phpunit/eventinvalidationtest/' . $CFG->wwwroot . 'phpunit');
-        $hash = md5(cache_store::MODE_APPLICATION.'/phpunit/eventinvalidationtest/'.$CFG->wwwroot.'phpunit');
+        $timefile = $CFG->dataroot .
-        $timefile = $CFG->dataroot."/cache/cachestore_file/default_application/phpunit_eventinvalidationtest/las-cache/lastinvalidation-$hash.cache";
+            "/cache/cachestore_file/default_application/phpunit_eventinvalidationtest/las-cache/lastinvalidation-$hash.cache";
         // Make sure the file is correct.
         $this->assertTrue(file_exists($timefile));
         $timecont = serialize(cache::now(true) - 60); // Back 60sec in the past to force it to re-invalidate.
+        make_writable_directory(dirname($timefile));
-        make_writable_directory(dirname($timefile));
+        file_put_contents($timefile, $timecont);
-        file_put_contents($timefile, $timecont);
+        $this->assertTrue(file_exists($timefile));
         $this->assertTrue(file_exists($timefile));
         $datafile = $CFG->dataroot .
-        $datafile = $CFG->dataroot."/cache/cachestore_file/default_application/phpunit_eventinvalidationtest/tes-cache/testkey1-$hash.cache";
+            "/cache/cachestore_file/default_application/phpunit_eventinvalidationtest/tes-cache/testkey1-$hash.cache";
         $datacont = serialize("test data 1");
         make_writable_directory(dirname($datafile));
         file_put_contents($datafile, $datacont);
         $this->assertTrue(file_exists($datafile));
         // Test 1: Rebuild without the event and test its there.
-        cache_factory::reset();
+        factory::reset();
         $instance = cache_config_testing::instance();
-        $instance->phpunit_add_definition('phpunit/eventinvalidationtest', array(
+        $instance->phpunit_add_definition('phpunit/eventinvalidationtest', [
-            'mode' => cache_store::MODE_APPLICATION,
+            'mode' => store::MODE_APPLICATION,
             'component' => 'phpunit',
             'area' => 'eventinvalidationtest',
             'simplekeys' => true,
             'simpledata' => true,
-        ));
+        ]);
         $cache = cache::make('phpunit', 'eventinvalidationtest');
         $this->assertEquals('test data 1', $cache->get('testkey1'));
         // Test 2: Rebuild and test the invalidation of the event via the invalidation cache.
-        cache_factory::reset();
+        factory::reset();
         $instance = cache_config_testing::instance();
-        $instance->phpunit_add_definition('phpunit/eventinvalidationtest', array(
+        $instance->phpunit_add_definition('phpunit/eventinvalidationtest', [
-            'mode' => cache_store::MODE_APPLICATION,
+            'mode' => store::MODE_APPLICATION,
             'component' => 'phpunit',
             'area' => 'eventinvalidationtest',
             'simplekeys' => true,
             'simpledata' => true,
         // Set testkey2 data.
         $cache->set('testkey2', 'test data 2');
         // Backdate the event invalidation time by 30 seconds.
         $invalidationcache = cache::make('core', 'eventinvalidation');
-        $invalidationcache->set('crazyevent', array('testkey2' => cache::now() - 30));
+        $invalidationcache->set('crazyevent', ['testkey2' => cache::now() - 30]);
         // Lastinvalidation should already be cache::now().
         $this->assertEquals(cache::get_purge_token(), $cache->get('lastinvalidation'));
         // Set it to 15 seconds ago so that we know if it changes.
         $pasttime = cache::now(true) - 15;
         $cache->set('lastinvalidation', $pasttime);
         // Make a new cache class.  This should not invalidate anything.
-        cache_factory::instance()->reset_cache_instances();
+        factory::instance()->reset_cache_instances();
         $cache = cache::make('phpunit', 'eventinvalidationtest');
         // Lastinvalidation shouldn't change since it was already newer than invalidation event.
         $this->assertEquals($pasttime, $cache->get('lastinvalidation'));
         // Now set the event invalidation to newer than the lastinvalidation time.
-        $invalidationcache->set('crazyevent', array('testkey2' => cache::now() - 5));
+        $invalidationcache->set('crazyevent', ['testkey2' => cache::now() - 5]);
         // Make a new cache class.  This should should invalidate testkey2.
-        cache_factory::instance()->reset_cache_instances();
+        factory::instance()->reset_cache_instances();
         $cache = cache::make('phpunit', 'eventinvalidationtest');
         // Lastinvalidation timestamp should have updated to cache::now().
         $this->assertEquals(cache::get_purge_token(), $cache->get('lastinvalidation'));
         // Now simulate a purge_by_event 5 seconds ago.
         $invalidationcache = cache::make('core', 'eventinvalidation');
-        $invalidationcache->set('crazyevent', array('purged' => cache::now(true) - 5));
+        $invalidationcache->set('crazyevent', ['purged' => cache::now(true) - 5]);
-        // Set our lastinvalidation timestamp to 15 seconds ago.
-        $cache->set('lastinvalidation', cache::now(true) - 15);
+        // Set our lastinvalidation timestamp to 15 seconds ago.
-        // Make a new cache class.  This should invalidate the cache.
+        $cache->set('lastinvalidation', cache::now(true) - 15);
-        cache_factory::instance()->reset_cache_instances();
+        // Make a new cache class.  This should invalidate the cache.
-        $cache = cache::make('phpunit', 'eventinvalidationtest');
+        factory::instance()->reset_cache_instances();
-        // Lastinvalidation timestamp should have updated to cache::now().
+        $cache = cache::make('phpunit', 'eventinvalidationtest');
-        $this->assertEquals(cache::get_purge_token(), $cache->get('lastinvalidation'));
+        // Lastinvalidation timestamp should have updated to cache::now().
+        $this->assertEquals(cache::get_purge_token(), $cache->get('lastinvalidation'));
     }
     /**
      * Tests application cache event purge
      */
     public function test_application_event_purge(): void {
         $instance = cache_config_testing::instance();
-        $instance->phpunit_add_definition('phpunit/eventpurgetest', array(
+        $instance->phpunit_add_definition('phpunit/eventpurgetest', [
-            'mode' => cache_store::MODE_APPLICATION,
+            'mode' => store::MODE_APPLICATION,
             'component' => 'phpunit',
             'area' => 'eventpurgetest',
-            'invalidationevents' => array(
+            'invalidationevents' => [
-                'crazyevent'
+                'crazyevent',
-            )
+            ],
-        ));
+        ]);
-        $instance->phpunit_add_definition('phpunit/eventpurgetestaccelerated', array(
+        $instance->phpunit_add_definition('phpunit/eventpurgetestaccelerated', [
-            'mode' => cache_store::MODE_APPLICATION,
+            'mode' => store::MODE_APPLICATION,
             'component' => 'phpunit',
             'area' => 'eventpurgetestaccelerated',
             'staticacceleration' => true,
-            'invalidationevents' => array(
+            'invalidationevents' => [
-                'crazyevent'
+                'crazyevent',
-            )
+            ],
-        ));
+        ]);
         $cache = cache::make('phpunit', 'eventpurgetest');
         $this->assertEquals('test data 1', $cache->get('testkey1'));
         $this->assertTrue($cache->set('testkey2', 'test data 2'));
         $this->assertEquals('test data 2', $cache->get('testkey2'));
         // Purge the event.
-        cache_helper::purge_by_event('crazyevent');
+        helper::purge_by_event('crazyevent');
         // Check things have been removed.
         $this->assertFalse($cache->get('testkey1'));
     /**
      * Tests session cache event purge
      */
     public function test_session_event_purge(): void {
         $instance = cache_config_testing::instance();
-        $instance->phpunit_add_definition('phpunit/eventpurgetest', array(
+        $instance->phpunit_add_definition('phpunit/eventpurgetest', [
-            'mode' => cache_store::MODE_SESSION,
+            'mode' => store::MODE_SESSION,
             'component' => 'phpunit',
             'area' => 'eventpurgetest',
-            'invalidationevents' => array(
+            'invalidationevents' => [
-                'crazyevent'
+                'crazyevent',
-            )
+            ],
-        ));
+        ]);
-        $instance->phpunit_add_definition('phpunit/eventpurgetestaccelerated', array(
+        $instance->phpunit_add_definition('phpunit/eventpurgetestaccelerated', [
-            'mode' => cache_store::MODE_SESSION,
+            'mode' => store::MODE_SESSION,
             'component' => 'phpunit',
             'area' => 'eventpurgetestaccelerated',
             'staticacceleration' => true,
-            'invalidationevents' => array(
+            'invalidationevents' => [
-                'crazyevent'
+                'crazyevent',
-            )
+            ],
-        ));
+        ]);
         $cache = cache::make('phpunit', 'eventpurgetest');
         $this->assertTrue($cache->set('testkey1', 'test data 1'));
         $this->assertEquals('test data 1', $cache->get('testkey1'));
         $this->assertTrue($cache->set('testkey2', 'test data 2'));
         $this->assertEquals('test data 2', $cache->get('testkey2'));
         // Purge the event.
-        cache_helper::purge_by_event('crazyevent');
+        helper::purge_by_event('crazyevent');
         $this->assertEquals('test data 1', $cache->get('testkey1'));
         $this->assertTrue($cache->set('testkey2', 'test data 2'));
         $this->assertEquals('test data 2', $cache->get('testkey2'));
         // Purge the event.
-        cache_helper::purge_by_event('crazyevent');
+        helper::purge_by_event('crazyevent');
         // Check things have been removed.
         $this->assertFalse($cache->get('testkey1'));
     /**
      * Tests application cache definition purge
      */
     public function test_application_definition_purge(): void {
         $instance = cache_config_testing::instance();
-        $instance->phpunit_add_definition('phpunit/definitionpurgetest', array(
+        $instance->phpunit_add_definition('phpunit/definitionpurgetest', [
-            'mode' => cache_store::MODE_APPLICATION,
+            'mode' => store::MODE_APPLICATION,
             'component' => 'phpunit',
             'area' => 'definitionpurgetest',
-            'invalidationevents' => array(
+            'invalidationevents' => [
-                'crazyevent'
+                'crazyevent',
-            )
+            ],
-        ));
+        ]);
         $cache = cache::make('phpunit', 'definitionpurgetest');
         $this->assertTrue($cache->set('testkey1', 'test data 1'));
         $this->assertEquals('test data 1', $cache->get('testkey1'));
         $this->assertTrue($cache->set('testkey2', 'test data 2'));
         $this->assertEquals('test data 2', $cache->get('testkey2'));
         // Purge the event.
-        cache_helper::purge_by_definition('phpunit', 'definitionpurgetest');
+        helper::purge_by_definition('phpunit', 'definitionpurgetest');
         // Check things have been removed.
      * Test the use of an alt path.
      * If we can generate a config instance we are done :)
      */
     public function test_alt_cache_path(): void {
         global $CFG;
-        if ((defined('TEST_CACHE_USING_ALT_CACHE_CONFIG_PATH') && TEST_CACHE_USING_ALT_CACHE_CONFIG_PATH) || !empty($CFG->altcacheconfigpath)) {
-            $this->markTestSkipped('Skipped testing alt cache path as it is already being used.');
+        if ($this->skip_if_empty_alt_cache_path()) {
+            return;
+        }
         $this->resetAfterTest();
-        $CFG->altcacheconfigpath = $CFG->dataroot.'/cache/altcacheconfigpath';
+        $CFG->altcacheconfigpath = $CFG->dataroot . '/cache/altcacheconfigpath';
         $instance = cache_config_testing::instance();
-        $this->assertInstanceOf(cache_config::class, $instance);
+        $this->assertInstanceOf(config::class, $instance);
+    }
     /**
      * Test disabling the cache stores.
      */
     public function test_disable_stores(): void {
         $instance = cache_config_testing::instance();
-        $instance->phpunit_add_definition('phpunit/disabletest1', array(
+        $instance->phpunit_add_definition('phpunit/disabletest1', [
-            'mode' => cache_store::MODE_APPLICATION,
+            'mode' => store::MODE_APPLICATION,
             'component' => 'phpunit',
-            'area' => 'disabletest1'
+            'area' => 'disabletest1',
-        ));
+        ]);
-        $instance->phpunit_add_definition('phpunit/disabletest2', array(
+        $instance->phpunit_add_definition('phpunit/disabletest2', [
-            'mode' => cache_store::MODE_SESSION,
-            'component' => 'phpunit',
-            'area' => 'disabletest2'
-        ));
-        $instance->phpunit_add_definition('phpunit/disabletest3', array(
-            'mode' => cache_store::MODE_REQUEST,
+            'mode' => store::MODE_SESSION,
+            'component' => 'phpunit',
+            'area' => 'disabletest2',
+        ]);
+        $instance->phpunit_add_definition('phpunit/disabletest3', [
+            'mode' => store::MODE_REQUEST,
             'component' => 'phpunit',
-            'area' => 'disabletest3'
+            'area' => 'disabletest3',
-        ));
+        ]);
-        $caches = array(
+        $caches = [
             'disabletest1' => cache::make('phpunit', 'disabletest1'),
             'disabletest2' => cache::make('phpunit', 'disabletest2'),
-            'disabletest3' => cache::make('phpunit', 'disabletest3')
+            'disabletest3' => cache::make('phpunit', 'disabletest3'),
-        );
+        ];
         $this->assertInstanceOf(cache_phpunit_application::class, $caches['disabletest1']);
         $this->assertInstanceOf(cache_phpunit_session::class, $caches['disabletest2']);
         $this->assertInstanceOf(cache_phpunit_request::class, $caches['disabletest3']);
-        $this->assertEquals('cachestore_file', $caches['disabletest1']->phpunit_get_store_class());
+        $this->assertInstanceOf(cachestore_file::class, $caches['disabletest1']->get_store());
-        $this->assertEquals('cachestore_session', $caches['disabletest2']->phpunit_get_store_class());
+        $this->assertInstanceOf(cachestore_session::class, $caches['disabletest2']->get_store());
-        $this->assertEquals('cachestore_static', $caches['disabletest3']->phpunit_get_store_class());
+        $this->assertInstanceOf(cachestore_static::class, $caches['disabletest3']->get_store());
         foreach ($caches as $cache) {
             $this->assertFalse($cache->get('test'));
             $this->assertTrue($cache->set('test', 'test'));
             $this->assertEquals('test', $cache->get('test'));
         }
-        cache_factory::disable_stores();
+        factory::disable_stores();
-        $caches = array(
+        $caches = [
             'disabletest1' => cache::make('phpunit', 'disabletest1'),
             'disabletest2' => cache::make('phpunit', 'disabletest2'),
-            'disabletest3' => cache::make('phpunit', 'disabletest3')
+            'disabletest3' => cache::make('phpunit', 'disabletest3'),
-        );
+        ];
         $this->assertInstanceOf(cache_phpunit_application::class, $caches['disabletest1']);
         $this->assertInstanceOf(cache_phpunit_session::class, $caches['disabletest2']);
      * Test disabling the cache.
      */
     public function test_disable(): void {
         global $CFG;
-        if ((defined('TEST_CACHE_USING_ALT_CACHE_CONFIG_PATH') && TEST_CACHE_USING_ALT_CACHE_CONFIG_PATH) || !empty($CFG->altcacheconfigpath)) {
-            // We can't run this test as it requires us to delete the cache configuration script which we just
-            // cant do with a custom path in play.
-            $this->markTestSkipped('Skipped testing cache disable functionality as alt cache path is being used.');
-        }
+        $this->skip_if_empty_alt_cache_path();
-        $configfile = $CFG->dataroot.'/muc/config.php';
+        $configfile = $CFG->dataroot . '/muc/config.php';
         // The config file will not exist yet as we've not done anything with the cache.
         // reset_all_data removes the file and without a call to create a configuration it doesn't exist
         // as yet.
         $this->assertFileDoesNotExist($configfile);
-        // Disable the cache
+        // Disable the cache.
         cache_phpunit_factory::phpunit_disable();
         // Check we get the expected disabled factory.
-        $factory = cache_factory::instance();
+        $factory = factory::instance();
-        $this->assertInstanceOf(cache_factory_disabled::class, $factory);
+        $this->assertInstanceOf(disabled_factory::class, $factory);
         // Check we get the expected disabled config.
         $config = $factory->create_config_instance();
-        $this->assertInstanceOf(cache_config_disabled::class, $config);
+        $this->assertInstanceOf(disabled_config::class, $config);
         // Check we get the expected disabled caches.
         $cache = cache::make('core', 'string');
-        $this->assertInstanceOf(cache_disabled::class, $cache);
+        $this->assertInstanceOf(disabled_cache::class, $cache);
         $this->assertTrue($cache->release_lock('test'));
         $this->assertTrue($cache->release_lock('test'));
         $this->assertTrue($cache->check_lock_state('test'));
         // Test a session cache.
-        $cache = cache::make_from_params(cache_store::MODE_SESSION, 'phpunit', 'disable');
+        $cache = cache::make_from_params(store::MODE_SESSION, 'phpunit', 'disable');
-        $this->assertInstanceOf(cache_disabled::class, $cache);
+        $this->assertInstanceOf(disabled_cache::class, $cache);
         $this->assertFalse($cache->get('test'));
         $this->assertFalse($cache->get_versioned('v', 1));
         $this->assertFalse($cache->set('test', 'test'));
         $this->assertFalse($cache->set_versioned('v', 1, 'data'));
         $this->assertFalse($cache->delete('test'));
         $this->assertTrue($cache->purge());
         // Finally test a request cache.
-        $cache = cache::make_from_params(cache_store::MODE_REQUEST, 'phpunit', 'disable');
+        $cache = cache::make_from_params(store::MODE_REQUEST, 'phpunit', 'disable');
-        $this->assertInstanceOf(cache_disabled::class, $cache);
+        $this->assertInstanceOf(disabled_cache::class, $cache);
         $this->assertFalse($cache->get('test'));
         $this->assertFalse($cache->get_versioned('v', 1));
         $this->assertFalse($cache->set('test', 'test'));
         $this->assertFalse($cache->set_versioned('v', 1, 'data'));
         $this->assertFalse($cache->delete('test'));
         $this->assertTrue($cache->purge());
-        cache_factory::reset();
+        factory::reset();
-        $factory = cache_factory::instance(true);
+        $factory = factory::instance(true);
         $config = $factory->create_config_instance();
-        $this->assertEquals('cache_config_testing', get_class($config));
+        $this->assertInstanceOf(cache_config_testing::class, $config);
+    }
     /**
      * Test that multiple application loaders work ok.
      */
     public function test_multiple_application_loaders(): void {
-        $instance = cache_config_testing::instance(true);
+        $instance = cache_config_testing::instance();
         $instance->phpunit_add_file_store('phpunittest1');
         $instance->phpunit_add_file_store('phpunittest2');
-        $instance->phpunit_add_definition('phpunit/multi_loader', array(
+        $instance->phpunit_add_definition('phpunit/multi_loader', [
-            'mode' => cache_store::MODE_APPLICATION,
+            'mode' => store::MODE_APPLICATION,
             'component' => 'phpunit',
-            'area' => 'multi_loader'
+            'area' => 'multi_loader',
-        ));
+        ]);
         $instance->phpunit_add_definition_mapping('phpunit/multi_loader', 'phpunittest1', 3);
         $instance->phpunit_add_definition_mapping('phpunit/multi_loader', 'phpunittest2', 2);
         $cache = cache::make('phpunit', 'multi_loader');
-        $this->assertInstanceOf(cache_application::class, $cache);
+        $this->assertInstanceOf(application_cache::class, $cache);
         $this->assertFalse($cache->get('test'));
         $this->assertTrue($cache->set('test', 'test'));
         $this->assertEquals('test', $cache->get('test'));
         $this->assertTrue($cache->delete('test'));
         $this->assertFalse($cache->get('test'));
         $this->assertTrue($cache->set('test', 'test'));
         $this->assertTrue($cache->purge());
         $this->assertFalse($cache->get('test'));
         // Test the many commands.
-        $this->assertEquals(3, $cache->set_many(array('a' => 'A', 'b' => 'B', 'c' => 'C')));
+        $this->assertEquals(3, $cache->set_many(['a' => 'A', 'b' => 'B', 'c' => 'C']));
-        $result = $cache->get_many(array('a', 'b', 'c'));
+        $result = $cache->get_many(['a', 'b', 'c']);
         $this->assertIsArray($result);
         $this->assertCount(3, $result);
         $this->assertArrayHasKey('a', $result);
         $this->assertArrayHasKey('b', $result);
         $this->assertArrayHasKey('c', $result);
         $this->assertEquals('A', $result['a']);
         $this->assertEquals('B', $result['b']);
         $this->assertSame('test', $cache->get('test'));
         $this->assertTrue($cache->delete('test', false));
         // We should still have it on a deeper loader.
         $this->assertSame('test', $cache->get('test'));
         // Test non-recusive with many functions.
-        $this->assertSame(3, $cache->set_many(array(
+        $this->assertSame(3, $cache->set_many([
             'one' => 'one',
             'two' => 'two',
-            'three' => 'three'
+            'three' => 'three',
-        )));
+        ]));
         $this->assertSame('one', $cache->get('one'));
-        $this->assertSame(array('two' => 'two', 'three' => 'three'), $cache->get_many(array('two', 'three')));
+        $this->assertSame(['two' => 'two', 'three' => 'three'], $cache->get_many(['two', 'three']));
-        $this->assertSame(3, $cache->delete_many(array('one', 'two', 'three'), false));
+        $this->assertSame(3, $cache->delete_many(['one', 'two', 'three'], false));
         $this->assertSame('one', $cache->get('one'));
-        $this->assertSame(array('two' => 'two', 'three' => 'three'), $cache->get_many(array('two', 'three')));
+        $this->assertSame(['two' => 'two', 'three' => 'three'], $cache->get_many(['two', 'three']));
+    }
     /**
      * Data provider to try using a TTL or non-TTL cache.
+     *
      * @return array
      */
-    public function ttl_or_not(): array {
+    public static function ttl_or_not(): array {
         return [[false], [true]];
+    }
     /**
      * Data provider to try using a TTL or non-TTL cache, and static acceleration or not.
+     *
      * @return array
      */
-    public function ttl_and_static_acceleration_or_not(): array {
+    public static function ttl_and_static_acceleration_or_not(): array {
         return [[false, false], [false, true], [true, false], [true, true]];
+    }
     /**
      * Data provider to try using a TTL or non-TTL cache, and simple data on or off.
      *
      * @return array
      */
-    public function ttl_and_simple_data_or_not(): array {
+    public static function ttl_and_simple_data_or_not(): array {
         // Same values as for ttl and static acceleration (two booleans).
-        return $this->ttl_and_static_acceleration_or_not();
+        return self::ttl_and_static_acceleration_or_not();
+    }
     /**
      * Shared code to set up a two or three-layer versioned cache for testing.
+     *
      * @param bool $ttl If true, sets TTL in the definition
      * @param bool $threelayer If true, uses a 3-layer instead of 2-layer cache
      * @param bool $staticacceleration If true, enables static acceleration
+     * @param bool $simpledata If true, enables simple data
+     * @return application_cache Cache
-     * @param bool $simpledata If true, enables simple data
+     */
+    protected function create_versioned_cache(
+        bool $ttl,
-     * @return \cache_application Cache
+        bool $threelayer = false,
-     */
+        bool $staticacceleration = false,
-    protected function create_versioned_cache(bool $ttl, bool $threelayer = false,
+        bool $simpledata = false
-            bool $staticacceleration = false, bool $simpledata = false): \cache_application {
+    ): application_cache {
-        $instance = cache_config_testing::instance(true);
+        $instance = cache_config_testing::instance();
         $instance->phpunit_add_file_store('a', false);
         $instance->phpunit_add_file_store('b', false);
         if ($threelayer) {
             $instance->phpunit_add_file_store('c', false);
         }
         $defarray = [
-            'mode' => cache_store::MODE_APPLICATION,
+            'mode' => store::MODE_APPLICATION,
             'component' => 'phpunit',
-            'area' => 'multi_loader'
+            'area' => 'multi_loader',
         ];
      * Tests basic use of versioned cache.
+     *
      * @dataProvider ttl_and_simple_data_or_not
      * @param bool $ttl If true, uses a TTL cache.
      * @param bool $simpledata If true, turns on simple data flag
-     * @covers ::set_versioned
-     * @covers ::get_versioned
      */
     public function test_versioned_cache_basic(bool $ttl, bool $simpledata): void {
         $multicache = $this->create_versioned_cache($ttl, false, false, $simpledata);
      * Tests versioned cache with objects.
+     *
      * @dataProvider ttl_and_static_acceleration_or_not
      * @param bool $ttl If true, uses a TTL cache.
      * @param bool $staticacceleration If true, enables static acceleration
-     * @covers ::set_versioned
-     * @covers ::get_versioned
      */
     public function test_versioned_cache_objects(bool $ttl, bool $staticacceleration): void {
         $multicache = $this->create_versioned_cache($ttl, false, $staticacceleration);
     /**
      * Tests requesting a version that doesn't exist.
+     *
      * @dataProvider ttl_or_not
      * @param bool $ttl If true, uses a TTL cache.
-     * @covers ::set_versioned
-     * @covers ::get_versioned
      */
     public function test_versioned_cache_not_exist(bool $ttl): void {
         $multicache = $this->create_versioned_cache($ttl);
     /**
      * Tests attempts to use get after set_version or get_version after set.
+     *
      * @dataProvider ttl_or_not
      * @param bool $ttl If true, uses a TTL cache.
-     * @covers ::set_versioned
-     * @covers ::get_versioned
      */
     public function test_versioned_cache_incompatible_versioning(bool $ttl): void {
         $multicache = $this->create_versioned_cache($ttl);
         // What if you use get on a get_version cache?
         $multicache->set_versioned('game', 1, 'Pooh-sticks');
         try {
             $multicache->get('game');
             $this->fail();
-        } catch (\coding_exception $e) {
+        } catch (coding_exception $e) {
             $this->assertStringContainsString('Unexpectedly found versioned cache entry', $e->getMessage());
+        }
         // Or get_version on a get cache?
         $multicache->set('toy', 'Train set');
         try {
             $multicache->get_versioned('toy', 1);
             $this->fail();
-        } catch (\coding_exception $e) {
+        } catch (coding_exception $e) {
             $this->assertStringContainsString('Unexpectedly found non-versioned cache entry', $e->getMessage());
+        }
+    }
     /**
      * Versions are only stored once, so if you set a newer version you will always get it even
      * if you ask for the lower version number.
-     *
-     * @dataProvider ttl_or_not
      * @param bool $ttl If true, uses a TTL cache.
-     * @covers ::set_versioned
+     * @dataProvider ttl_or_not
-     * @covers ::get_versioned
+     * @param bool $ttl If true, uses a TTL cache.
      */
      * If the first (local) store has an outdated copy but the second (shared) store has a newer
      * one, then it should automatically be retrieved.
+     *
      * @dataProvider ttl_or_not
      * @param bool $ttl If true, uses a TTL cache.
-     * @covers ::set_versioned
-     * @covers ::get_versioned
      */
     public function test_versioned_cache_outdated_local(bool $ttl): void {
         $multicache = $this->create_versioned_cache($ttl);
         // Set initial value to version 2, 'Tag', in both stores.
         $multicache->set_versioned('game', 2, 'Tag');
         // Get the two separate cache stores for the multi-level cache.
-        $factory = cache_factory::instance();
+        $factory = factory::instance();
         $definition = $factory->create_definition('phpunit', 'multi_loader');
         [0 => $storea, 1 => $storeb] = $factory->get_store_instances_in_use($definition);
         // Simulate what happens if the shared cache is updated with a new version but the
         // local one still has an old version.
-        $hashgame = cache_helper::hash_key('game', $definition);
+        $hashgame = helper::hash_key('game', $definition);
         $data = 'British Bulldog';
         if ($ttl) {
         if ($ttl) {
             // In case the time has changed slightly since the first set, we can't do an exact
             // compare, so check it ignoring the time field.
             $this->assertEquals(3, $localvalue->version);
             $ttldata = $localvalue->data;
-            $this->assertInstanceOf('cache_ttl_wrapper', $ttldata);
+            $this->assertInstanceOf(ttl_wrapper::class, $ttldata);
             $this->assertEquals('British Bulldog', $ttldata->data);
         } else {
             $this->assertEquals(new \core_cache\version_wrapper('British Bulldog', 3), $localvalue);
+        }
+    }
      * cache (to save I/O if there are multiple requests, as if there is another request it will
      * not have to retrieve the values to find out that they're old).
+     *
      * @dataProvider ttl_or_not
      * @param bool $ttl If true, uses a TTL cache.
-     * @covers ::set_versioned
-     * @covers ::get_versioned
      */
     public function test_versioned_cache_deleting_outdated(bool $ttl): void {
         $multicache = $this->create_versioned_cache($ttl);
         // Set initial value to version 2, 'Tag', in both stores.
         $multicache->set_versioned('game', 2, 'Tag');
         // Get the two separate cache stores for the multi-level cache.
-        $factory = cache_factory::instance();
+        $factory = factory::instance();
         $definition = $factory->create_definition('phpunit', 'multi_loader');
         [0 => $storea, 1 => $storeb] = $factory->get_store_instances_in_use($definition);
         // If we request a newer version, then any older version should be deleted in each
         // cache level.
         $this->assertFalse($multicache->get_versioned('game', 4));
-        $hashgame = cache_helper::hash_key('game', $definition);
+        $hashgame = helper::hash_key('game', $definition);
         $this->assertFalse($storea->get($hashgame));
         $this->assertFalse($storeb->get($hashgame));
-    }
-    /**
      * Tests a versioned cache when using static cache.
-     * @covers ::set_versioned
+    /**
-     * @covers ::get_versioned
+     * Tests a versioned cache when using static cache.
      */
     public function test_versioned_cache_static(): void {
         $staticcache = $this->create_versioned_cache(false, false, true);
         // Set a value in the cache, version 1. This will store it in static acceleration.
         $staticcache->set_versioned('game', 1, 'Pooh-sticks');
         // Get the first cache store (we don't need the second one for this test).
-        $factory = cache_factory::instance();
+        $factory = factory::instance();
         $definition = $factory->create_definition('phpunit', 'multi_loader');
         [0 => $storea] = $factory->get_store_instances_in_use($definition);
         $this->assertFalse($staticcache->get_versioned('game', 4));
+    }
     /**
-     * Tests basic use of 3-layer versioned caches.
-     *
-     * @covers ::set_versioned
-     * @covers ::get_versioned
+     * Tests basic use of 3-layer versioned caches.
      */
     public function test_versioned_cache_3_layers_basic(): void {
         $multicache = $this->create_versioned_cache(false, true);
         $this->assertEquals('Tag', $multicache->get_versioned('game', 1));
+    }
     /**
-     * Tests use of 3-layer versioned caches where the 3 layers currently have different versions.
-     *
-     * @covers ::set_versioned
-     * @covers ::get_versioned
+     * Tests use of 3-layer versioned caches where the 3 layers currently have different versions.
      */
     public function test_versioned_cache_3_layers_different_data(): void {
         // Set version 2 using normal method.
         $multicache = $this->create_versioned_cache(false, true);
         $multicache->set_versioned('game', 2, 'Tag');
         // Get the three separate cache stores for the multi-level cache.
-        $factory = cache_factory::instance();
+        $factory = factory::instance();
         $definition = $factory->create_definition('phpunit', 'multi_loader');
         [0 => $storea, 1 => $storeb, 2 => $storec] = $factory->get_store_instances_in_use($definition);
         // Set up two other versions so every level has a different version.
-        $hashgame = cache_helper::hash_key('game', $definition);
+        $hashgame = helper::hash_key('game', $definition);
         $storeb->set($hashgame, new \core_cache\version_wrapper('British Bulldog', 3));
     /**
      * Test that multiple application loaders work ok.
      */
     public function test_multiple_session_loaders(): void {
-        /* @var cache_config_testing $instance */
+        /* @var \cache_config_testing $instance */
-        $instance = cache_config_testing::instance(true);
+        $instance = cache_config_testing::instance();
         $instance->phpunit_add_session_store('phpunittest1');
         $instance->phpunit_add_session_store('phpunittest2');
-        $instance->phpunit_add_definition('phpunit/multi_loader', array(
+        $instance->phpunit_add_definition('phpunit/multi_loader', [
-            'mode' => cache_store::MODE_SESSION,
+            'mode' => store::MODE_SESSION,
             'component' => 'phpunit',
-            'area' => 'multi_loader'
+            'area' => 'multi_loader',
-        ));
+        ]);
         $instance->phpunit_add_definition_mapping('phpunit/multi_loader', 'phpunittest1', 3);
         $instance->phpunit_add_definition_mapping('phpunit/multi_loader', 'phpunittest2', 2);
         $cache = cache::make('phpunit', 'multi_loader');
-        $this->assertInstanceOf(cache_session::class, $cache);
+        $this->assertInstanceOf(session_cache::class, $cache);
         $this->assertFalse($cache->get('test'));
         $this->assertTrue($cache->set('test', 'test'));
         $this->assertEquals('test', $cache->get('test'));
         $this->assertTrue($cache->delete('test'));
         $this->assertFalse($cache->get('test'));
         $this->assertTrue($cache->set('test', 'test'));
         $this->assertTrue($cache->purge());
         $this->assertFalse($cache->get('test'));
         // Test the many commands.
-        $this->assertEquals(3, $cache->set_many(array('a' => 'A', 'b' => 'B', 'c' => 'C')));
+        $this->assertEquals(3, $cache->set_many(['a' => 'A', 'b' => 'B', 'c' => 'C']));
-        $result = $cache->get_many(array('a', 'b', 'c'));
+        $result = $cache->get_many(['a', 'b', 'c']);
         $this->assertIsArray($result);
         $this->assertCount(3, $result);
         $this->assertArrayHasKey('a', $result);
         $this->assertArrayHasKey('b', $result);
         $this->assertArrayHasKey('c', $result);
         $this->assertEquals('A', $result['a']);
         $this->assertEquals('B', $result['b']);
         $this->assertEquals('C', $result['c']);
-        $this->assertEquals($result, $cache->get_many(array('a', 'b', 'c')));
+        $this->assertEquals($result, $cache->get_many(['a', 'b', 'c']));
-        $this->assertEquals(2, $cache->delete_many(array('a', 'c')));
+        $this->assertEquals(2, $cache->delete_many(['a', 'c']));
-        $result = $cache->get_many(array('a', 'b', 'c'));
+        $result = $cache->get_many(['a', 'b', 'c']);
         $this->assertIsArray($result);
         $this->assertCount(3, $result);
         $this->assertSame('test', $cache->get('test'));
         $this->assertTrue($cache->delete('test', false));
         // We should still have it on a deeper loader.
         $this->assertSame('test', $cache->get('test'));
         // Test non-recusive with many functions.
-        $this->assertSame(3, $cache->set_many(array(
+        $this->assertSame(3, $cache->set_many([
             'one' => 'one',
             'two' => 'two',
-            'three' => 'three'
+            'three' => 'three',
-        )));
+        ]));
         $this->assertSame('one', $cache->get('one'));
-        $this->assertSame(array('two' => 'two', 'three' => 'three'), $cache->get_many(array('two', 'three')));
+        $this->assertSame(['two' => 'two', 'three' => 'three'], $cache->get_many(['two', 'three']));
-        $this->assertSame(3, $cache->delete_many(array('one', 'two', 'three'), false));
+        $this->assertSame(3, $cache->delete_many(['one', 'two', 'three'], false));
         $this->assertSame('one', $cache->get('one'));
-        $this->assertSame(array('two' => 'two', 'three' => 'three'), $cache->get_many(array('two', 'three')));
+        $this->assertSame(['two' => 'two', 'three' => 'three'], $cache->get_many(['two', 'three']));
+    }
     /**
      * Test switching users with session caches.
      */
     public function test_session_cache_switch_user(): void {
         $this->resetAfterTest(true);
-        $cache = cache::make_from_params(cache_store::MODE_SESSION, 'phpunit', 'sessioncache');
+        $cache = cache::make_from_params(store::MODE_SESSION, 'phpunit', 'sessioncache');
         $user1 = $this->getDataGenerator()->create_user();
         $user2 = $this->getDataGenerator()->create_user();
     /**
      * Test switching users with session caches.
      */
     public function test_session_cache_switch_user_application_mapping(): void {
         $this->resetAfterTest(true);
-        $instance = cache_config_testing::instance(true);
+        $instance = cache_config_testing::instance();
         $instance->phpunit_add_file_store('testfilestore');
-        $instance->phpunit_add_definition('phpunit/testappsession', array(
+        $instance->phpunit_add_definition('phpunit/testappsession', [
-            'mode' => cache_store::MODE_SESSION,
+            'mode' => store::MODE_SESSION,
             'component' => 'phpunit',
-            'area' => 'testappsession'
+            'area' => 'testappsession',
-        ));
+        ]);
         $instance->phpunit_add_definition_mapping('phpunit/testappsession', 'testfilestore', 3);
         $cache = cache::make('phpunit', 'testappsession');
         $user1 = $this->getDataGenerator()->create_user();
         $user2 = $this->getDataGenerator()->create_user();
     /**
      * Test two session caches being used at once to confirm collisions don't occur.
      */
     public function test_dual_session_caches(): void {
-        $instance = cache_config_testing::instance(true);
+        $instance = cache_config_testing::instance();
-        $instance->phpunit_add_definition('phpunit/testsess1', array(
+        $instance->phpunit_add_definition('phpunit/testsess1', [
-            'mode' => cache_store::MODE_SESSION,
+            'mode' => store::MODE_SESSION,
             'component' => 'phpunit',
-            'area' => 'testsess1'
+            'area' => 'testsess1',
-        ));
+        ]);
-        $instance->phpunit_add_definition('phpunit/testsess2', array(
+        $instance->phpunit_add_definition('phpunit/testsess2', [
-            'mode' => cache_store::MODE_SESSION,
+            'mode' => store::MODE_SESSION,
             'component' => 'phpunit',
-            'area' => 'testsess2'
+            'area' => 'testsess2',
-        ));
+        ]);
         $cache1 = cache::make('phpunit', 'testsess1');
         $cache2 = cache::make('phpunit', 'testsess2');
     /**
      * Test multiple session caches when switching user.
      */
     public function test_session_cache_switch_user_multiple(): void {
         $this->resetAfterTest(true);
-        $cache1 = cache::make_from_params(cache_store::MODE_SESSION, 'phpunit', 'sessioncache1');
+        $cache1 = cache::make_from_params(store::MODE_SESSION, 'phpunit', 'sessioncache1');
-        $cache2 = cache::make_from_params(cache_store::MODE_SESSION, 'phpunit', 'sessioncache2');
+        $cache2 = cache::make_from_params(store::MODE_SESSION, 'phpunit', 'sessioncache2');
         $user1 = $this->getDataGenerator()->create_user();
         $user2 = $this->getDataGenerator()->create_user();
         // Log in as the first user.
+    }
     /**
      * The application locking feature should work with caches that support multiple identifiers
-     * (static cache and MongoDB with a specific setting).
-     *
-     * @covers \cache_application
+     * (static cache and MongoDB with a specific setting).
      */
     public function test_application_locking_multiple_identifier_cache(): void {
         // Get an arbitrary definition (modinfo).
-        $instance = cache_config_testing::instance(true);
+        $instance = cache_config_testing::instance();
         $definitions = $instance->get_definitions();
-        $definition = \cache_definition::load('phpunit', $definitions['core/coursemodinfo']);
+        $definition = definition::load('phpunit', $definitions['core/coursemodinfo']);
-        // Set up a static cache using that definition, wrapped in cache_application so we can do
+        // Set up a static cache using that definition, wrapped in application_cache so we can do
         // locking.
         $store = new \cachestore_static('test');
         $store->initialise($definition);
-        $cache = new cache_application($definition, $store);
+        $cache = new application_cache($definition, $store);
         // Test the three locking functions.
         $cache->acquire_lock('frog');
         $this->assertTrue($cache->check_lock_state('frog'));
         $cache->release_lock('frog');
-    }
     /**
      * Test requiring a lock before attempting to set a key.
-     *
+    /**
-     * @covers ::set_implementation
+     * Test requiring a lock before attempting to set a key.
      */
     public function test_application_locking_before_write(): void {
-        $instance = cache_config_testing::instance(true);
+        $instance = cache_config_testing::instance();
-        $instance->phpunit_add_definition('phpunit/test_application_locking', array(
+        $instance->phpunit_add_definition('phpunit/test_application_locking', [
-            'mode' => cache_store::MODE_APPLICATION,
+            'mode' => store::MODE_APPLICATION,
             'component' => 'phpunit',
             'area' => 'test_application_locking',
             'staticacceleration' => true,
             'staticaccelerationsize' => 1,
-            'requirelockingbeforewrite' => true
+            'requirelockingbeforewrite' => true,
-        ));
+        ]);
         $cache = cache::make('phpunit', 'test_application_locking');
-        $this->assertInstanceOf(cache_application::class, $cache);
+        $this->assertInstanceOf(application_cache::class, $cache);
         $cache->acquire_lock('a');
         try {
             // Set with lock.
             $this->assertTrue($cache->set('a', 'A'));
             // Set without lock.
             try {
                 $cache->set('b', 'B');
+                $this->fail();
-                $this->fail();
+            } catch (coding_exception $e) {
-            } catch (\coding_exception $e) {
+                $this->assertStringContainsString(
-                $this->assertStringContainsString(
+                    'Attempted to set cache key "b" without a lock. ' .
-                        'Attempted to set cache key "b" without a lock. ' .
+                        'Locking before writes is required for phpunit/test_application_locking',
-                        'Locking before writes is required for phpunit/test_application_locking',
+                    $e->getMessage()
-                        $e->getMessage());
+                );
+            }
             // Set many without full lock.
+            try {
-            try {
+                $cache->set_many(['a' => 'AA', 'b' => 'BB']);
-                $cache->set_many(['a' => 'AA', 'b' => 'BB']);
+                $this->fail();
-                $this->fail();
+            } catch (coding_exception $e) {
             // Delete key without lock.
             try {
                 $cache->delete('b');
                 $this->fail();
-            } catch (\coding_exception $e) {
+            } catch (coding_exception $e) {
                 $this->assertStringContainsString(
-                        'Attempted to delete cache key "b" without a lock.',
+                    'Attempted to delete cache key "b" without a lock.',
+                    $e->getMessage()
-                        $e->getMessage());
+                );
+            }
             // Delete many without full lock.
             $cache->set('a', 'AAA');
             try {
                 $cache->delete_many(['a', 'b']);
                 $this->fail();
-            } catch (\coding_exception $e) {
+            } catch (coding_exception $e) {
                 $this->assertStringContainsString(
+                    'Attempted to delete cache key "b" without a lock.',
-                        'Attempted to delete cache key "b" without a lock.',
+                    $e->getMessage()
-                        $e->getMessage());
+                );
+            }
             // Nothing was deleted.
+    }
     /**
      * Test that locking before write works when writing across multiple layers.
      *
-     * @covers \cache_loader
-     * @return void
+     * @covers \core_cache\application_cache
      */
     public function test_application_locking_multiple_layers(): void {
-        $instance = cache_config_testing::instance(true);
+        $instance = cache_config_testing::instance();
-        $instance->phpunit_add_definition('phpunit/test_application_locking', array(
+        $instance->phpunit_add_definition('phpunit/test_application_locking', [
-            'mode' => cache_store::MODE_APPLICATION,
+            'mode' => store::MODE_APPLICATION,
             'component' => 'phpunit',
             'area' => 'test_application_locking',
             'staticacceleration' => true,
             'staticaccelerationsize' => 1,
-            'requirelockingbeforewrite' => true
+            'requirelockingbeforewrite' => true,
-        ), false);
+        ], false);
         $instance->phpunit_add_file_store('phpunittest1');
         $instance->phpunit_add_file_store('phpunittest2');
         $instance->phpunit_add_definition_mapping('phpunit/test_application_locking', 'phpunittest1', 1);
         $instance->phpunit_add_definition_mapping('phpunit/test_application_locking', 'phpunittest2', 2);
         $cache = cache::make('phpunit', 'test_application_locking');
-        $this->assertInstanceOf(cache_application::class, $cache);
+        $this->assertInstanceOf(application_cache::class, $cache);
         // Try the tests again with a third layer.
         $instance->phpunit_add_file_store('phpunittest3');
         $instance->phpunit_add_definition_mapping('phpunit/test_application_locking', 'phpunittest3', 3);
         $cache = cache::make('phpunit', 'test_application_locking');
-        $this->assertInstanceOf(cache_application::class, $cache);
+        $this->assertInstanceOf(application_cache::class, $cache);
         // Check that we can set a key across multiple layers.
+    }
     /**
      * Tests that locking fails correctly when either layer of a 2-layer cache has a lock already.
      *
-     * @covers \cache_loader
+     * @covers \core_cache\application_cache
      */
     public function test_application_locking_multiple_layers_failures(): void {
-        $instance = cache_config_testing::instance(true);
+        $instance = cache_config_testing::instance();
-        $instance->phpunit_add_definition('phpunit/test_application_locking', array(
+        $instance->phpunit_add_definition('phpunit/test_application_locking', [
-            'mode' => cache_store::MODE_APPLICATION,
+            'mode' => store::MODE_APPLICATION,
             'component' => 'phpunit',
             'area' => 'test_application_locking',
             'staticacceleration' => true,
             'staticaccelerationsize' => 1,
-            'requirelockingbeforewrite' => true
+            'requirelockingbeforewrite' => true,
-        ), false);
+        ], false);
         $instance->phpunit_add_file_store('phpunittest1');
         $instance->phpunit_add_file_store('phpunittest2');
         $lockwaitprop->setValue($localstore, 1);
         $lockwaitprop->setValue($sharedstore, 1);
         // Get key details and the cache identifier.
-        $hashedkey = cache_helper::hash_key('apple', $definition);
+        $hashedkey = helper::hash_key('apple', $definition);
         $localidentifier = $cache->get_identifier();
         $sharedidentifier = $sharedcache->get_identifier();
         // 1. Local cache is not locked but parent cache is locked.
         $sharedstore->acquire_lock($hashedkey, 'somebodyelse');
         try {
             try {
                 $cache->acquire_lock('apple');
                 $this->fail();
-            } catch (\moodle_exception $e) {
+            } catch (moodle_exception $e) { // phpcs:ignore Generic.CodeAnalysis.EmptyStatement.DetectedCatch
+            }
         $localstore->acquire_lock($hashedkey, 'somebodyelse');
         try {
             try {
                 $cache->acquire_lock('apple');
                 $this->fail();
-            } catch (\moodle_exception $e) {
+            } catch (moodle_exception $e) { // phpcs:ignore Generic.CodeAnalysis.EmptyStatement.DetectedCatch
+            }
             // Neither store is locked by us, local store still locked.
             $this->assertFalse((bool)$localstore->check_lock_state($hashedkey, $localidentifier));
             $cache->release_lock('apple');
+        }
+    }
     /**
-     * Test the static cache_helper method purge_stores_used_by_definition.
+     * Test the static helper method purge_stores_used_by_definition.
      */
     public function test_purge_stores_used_by_definition(): void {
-        $instance = cache_config_testing::instance(true);
+        $instance = cache_config_testing::instance();
-        $instance->phpunit_add_definition('phpunit/test_purge_stores_used_by_definition', array(
+        $instance->phpunit_add_definition('phpunit/test_purge_stores_used_by_definition', [
-            'mode' => cache_store::MODE_APPLICATION,
+            'mode' => store::MODE_APPLICATION,
             'component' => 'phpunit',
-            'area' => 'test_purge_stores_used_by_definition'
+            'area' => 'test_purge_stores_used_by_definition',
-        ));
+        ]);
         $cache = cache::make('phpunit', 'test_purge_stores_used_by_definition');
-        $this->assertInstanceOf(cache_application::class, $cache);
+        $this->assertInstanceOf(application_cache::class, $cache);
         $this->assertTrue($cache->set('test', 'test'));
         unset($cache);
-        cache_helper::purge_stores_used_by_definition('phpunit', 'test_purge_stores_used_by_definition');
+        helper::purge_stores_used_by_definition('phpunit', 'test_purge_stores_used_by_definition');
         $cache = cache::make('phpunit', 'test_purge_stores_used_by_definition');
-        $this->assertInstanceOf(cache_application::class, $cache);
+        $this->assertInstanceOf(application_cache::class, $cache);
         $this->assertFalse($cache->get('test'));
+    }
     /**
      * Test purge routines.
      */
     public function test_purge_routines(): void {
-        $instance = cache_config_testing::instance(true);
+        $instance = cache_config_testing::instance();
-        $instance->phpunit_add_definition('phpunit/purge1', array(
+        $instance->phpunit_add_definition('phpunit/purge1', [
-            'mode' => cache_store::MODE_APPLICATION,
+            'mode' => store::MODE_APPLICATION,
             'component' => 'phpunit',
-            'area' => 'purge1'
+            'area' => 'purge1',
-        ));
+        ]);
-        $instance->phpunit_add_definition('phpunit/purge2', array(
+        $instance->phpunit_add_definition('phpunit/purge2', [
-            'mode' => cache_store::MODE_APPLICATION,
+            'mode' => store::MODE_APPLICATION,
             'component' => 'phpunit',
             'area' => 'purge2',
-            'requireidentifiers' => array(
+            'requireidentifiers' => [
-                'id'
+                'id',
             ],
-        ));
+        ]);
-        $factory = cache_factory::instance();
+        $factory = factory::instance();
         $definition = $factory->create_definition('phpunit', 'purge1');
         $this->assertFalse($definition->has_required_identifiers());
         $cache = $factory->create_cache($definition);
-        $this->assertInstanceOf(cache_application::class, $cache);
+        $this->assertInstanceOf(application_cache::class, $cache);
         $this->assertTrue($cache->set('test', 'test'));
         $this->assertTrue($cache->has('test'));
-        cache_helper::purge_by_definition('phpunit', 'purge1');
+        helper::purge_by_definition('phpunit', 'purge1');
         $this->assertFalse($cache->has('test'));
-        $factory = cache_factory::instance();
+        $factory = factory::instance();
         $definition = $factory->create_definition('phpunit', 'purge2');
         $this->assertTrue($definition->has_required_identifiers());
         $cache = $factory->create_cache($definition);
-        $this->assertInstanceOf(cache_application::class, $cache);
+        $this->assertInstanceOf(application_cache::class, $cache);
         $this->assertTrue($cache->set('test', 'test'));
         $this->assertTrue($cache->has('test'));
-        cache_helper::purge_stores_used_by_definition('phpunit', 'purge2');
+        helper::purge_stores_used_by_definition('phpunit', 'purge2');
         $this->assertFalse($cache->has('test'));
         try {
-            cache_helper::purge_by_definition('phpunit', 'purge2');
+            helper::purge_by_definition('phpunit', 'purge2');
             $this->fail('Should not be able to purge a definition required identifiers without providing them.');
-        } catch (\coding_exception $ex) {
+        } catch (coding_exception $ex) {
             $this->assertStringContainsString('Identifier required for cache has not been provided', $ex->getMessage());
+        }
     }
     /**
      * Tests that ad-hoc caches are correctly purged with a purge_all call.
      */
     public function test_purge_all_with_adhoc_caches(): void {
-        $cache = cache::make_from_params(cache_store::MODE_REQUEST, 'core_cache', 'test');
+        $cache = cache::make_from_params(store::MODE_REQUEST, 'core_cache', 'test');
         $cache->set('test', 123);
-        cache_helper::purge_all();
+        helper::purge_all();
         $this->assertFalse($cache->get('test'));
+    }
     /**
      * Test that the default stores all support searching.
      */
     public function test_defaults_support_searching(): void {
-        $instance = cache_config_testing::instance(true);
+        $instance = cache_config_testing::instance();
-        $instance->phpunit_add_definition('phpunit/search1', array(
+        $instance->phpunit_add_definition('phpunit/search1', [
-            'mode' => cache_store::MODE_APPLICATION,
+            'mode' => store::MODE_APPLICATION,
             'component' => 'phpunit',
             'area' => 'search1',
-            'requiresearchable' => true
+            'requiresearchable' => true,
-        ));
+        ]);
-        $instance->phpunit_add_definition('phpunit/search2', array(
+        $instance->phpunit_add_definition('phpunit/search2', [
-            'mode' => cache_store::MODE_SESSION,
+            'mode' => store::MODE_SESSION,
             'component' => 'phpunit',
             'area' => 'search2',
-            'requiresearchable' => true
+            'requiresearchable' => true,
-        ));
+        ]);
-        $instance->phpunit_add_definition('phpunit/search3', array(
+        $instance->phpunit_add_definition('phpunit/search3', [
-            'mode' => cache_store::MODE_REQUEST,
+            'mode' => store::MODE_REQUEST,
             'component' => 'phpunit',
             'area' => 'search3',
-            'requiresearchable' => true
+            'requiresearchable' => true,
-        ));
+        ]);
-        $factory = cache_factory::instance();
+        $factory = factory::instance();
         // Test application cache is searchable.
         $definition = $factory->create_definition('phpunit', 'search1');
-        $this->assertInstanceOf(cache_definition::class, $definition);
+        $this->assertInstanceOf(definition::class, $definition);
-        $this->assertEquals(cache_store::IS_SEARCHABLE, $definition->get_requirements_bin() & cache_store::IS_SEARCHABLE);
+        $this->assertEquals(store::IS_SEARCHABLE, $definition->get_requirements_bin() & store::IS_SEARCHABLE);
         $cache = $factory->create_cache($definition);
-        $this->assertInstanceOf(cache_application::class, $cache);
+        $this->assertInstanceOf(application_cache::class, $cache);
-        $this->assertArrayHasKey('cache_is_searchable', $cache->phpunit_get_store_implements());
+        $this->assertInstanceOf(searchable_cache_interface::class, $cache->get_store());
         // Test session cache is searchable.
         $definition = $factory->create_definition('phpunit', 'search2');
-        $this->assertInstanceOf(cache_definition::class, $definition);
+        $this->assertInstanceOf(definition::class, $definition);
-        $this->assertEquals(cache_store::IS_SEARCHABLE, $definition->get_requirements_bin() & cache_store::IS_SEARCHABLE);
+        $this->assertEquals(store::IS_SEARCHABLE, $definition->get_requirements_bin() & store::IS_SEARCHABLE);
         $cache = $factory->create_cache($definition);
-        $this->assertInstanceOf(cache_session::class, $cache);
+        $this->assertInstanceOf(session_cache::class, $cache);
-        $this->assertArrayHasKey('cache_is_searchable', $cache->phpunit_get_store_implements());
+        $this->assertInstanceOf(searchable_cache_interface::class, $cache->get_store());
         // Test request cache is searchable.
         $definition = $factory->create_definition('phpunit', 'search3');
-        $this->assertInstanceOf(cache_definition::class, $definition);
+        $this->assertInstanceOf(definition::class, $definition);
-        $this->assertEquals(cache_store::IS_SEARCHABLE, $definition->get_requirements_bin() & cache_store::IS_SEARCHABLE);
+        $this->assertEquals(store::IS_SEARCHABLE, $definition->get_requirements_bin() & store::IS_SEARCHABLE);
         $cache = $factory->create_cache($definition);
-        $this->assertInstanceOf(cache_request::class, $cache);
+        $this->assertInstanceOf(request_cache::class, $cache);
-        $this->assertArrayHasKey('cache_is_searchable', $cache->phpunit_get_store_implements());
+        $this->assertInstanceOf(searchable_cache_interface::class, $cache->get_store());
+    }
     /**
      * Test static acceleration
      *
      * Note: All the assertGreaterThanOrEqual() in this test should be assertGreaterThan() be because of some microtime()
      * resolution problems under some OSs / PHP versions, we are accepting equal as valid outcome. For more info see MDL-57147.
      */
     public function test_static_acceleration(): void {
         $instance = cache_config_testing::instance();
-        $instance->phpunit_add_definition('phpunit/accelerated', array(
+        $instance->phpunit_add_definition('phpunit/accelerated', [
-            'mode' => cache_store::MODE_APPLICATION,
+            'mode' => store::MODE_APPLICATION,
             'component' => 'phpunit',
             'area' => 'accelerated',
             'staticacceleration' => true,
             'staticaccelerationsize' => 3,
-        ));
+        ]);
-        $instance->phpunit_add_definition('phpunit/accelerated2', array(
+        $instance->phpunit_add_definition('phpunit/accelerated2', [
-            'mode' => cache_store::MODE_APPLICATION,
+            'mode' => store::MODE_APPLICATION,
             'component' => 'phpunit',
             'area' => 'accelerated2',
             'staticacceleration' => true,
             'staticaccelerationsize' => 3,
-        ));
+        ]);
-        $instance->phpunit_add_definition('phpunit/accelerated3', array(
+        $instance->phpunit_add_definition('phpunit/accelerated3', [
-            'mode' => cache_store::MODE_APPLICATION,
+            'mode' => store::MODE_APPLICATION,
             'component' => 'phpunit',
             'area' => 'accelerated3',
             'staticacceleration' => true,
             'staticaccelerationsize' => 3,
-        ));
+        ]);
-        $instance->phpunit_add_definition('phpunit/accelerated4', array(
+        $instance->phpunit_add_definition('phpunit/accelerated4', [
-            'mode' => cache_store::MODE_APPLICATION,
+            'mode' => store::MODE_APPLICATION,
             'component' => 'phpunit',
             'area' => 'accelerated4',
             'staticacceleration' => true,
             'staticaccelerationsize' => 4,
-        ));
+        ]);
-        $instance->phpunit_add_definition('phpunit/simpledataarea1', array(
+        $instance->phpunit_add_definition('phpunit/simpledataarea1', [
-            'mode' => cache_store::MODE_APPLICATION,
+            'mode' => store::MODE_APPLICATION,
             'component' => 'phpunit',
             'area' => 'simpledataarea1',
             'staticacceleration' => true,
-            'simpledata' => false
+            'simpledata' => false,
-        ));
+        ]);
-        $instance->phpunit_add_definition('phpunit/simpledataarea2', array(
+        $instance->phpunit_add_definition('phpunit/simpledataarea2', [
-            'mode' => cache_store::MODE_APPLICATION,
+            'mode' => store::MODE_APPLICATION,
             'component' => 'phpunit',
             'area' => 'simpledataarea2',
             'staticacceleration' => true,
-            'simpledata' => true
+            'simpledata' => true,
         $this->assertFalse($cache->phpunit_static_acceleration_get('b'));
         $this->assertEquals('C', $cache->phpunit_static_acceleration_get('c'));
         $this->assertEquals('D', $cache->phpunit_static_acceleration_get('d'));
         $this->assertEquals('E', $cache->phpunit_static_acceleration_get('e'));
-        // Store a cacheable_object, get many times and ensure each time wake_for_cache is used.
+        // Store a cacheable_object_interface, get many times and ensure each time wake_for_cache is used.
         // Both get and get_many are tested.  Two cache entries are used to ensure the times aren't
         // confused with multiple calls to get()/get_many().
         $startmicrotime = microtime(true);
         $cacheableobject = new cache_phpunit_dummy_object(1, 1, $startmicrotime);
         $cachevalue = $cache->get('a');
         $this->assertInstanceOf(cache_phpunit_dummy_object::class, $cachevalue);
         $this->assertGreaterThanOrEqual($staticaccelerationreturntime, $cachevalue->propertytime);
         $backingstorereturntime = $cachevalue->propertytime;
-        $results = $cache->get_many(array('b'));
+        $results = $cache->get_many(['b']);
         $this->assertInstanceOf(cache_phpunit_dummy_object::class, $results['b']);
         $this->assertGreaterThanOrEqual($staticaccelerationreturntimeb, $results['b']->propertytime);
         $backingstorereturntimeb = $results['b']->propertytime;
         // value is stored serialized in the static acceleration cache.
         $cachevalue = $cache->phpunit_static_acceleration_get('a');
         $this->assertInstanceOf(cache_phpunit_dummy_object::class, $cachevalue);
         $this->assertGreaterThanOrEqual($backingstorereturntime, $cachevalue->propertytime);
-        $results = $cache->get_many(array('b'));
+        $results = $cache->get_many(['b']);
         $this->assertInstanceOf(cache_phpunit_dummy_object::class, $results['b']);
         $this->assertGreaterThanOrEqual($backingstorereturntimeb, $results['b']->propertytime);
         $this->assertEquals('A', $cache->phpunit_static_acceleration_get('a'));
         $this->assertFalse($cache->phpunit_static_acceleration_get('b'));
         $this->assertFalse($cache->phpunit_static_acceleration_get('c'));
         // Current keys in the array: d, e, a.
-        $this->assertEquals(array('c' => 'C'), $cache->get_many(array('c')));
+        $this->assertEquals(['c' => 'C'], $cache->get_many(['c']));
         // Current keys in the array: e, a, c.
         $this->assertEquals('E', $cache->phpunit_static_acceleration_get('e'));
         $this->assertEquals('A', $cache->phpunit_static_acceleration_get('a'));
         $this->assertEquals('C', $cache->phpunit_static_acceleration_get('c'));
         $this->assertEquals('B2', $cache->phpunit_static_acceleration_get('b'));
         $this->assertFalse($cache->phpunit_static_acceleration_get('c'));
         $this->assertEquals('D', $cache->phpunit_static_acceleration_get('d'));
         $this->assertEquals('E', $cache->phpunit_static_acceleration_get('e'));
-        $this->assertEquals(2, $cache->set_many(array('b' => 'B3', 'c' => 'C3')));
+        $this->assertEquals(2, $cache->set_many(['b' => 'B3', 'c' => 'C3']));
         $this->assertFalse($cache->phpunit_static_acceleration_get('a'));
         $this->assertEquals('B3', $cache->phpunit_static_acceleration_get('b'));
         $this->assertEquals('C3', $cache->phpunit_static_acceleration_get('c'));
         $this->assertFalse($cache->phpunit_static_acceleration_get('d'));
         $returnedinstance1->name = 'b';
         $this->assertEquals('b', $returnedinstance2->name);
+    }
     public function test_identifiers_have_separate_caches(): void {
-        $cachepg = cache::make('core', 'databasemeta', array('dbfamily' => 'pgsql'));
+        $cachepg = cache::make('core', 'databasemeta', ['dbfamily' => 'pgsql']);
         $cachepg->set(1, 'here');
-        $cachemy = cache::make('core', 'databasemeta', array('dbfamily' => 'mysql'));
+        $cachemy = cache::make('core', 'databasemeta', ['dbfamily' => 'mysql']);
         $cachemy->set(2, 'there');
         $this->assertEquals('here', $cachepg->get(1));
         $this->assertEquals('there', $cachemy->get(2));
         $this->assertFalse($cachemy->get(1));
         $this->resetAfterTest(true);
         $CFG->perfdebug = 15;
         $instance = cache_config_testing::instance();
         $applicationid = 'phpunit/applicationperf';
-        $instance->phpunit_add_definition($applicationid, array(
+        $instance->phpunit_add_definition($applicationid, [
-            'mode' => cache_store::MODE_APPLICATION,
+            'mode' => store::MODE_APPLICATION,
             'component' => 'phpunit',
-            'area' => 'applicationperf'
+            'area' => 'applicationperf',
-        ));
+        ]);
         $sessionid = 'phpunit/sessionperf';
-        $instance->phpunit_add_definition($sessionid, array(
+        $instance->phpunit_add_definition($sessionid, [
-            'mode' => cache_store::MODE_SESSION,
+            'mode' => store::MODE_SESSION,
             'component' => 'phpunit',
-            'area' => 'sessionperf'
+            'area' => 'sessionperf',
-        ));
+        ]);
         $requestid = 'phpunit/requestperf';
-        $instance->phpunit_add_definition($requestid, array(
+        $instance->phpunit_add_definition($requestid, [
-            'mode' => cache_store::MODE_REQUEST,
+            'mode' => store::MODE_REQUEST,
             'component' => 'phpunit',
-            'area' => 'requestperf'
+            'area' => 'requestperf',
-        ));
+        ]);
         $application = cache::make('phpunit', 'applicationperf');
         $session = cache::make('phpunit', 'sessionperf');
         $request = cache::make('phpunit', 'requestperf');
         // Check that no stats are recorded for these definitions yet.
-        $stats = cache_helper::get_stats();
+        $stats = helper::get_stats();
         $this->assertArrayNotHasKey($applicationid, $stats);
         $this->assertFalse($request->get('missMe'));
         $this->assertFalse($request->get('missMe'));
         $this->assertFalse($request->get('missMe'));
         $this->assertFalse($request->get('missMe'));
-        $endstats = cache_helper::get_stats();
+        $endstats = helper::get_stats();
         $this->assertEquals(2, $endstats[$applicationid]['stores']['default_application']['misses']);
         $this->assertEquals(0, $endstats[$applicationid]['stores']['default_application']['hits']);
         $this->assertEquals(0, $endstats[$applicationid]['stores']['default_application']['sets']);
         $this->assertEquals(3, $endstats[$sessionid]['stores']['default_session']['misses']);
         $this->assertEquals(0, $endstats[$sessionid]['stores']['default_session']['hits']);
         $this->assertEquals(1, $endstats[$sessionid]['stores']['default_session']['sets']);
         $this->assertEquals(4, $endstats[$requestid]['stores']['default_request']['misses']);
         $this->assertEquals(0, $endstats[$requestid]['stores']['default_request']['hits']);
         $this->assertEquals(0, $endstats[$requestid]['stores']['default_request']['sets']);
-        $startstats = cache_helper::get_stats();
+        $startstats = helper::get_stats();
         // Check that stores register sets.
         $this->assertTrue($request->set('setMe1', 1));
         $this->assertTrue($request->set('setMe2', 2));
         $this->assertTrue($request->set('setMe3', 3));
         $this->assertTrue($request->set('setMe4', 4));
-        $endstats = cache_helper::get_stats();
+        $endstats = helper::get_stats();
         $this->assertEquals(0, $endstats[$applicationid]['stores']['default_application']['misses'] -
                              $startstats[$applicationid]['stores']['default_application']['misses']);
         $this->assertEquals(0, $endstats[$applicationid]['stores']['default_application']['hits'] -
                              $startstats[$applicationid]['stores']['default_application']['hits']);
         $this->assertEquals(0, $endstats[$requestid]['stores']['default_request']['hits'] -
                              $startstats[$requestid]['stores']['default_request']['hits']);
         $this->assertEquals(4, $endstats[$requestid]['stores']['default_request']['sets'] -
                              $startstats[$requestid]['stores']['default_request']['sets']);
-        $startstats = cache_helper::get_stats();
+        $startstats = helper::get_stats();
         // Check that stores register hits.
         $this->assertEquals($application->get('setMe1'), 1);
         $this->assertEquals($request->get('setMe1'), 1);
         $this->assertEquals($request->get('setMe2'), 2);
         $this->assertEquals($request->get('setMe3'), 3);
         $this->assertEquals($request->get('setMe4'), 4);
-        $endstats = cache_helper::get_stats();
+        $endstats = helper::get_stats();
         $this->assertEquals(0, $endstats[$applicationid]['stores']['default_application']['misses'] -
                              $startstats[$applicationid]['stores']['default_application']['misses']);
         $this->assertEquals(2, $endstats[$applicationid]['stores']['default_application']['hits'] -
                              $startstats[$applicationid]['stores']['default_application']['hits']);
         $this->assertEquals(4, $endstats[$requestid]['stores']['default_request']['hits'] -
                              $startstats[$requestid]['stores']['default_request']['hits']);
         $this->assertEquals(0, $endstats[$requestid]['stores']['default_request']['sets'] -
                              $startstats[$requestid]['stores']['default_request']['sets']);
-        $startstats = cache_helper::get_stats();
+        $startstats = helper::get_stats();
         // Check that stores register through get_many.
-        $application->get_many(array('setMe1', 'setMe2'));
+        $application->get_many(['setMe1', 'setMe2']);
-        $session->get_many(array('setMe1', 'setMe2', 'setMe3'));
+        $session->get_many(['setMe1', 'setMe2', 'setMe3']);
-        $request->get_many(array('setMe1', 'setMe2', 'setMe3', 'setMe4'));
+        $request->get_many(['setMe1', 'setMe2', 'setMe3', 'setMe4']);
-        $endstats = cache_helper::get_stats();
+        $endstats = helper::get_stats();
         $this->assertEquals(0, $endstats[$applicationid]['stores']['default_application']['misses'] -
                              $startstats[$applicationid]['stores']['default_application']['misses']);
         $this->assertEquals(4, $endstats[$requestid]['stores']['default_request']['hits'] -
                              $startstats[$requestid]['stores']['default_request']['hits']);
         $this->assertEquals(0, $endstats[$requestid]['stores']['default_request']['sets'] -
                              $startstats[$requestid]['stores']['default_request']['sets']);
-        $startstats = cache_helper::get_stats();
+        $startstats = helper::get_stats();
         // Check that stores register through set_many.
         $this->assertEquals(2, $application->set_many(['setMe1' => 1, 'setMe2' => 2]));
         $this->assertEquals(3, $session->set_many(['setMe1' => 1, 'setMe2' => 2, 'setMe3' => 3]));
         $this->assertEquals(4, $request->set_many(['setMe1' => 1, 'setMe2' => 2, 'setMe3' => 3, 'setMe4' => 4]));
-        $endstats = cache_helper::get_stats();
+        $endstats = helper::get_stats();
     /**
      * Data provider for static acceleration performance tests.
+     *
      * @return array
      */
-    public function static_acceleration_performance_provider(): array {
+    public static function static_acceleration_performance_provider(): array {
         // Note: These are the delta values, not the absolute values.
         // Also note that the set will actually store the valuein the static cache immediately.
         $validfirst = [
             'default_application' => [
                 'hits' => 1,
                 'misses' => 0,
             ],
-            cache_store::STATIC_ACCEL => [
+            store::STATIC_ACCEL => [
                 'hits' => 0,
                 'misses' => 1,
             ],
         ];
         $validsecond = [
             'default_application' => [
                 'hits' => 0,
                 'misses' => 0,
             ],
-            cache_store::STATIC_ACCEL => [
+            store::STATIC_ACCEL => [
                 'hits' => 1,
                 'misses' => 0,
             ],
         ];
         $invalidfirst = [
             'default_application' => [
                 'hits' => 0,
                 'misses' => 1,
             ],
-            cache_store::STATIC_ACCEL => [
+            store::STATIC_ACCEL => [
                 'hits' => 0,
                 'misses' => 1,
             ],
         ];
         $invalidsecond = [
             'default_application' => [
                 'hits' => 0,
                 'misses' => 1,
             ],
-            cache_store::STATIC_ACCEL => [
+            store::STATIC_ACCEL => [
                 'hits' => 0,
                 'misses' => 1,
+            ],
-            ],
+        ];
         ];;
         return [
         $this->resetAfterTest(true);
         $CFG->perfdebug = 15;
         $instance = cache_config_testing::instance();
         $instance->phpunit_add_definition('phpunit/accelerated', [
-            'mode' => cache_store::MODE_APPLICATION,
+            'mode' => store::MODE_APPLICATION,
             'component' => 'phpunit',
             'area' => 'accelerated',
             'staticacceleration' => true,
             'staticaccelerationsize' => 1,
         $cache = cache::make('phpunit', 'accelerated');
         $this->assertInstanceOf(cache_phpunit_application::class, $cache);
         $this->assertTrue($cache->set('value', $value));
-        $checkstats = function(
+        $checkstats = function (
             array $start,
             array $expectedstats,
         ): array {
             $applicationid = 'phpunit/accelerated';
-            $endstats = cache_helper::get_stats();
+            $endstats = helper::get_stats();
             return $endstats;
         };
         // Reset the cache factory so that we can get the stats from a fresh instance.
-        $factory = cache_factory::instance();
+        $factory = factory::instance();
         $factory->reset_cache_instances();
         $cache = cache::make('phpunit', 'accelerated');
         // Get the initial stats.
-        $startstats = cache_helper::get_stats();
+        $startstats = helper::get_stats();
         $CFG->perfdebug = 15;
         // Create cache store with static acceleration.
         $instance = cache_config_testing::instance();
         $applicationid = 'phpunit/applicationperf';
-        $instance->phpunit_add_definition($applicationid, array(
+        $instance->phpunit_add_definition($applicationid, [
-            'mode' => cache_store::MODE_APPLICATION,
+            'mode' => store::MODE_APPLICATION,
             'component' => 'phpunit',
             'area' => 'applicationperf',
             'simplekeys' => true,
             'staticacceleration' => true,
-            'staticaccelerationsize' => 3
+            'staticaccelerationsize' => 3,
-        ));
+        ]);
         $application = cache::make('phpunit', 'applicationperf');
         // Check that stores register sets.
         $this->assertTrue($application->set('setMe1', 1));
         $this->assertTrue($application->set('setMe2', 0));
-        $this->assertTrue($application->set('setMe3', array()));
+        $this->assertTrue($application->set('setMe3', []));
         $this->assertTrue($application->get('setMe1') !== false);
         $this->assertTrue($application->get('setMe2') !== false);
         $this->assertTrue($application->get('setMe3') !== false);
         // Check that the static acceleration worked, even on empty arrays and the number 0.
-        $endstats = cache_helper::get_stats();
+        $endstats = helper::get_stats();
         $this->resetAfterTest(true);
         $CFG->perfdebug = 7;
         $instance = cache_config_testing::instance();
         $applicationid = 'phpunit/applicationperfoff';
-        $instance->phpunit_add_definition($applicationid, array(
+        $instance->phpunit_add_definition($applicationid, [
-            'mode' => cache_store::MODE_APPLICATION,
+            'mode' => store::MODE_APPLICATION,
             'component' => 'phpunit',
-            'area' => 'applicationperfoff'
+            'area' => 'applicationperfoff',
-        ));
+        ]);
         $sessionid = 'phpunit/sessionperfoff';
-        $instance->phpunit_add_definition($sessionid, array(
+        $instance->phpunit_add_definition($sessionid, [
-            'mode' => cache_store::MODE_SESSION,
+            'mode' => store::MODE_SESSION,
             'component' => 'phpunit',
-            'area' => 'sessionperfoff'
+            'area' => 'sessionperfoff',
-        ));
+        ]);
         $requestid = 'phpunit/requestperfoff';
-        $instance->phpunit_add_definition($requestid, array(
+        $instance->phpunit_add_definition($requestid, [
-            'mode' => cache_store::MODE_REQUEST,
+            'mode' => store::MODE_REQUEST,
             'component' => 'phpunit',
-            'area' => 'requestperfoff'
+            'area' => 'requestperfoff',
-        ));
+        ]);
         $application = cache::make('phpunit', 'applicationperfoff');
         $session = cache::make('phpunit', 'sessionperfoff');
         $request = cache::make('phpunit', 'requestperfoff');
         // Check that no stats are recorded for these definitions yet.
-        $stats = cache_helper::get_stats();
+        $stats = helper::get_stats();
         $this->assertArrayNotHasKey($applicationid, $stats);
         $this->assertFalse($request->get('missMe'));
         $this->assertTrue($request->set('setMe', 4));
         $this->assertEquals(4, $request->get('setMe'));
         // Check that no stats are being recorded for these definitions.
-        $endstats = cache_helper::get_stats();
+        $endstats = helper::get_stats();
         $this->assertArrayNotHasKey($applicationid, $endstats);
         $this->assertArrayNotHasKey($sessionid, $endstats);
         $this->assertArrayNotHasKey($requestid, $endstats);
      * A new request is started a short time later.
      * The cache should be filled.
      */
     public function test_session_event_purge_same_second(): void {
         $instance = cache_config_testing::instance();
-        $instance->phpunit_add_definition('phpunit/eventpurgetest', array(
+        $instance->phpunit_add_definition('phpunit/eventpurgetest', [
-            'mode' => cache_store::MODE_SESSION,
+            'mode' => store::MODE_SESSION,
             'component' => 'phpunit',
             'area' => 'eventpurgetest',
-            'invalidationevents' => array(
+            'invalidationevents' => [
                 'crazyevent',
-            )
+            ],
-        ));
+        ]);
         // Create the cache, set a value, and immediately purge it by event.
         $cache = cache::make('phpunit', 'eventpurgetest');
         $cache->set('testkey1', 'test data 1');
         $this->assertEquals('test data 1', $cache->get('testkey1'));
-        cache_helper::purge_by_event('crazyevent');
+        helper::purge_by_event('crazyevent');
         $this->assertFalse($cache->get('testkey1'));
         // Set up the cache again in the same request and add a new value back in.
-        $factory = cache_factory::instance();
+        $factory = factory::instance();
         $factory->reset_cache_instances();
         $cache = cache::make('phpunit', 'eventpurgetest');
         $cache->set('testkey1', 'test data 2');
         $this->assertEquals('test data 2', $cache->get('testkey1'));
         // Trick the cache into thinking that this is a new request.
         cache_phpunit_cache::simulate_new_request();
-        $factory = cache_factory::instance();
+        $factory = factory::instance();
         $factory->reset_cache_instances();
     public function test_session_distinct_storage_key(): void {
         $this->resetAfterTest();
         // Prepare a dummy session cache configuration.
         $config = cache_config_testing::instance();
-        $config->phpunit_add_definition('phpunit/test_session_distinct_storage_key', array(
+        $config->phpunit_add_definition('phpunit/test_session_distinct_storage_key', [
-            'mode' => cache_store::MODE_SESSION,
+            'mode' => store::MODE_SESSION,
             'component' => 'phpunit',
-            'area' => 'test_session_distinct_storage_key'
+            'area' => 'test_session_distinct_storage_key',
-        ));
+        ]);
         // First anonymous user's session cache.
         cache_phpunit_session::phpunit_mockup_session_id('foo');
         $this->setUser(0);
         $cache1 = cache::make('phpunit', 'test_session_distinct_storage_key');
         // Reset cache instances to emulate a new request.
-        cache_factory::instance()->reset_cache_instances();
+        factory::instance()->reset_cache_instances();
         // Another anonymous user's session cache.
         cache_phpunit_session::phpunit_mockup_session_id('bar');
         $this->setUser(0);
         $cache2 = cache::make('phpunit', 'test_session_distinct_storage_key');
-        cache_factory::instance()->reset_cache_instances();
+        factory::instance()->reset_cache_instances();
         // Guest user's session cache.
         cache_phpunit_session::phpunit_mockup_session_id('baz');
         $this->setGuestUser();

Proyectos de Subversion Moodle

(root)/cache/tests/cache_test.php – Rev 11 → 1441