L-electron-Rare/moodle
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

MDL-73785 phpunit: Move more tests to use correct names and namespaces

Browse Source 
Applied the following changes to various testcase classes:

- Namespaced with component[\level2-API]
- Moved to level2-API subdirectory when required.
- Fixed incorrect use statements with leading backslash.
- Remove file phpdoc block
- Remove MOODLE_INTERNAL if not needed.
- Changed code to point to global scope when needed.
- Fix some relative paths and comments here and there.
- All them passing individually.
- Complete runs passing too.

Special mention to:

- When belonging to other components and being valid api:
  - analytics related tests have been moved to tests/analytics subdir.
  - backup & restore related tests have been moved to tests/backup subdir.
  - events related tests have been moved to tests/event subdir.
  - privacy related tests have been moved to tests/privacy.
  - task related tests have been moved to tests/task subdir.
- Some simple renames, not including the component part anymore (not
  needed now that they are namespaced):
  - some xxxlib_test.php have been renamed lib_test.php
    (when they where testing the corresponding lib.php).
  - cache stores tests have been all renamed store_test, originally
    each one had its own name (file_test, apcu_test, redis_test...)
  - assign feedback tests have been all renamed feedback_test, originally
    each one had its own name (file_test, editpdf_test...)
This commit is contained in:
Eloy Lafuente (stronk7)
2022-03-03 12:19:30 +01:00
parent 1d99ba19a2
commit 4003e31983
87 changed files with 1307 additions and 1716 deletions
Download Patch File Download Diff File Expand all files Collapse all files
cache/tests/cache_test.php
Vendored
+96 -87
View File
@@ -16,33 +16,42 @@
namespace core_cache;
use advanced_testcase;
use cache;
use cache_application;
use cache_config;
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_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 cacheable_object_array;
use cache_request;
use cache_session;
use cache_store;
use coding_exception;
use Exception;
use stdClass;
use cacheable_object_array;
/**
* PHPunit tests for the cache API
*
* @package core_cache
* 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
* @category cache
* @copyright 2012 Sam Hemelryk
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
* @coversDefaultClass \cache
*/
class cache_test extends advanced_testcase {
class cache_test extends \advanced_testcase {
/**
* Load required libraries and fixtures.
@@ -128,7 +137,7 @@ class cache_test extends advanced_testcase {
}
$instance = cache_config::instance();
$this->assertInstanceOf('cache_config_testing', $instance);
$this->assertInstanceOf(cache_config_testing::class, $instance);
$this->assertTrue(cache_config_testing::config_file_exists());
@@ -229,7 +238,7 @@ class cache_test extends advanced_testcase {
*/
public function test_default_application_cache() {
$cache = cache::make_from_params(cache_store::MODE_APPLICATION, 'phpunit', 'applicationtest');
$this->assertInstanceOf('cache_application', $cache);
$this->assertInstanceOf(cache_application::class, $cache);
$this->run_on_cache($cache);
$instance = cache_config_testing::instance(true);
@@ -241,7 +250,7 @@ class cache_test extends advanced_testcase {
'staticaccelerationsize' => 1
));
$cache = cache::make('phpunit', 'test_default_application_cache');
$this->assertInstanceOf('cache_application', $cache);
$this->assertInstanceOf(cache_application::class, $cache);
$this->run_on_cache($cache);
}
@@ -250,7 +259,7 @@ class cache_test extends advanced_testcase {
*/
public function test_default_session_cache() {
$cache = cache::make_from_params(cache_store::MODE_SESSION, 'phpunit', 'applicationtest');
$this->assertInstanceOf('cache_session', $cache);
$this->assertInstanceOf(cache_session::class, $cache);
$this->run_on_cache($cache);
}
@@ -259,7 +268,7 @@ class cache_test extends advanced_testcase {
*/
public function test_default_request_cache() {
$cache = cache::make_from_params(cache_store::MODE_REQUEST, 'phpunit', 'applicationtest');
$this->assertInstanceOf('cache_request', $cache);
$this->assertInstanceOf(cache_request::class, $cache);
$this->run_on_cache($cache);
}
@@ -347,7 +356,7 @@ class cache_test extends advanced_testcase {
$specobject = new cache_phpunit_dummy_object('red', 'blue', $starttime);
$this->assertTrue($cache->set($key, $specobject));
$result = $cache->get($key);
$this->assertInstanceOf('cache_phpunit_dummy_object', $result);
$this->assertInstanceOf(cache_phpunit_dummy_object::class, $result);
$this->assertEquals('red_ptc_wfc', $result->property1);
$this->assertEquals('blue_ptc_wfc', $result->property2);
$this->assertGreaterThan($starttime, $result->propertytime);
@@ -361,10 +370,10 @@ class cache_test extends advanced_testcase {
);
$this->assertTrue($cache->set($key, $data));
$result = $cache->get($key);
$this->assertInstanceOf('cacheable_object_array', $result);
$this->assertInstanceOf(cacheable_object_array::class, $result);
$this->assertCount(3, $data);
foreach ($result as $item) {
$this->assertInstanceOf('cache_phpunit_dummy_object', $item);
$this->assertInstanceOf(cache_phpunit_dummy_object::class, $item);
$this->assertEquals('red_ptc_wfc', $item->property1);
$this->assertEquals('blue_ptc_wfc', $item->property2);
// Ensure that wake from cache is called in all cases.
@@ -408,29 +417,29 @@ class cache_test extends advanced_testcase {
$this->assertFalse($cache->get('key3'));
// Quick reference test.
$obj = new stdClass;
$obj = new \stdClass;
$obj->key = 'value';
$ref =& $obj;
$this->assertTrue($cache->set('obj', $obj));
$obj->key = 'eulav';
$var = $cache->get('obj');
$this->assertInstanceOf('stdClass', $var);
$this->assertInstanceOf(\stdClass::class, $var);
$this->assertEquals('value', $var->key);
$ref->key = 'eulav';
$var = $cache->get('obj');
$this->assertInstanceOf('stdClass', $var);
$this->assertInstanceOf(\stdClass::class, $var);
$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;
$obj2->subobj =& $obj3;
@@ -440,62 +449,62 @@ class cache_test extends advanced_testcase {
$obj2->key = 'tset';
$obj3->key = 'krop';
$var = $cache->get('obj');
$this->assertInstanceOf('stdClass', $var);
$this->assertInstanceOf(\stdClass::class, $var);
$this->assertEquals('value', $var->key);
$this->assertInstanceOf('stdClass', $var->subobj);
$this->assertInstanceOf(\stdClass::class, $var->subobj);
$this->assertEquals('test', $var->subobj->key);
$this->assertInstanceOf('stdClass', $var->subobj->subobj);
$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', $var);
$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));
$var1 = $cache->get('obj');
$this->assertInstanceOf('stdClass', $var1);
$this->assertInstanceOf(\stdClass::class, $var1);
$this->assertEquals('value', $var1->key);
$var1->key = 'eulav';
$this->assertEquals('eulav', $var1->key);
$var2 = $cache->get('obj');
$this->assertInstanceOf('stdClass', $var2);
$this->assertInstanceOf(\stdClass::class, $var2);
$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)));
$var = $cache->get_many(array('obj'));
$this->assertInstanceOf('stdClass', $var['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)));
$var1 = $cache->get_many(array('obj'));
$this->assertInstanceOf('stdClass', $var1['obj']);
$this->assertInstanceOf(\stdClass::class, $var1['obj']);
$this->assertEquals('value', $var1['obj']->key);
$var1['obj']->key = 'eulav';
$this->assertEquals('eulav', $var1['obj']->key);
$var2 = $cache->get_many(array('obj'));
$this->assertInstanceOf('stdClass', $var2['obj']);
$this->assertInstanceOf(\stdClass::class, $var2['obj']);
$this->assertEquals('value', $var2['obj']->key);
$this->assertTrue($cache->delete('obj'));
@@ -504,20 +513,20 @@ class cache_test extends advanced_testcase {
try {
$cache->get('exception', MUST_EXIST);
$this->fail('Exception expected from cache::get using MUST_EXIST');
} catch (Exception $e) {
} catch (\Exception $e) {
$this->assertTrue(true);
}
try {
$cache->get_many(array('exception1', 'exception2'), MUST_EXIST);
$this->fail('Exception expected from cache::get_many using MUST_EXIST');
} catch (Exception $e) {
} catch (\Exception $e) {
$this->assertTrue(true);
}
$cache->set('test', 'test');
try {
$cache->get_many(array('test', 'exception'), MUST_EXIST);
$this->fail('Exception expected from cache::get_many using MUST_EXIST');
} catch (Exception $e) {
} catch (\Exception $e) {
$this->assertTrue(true);
}
}
@@ -536,7 +545,7 @@ class cache_test extends advanced_testcase {
));
$cache = cache::make('phpunit', 'datasourcetest');
$this->assertInstanceOf('cache_application', $cache);
$this->assertInstanceOf(cache_application::class, $cache);
// Purge it to be sure.
$this->assertTrue($cache->purge());
@@ -631,8 +640,8 @@ class cache_test extends advanced_testcase {
'overrideclassfile' => 'cache/tests/fixtures/lib.php'
));
$cache = cache::make('phpunit', 'overridetest');
$this->assertInstanceOf('cache_phpunit_dummy_overrideclass', $cache);
$this->assertInstanceOf('cache_application', $cache);
$this->assertInstanceOf(cache_phpunit_dummy_overrideclass::class, $cache);
$this->assertInstanceOf(cache_application::class, $cache);
// Purge it to be sure.
$this->assertTrue($cache->purge());
// It won't be there yet.
@@ -663,12 +672,12 @@ class cache_test extends advanced_testcase {
), false);
$cacheonly = cache::make('phpunit', 'mappingsonly');
$this->assertInstanceOf('cache_application', $cacheonly);
$this->assertInstanceOf(cache_application::class, $cacheonly);
$this->assertEquals('cachestore_dummy', $cacheonly->phpunit_get_store_class());
$expected = $this->get_expected_application_cache_store();
$cachenon = cache::make('phpunit', 'nonmappingsonly');
$this->assertInstanceOf('cache_application', $cachenon);
$this->assertInstanceOf(cache_application::class, $cachenon);
$this->assertEquals($expected, $cachenon->phpunit_get_store_class());
}
@@ -728,7 +737,7 @@ class cache_test extends advanced_testcase {
'ttl' => -86400 // Set to a day in the past to be extra sure.
));
$cache = cache::make('phpunit', 'ttltest');
$this->assertInstanceOf('cache_application', $cache);
$this->assertInstanceOf(cache_application::class, $cache);
// Purge it to be sure.
$this->assertTrue($cache->purge());
@@ -777,7 +786,7 @@ class cache_test extends advanced_testcase {
'ttl' => 86400 // Set to a day in the future to be extra sure.
));
$cache = cache::make('phpunit', 'ttltest');
$this->assertInstanceOf('cache_application', $cache);
$this->assertInstanceOf(cache_application::class, $cache);
// Purge it to be sure.
$this->assertTrue($cache->purge());
@@ -826,7 +835,7 @@ class cache_test extends advanced_testcase {
'ttl' => 86400 // Set to a day in the future to be extra sure.
));
$cache = cache::make('phpunit', 'ttltest');
$this->assertInstanceOf('cache_session', $cache);
$this->assertInstanceOf(cache_session::class, $cache);
// Purge it to be sure.
$this->assertTrue($cache->purge());
@@ -941,7 +950,7 @@ class cache_test extends advanced_testcase {
)
));
$cache = cache::make('phpunit', 'test_session_event_invalidation');
$this->assertInstanceOf('cache_session', $cache);
$this->assertInstanceOf(cache_session::class, $cache);
$this->assertTrue($cache->set('testkey1', 'test data 1'));
$this->assertEquals('test data 1', $cache->get('testkey1'));
@@ -1010,7 +1019,7 @@ class cache_test extends advanced_testcase {
'area' => 'test_session_definition_invalidation'
));
$cache = cache::make('phpunit', 'test_session_definition_invalidation');
$this->assertInstanceOf('cache_session', $cache);
$this->assertInstanceOf(cache_session::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'));
@@ -1306,7 +1315,7 @@ class cache_test extends advanced_testcase {
$this->resetAfterTest();
$CFG->altcacheconfigpath = $CFG->dataroot.'/cache/altcacheconfigpath';
$instance = cache_config_testing::instance();
$this->assertInstanceOf('cache_config', $instance);
$this->assertInstanceOf(cache_config::class, $instance);
}
/**
@@ -1336,9 +1345,9 @@ class cache_test extends advanced_testcase {
'disabletest3' => cache::make('phpunit', 'disabletest3')
);
$this->assertInstanceOf('cache_phpunit_application', $caches['disabletest1']);
$this->assertInstanceOf('cache_phpunit_session', $caches['disabletest2']);
$this->assertInstanceOf('cache_phpunit_request', $caches['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->assertEquals('cachestore_session', $caches['disabletest2']->phpunit_get_store_class());
@@ -1358,9 +1367,9 @@ class cache_test extends advanced_testcase {
'disabletest3' => cache::make('phpunit', 'disabletest3')
);
$this->assertInstanceOf('cache_phpunit_application', $caches['disabletest1']);
$this->assertInstanceOf('cache_phpunit_session', $caches['disabletest2']);
$this->assertInstanceOf('cache_phpunit_request', $caches['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_dummy', $caches['disabletest1']->phpunit_get_store_class());
$this->assertEquals('cachestore_dummy', $caches['disabletest2']->phpunit_get_store_class());
@@ -1397,19 +1406,19 @@ class cache_test extends advanced_testcase {
// Check we get the expected disabled factory.
$factory = cache_factory::instance();
$this->assertInstanceOf('cache_factory_disabled', $factory);
$this->assertInstanceOf(cache_factory_disabled::class, $factory);
// Check we get the expected disabled config.
$config = $factory->create_config_instance();
$this->assertInstanceOf('cache_config_disabled', $config);
$this->assertInstanceOf(cache_config_disabled::class, $config);
// Check we get the expected disabled caches.
$cache = cache::make('core', 'string');
$this->assertInstanceOf('cache_disabled', $cache);
$this->assertInstanceOf(cache_disabled::class, $cache);
// Test an application cache.
$cache = cache::make_from_params(cache_store::MODE_APPLICATION, 'phpunit', 'disable');
$this->assertInstanceOf('cache_disabled', $cache);
$this->assertInstanceOf(cache_disabled::class, $cache);
$this->assertFalse($cache->get('test'));
$this->assertFalse($cache->get_versioned('v', 1));
@@ -1420,7 +1429,7 @@ class cache_test extends advanced_testcase {
// Test a session cache.
$cache = cache::make_from_params(cache_store::MODE_SESSION, 'phpunit', 'disable');
$this->assertInstanceOf('cache_disabled', $cache);
$this->assertInstanceOf(cache_disabled::class, $cache);
$this->assertFalse($cache->get('test'));
$this->assertFalse($cache->get_versioned('v', 1));
@@ -1431,7 +1440,7 @@ class cache_test extends advanced_testcase {
// Finally test a request cache.
$cache = cache::make_from_params(cache_store::MODE_REQUEST, 'phpunit', 'disable');
$this->assertInstanceOf('cache_disabled', $cache);
$this->assertInstanceOf(cache_disabled::class, $cache);
$this->assertFalse($cache->get('test'));
$this->assertFalse($cache->get_versioned('v', 1));
@@ -1463,7 +1472,7 @@ class cache_test extends advanced_testcase {
$instance->phpunit_add_definition_mapping('phpunit/multi_loader', 'phpunittest2', 2);
$cache = cache::make('phpunit', 'multi_loader');
$this->assertInstanceOf('cache_application', $cache);
$this->assertInstanceOf(cache_application::class, $cache);
$this->assertFalse($cache->get('test'));
$this->assertTrue($cache->set('test', 'test'));
$this->assertEquals('test', $cache->get('test'));
@@ -1895,7 +1904,7 @@ class cache_test extends advanced_testcase {
$instance->phpunit_add_definition_mapping('phpunit/multi_loader', 'phpunittest2', 2);
$cache = cache::make('phpunit', 'multi_loader');
$this->assertInstanceOf('cache_session', $cache);
$this->assertInstanceOf(cache_session::class, $cache);
$this->assertFalse($cache->get('test'));
$this->assertTrue($cache->set('test', 'test'));
$this->assertEquals('test', $cache->get('test'));
@@ -2091,7 +2100,7 @@ class cache_test extends advanced_testcase {
'requirelockingwrite' => true
));
$cache = cache::make('phpunit', 'test_application_locking');
$this->assertInstanceOf('cache_application', $cache);
$this->assertInstanceOf(cache_application::class, $cache);
$this->assertTrue($cache->set('a', 'A'));
$this->assertTrue($cache->set('b', 'B'));
@@ -2113,14 +2122,14 @@ class cache_test extends advanced_testcase {
'area' => 'test_purge_stores_used_by_definition'
));
$cache = cache::make('phpunit', 'test_purge_stores_used_by_definition');
$this->assertInstanceOf('cache_application', $cache);
$this->assertInstanceOf(cache_application::class, $cache);
$this->assertTrue($cache->set('test', 'test'));
unset($cache);
cache_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', $cache);
$this->assertInstanceOf(cache_application::class, $cache);
$this->assertFalse($cache->get('test'));
}
@@ -2147,7 +2156,7 @@ class cache_test extends advanced_testcase {
$definition = $factory->create_definition('phpunit', 'purge1');
$this->assertFalse($definition->has_required_identifiers());
$cache = $factory->create_cache($definition);
$this->assertInstanceOf('cache_application', $cache);
$this->assertInstanceOf(cache_application::class, $cache);
$this->assertTrue($cache->set('test', 'test'));
$this->assertTrue($cache->has('test'));
cache_helper::purge_by_definition('phpunit', 'purge1');
@@ -2157,7 +2166,7 @@ class cache_test extends advanced_testcase {
$definition = $factory->create_definition('phpunit', 'purge2');
$this->assertTrue($definition->has_required_identifiers());
$cache = $factory->create_cache($definition);
$this->assertInstanceOf('cache_application', $cache);
$this->assertInstanceOf(cache_application::class, $cache);
$this->assertTrue($cache->set('test', 'test'));
$this->assertTrue($cache->has('test'));
cache_helper::purge_stores_used_by_definition('phpunit', 'purge2');
@@ -2166,7 +2175,7 @@ class cache_test extends advanced_testcase {
try {
cache_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());
}
}
@@ -2175,7 +2184,7 @@ class cache_test extends advanced_testcase {
* Tests that ad-hoc caches are correctly purged with a purge_all call.
*/
public function test_purge_all_with_adhoc_caches() {
$cache = \cache::make_from_params(\cache_store::MODE_REQUEST, 'core_cache', 'test');
$cache = cache::make_from_params(cache_store::MODE_REQUEST, 'core_cache', 'test');
$cache->set('test', 123);
cache_helper::purge_all();
$this->assertFalse($cache->get('test'));
@@ -2208,26 +2217,26 @@ class cache_test extends advanced_testcase {
// Test application cache is searchable.
$definition = $factory->create_definition('phpunit', 'search1');
$this->assertInstanceOf('cache_definition', $definition);
$this->assertInstanceOf(cache_definition::class, $definition);
$this->assertEquals(cache_store::IS_SEARCHABLE, $definition->get_requirements_bin() & cache_store::IS_SEARCHABLE);
$cache = $factory->create_cache($definition);
$this->assertInstanceOf('cache_application', $cache);
$this->assertInstanceOf(cache_application::class, $cache);
$this->assertArrayHasKey('cache_is_searchable', $cache->phpunit_get_store_implements());
// Test session cache is searchable.
$definition = $factory->create_definition('phpunit', 'search2');
$this->assertInstanceOf('cache_definition', $definition);
$this->assertInstanceOf(cache_definition::class, $definition);
$this->assertEquals(cache_store::IS_SEARCHABLE, $definition->get_requirements_bin() & cache_store::IS_SEARCHABLE);
$cache = $factory->create_cache($definition);
$this->assertInstanceOf('cache_session', $cache);
$this->assertInstanceOf(cache_session::class, $cache);
$this->assertArrayHasKey('cache_is_searchable', $cache->phpunit_get_store_implements());
// Test request cache is searchable.
$definition = $factory->create_definition('phpunit', 'search3');
$this->assertInstanceOf('cache_definition', $definition);
$this->assertInstanceOf(cache_definition::class, $definition);
$this->assertEquals(cache_store::IS_SEARCHABLE, $definition->get_requirements_bin() & cache_store::IS_SEARCHABLE);
$cache = $factory->create_cache($definition);
$this->assertInstanceOf('cache_request', $cache);
$this->assertInstanceOf(cache_request::class, $cache);
$this->assertArrayHasKey('cache_is_searchable', $cache->phpunit_get_store_implements());
}
@@ -2283,7 +2292,7 @@ class cache_test extends advanced_testcase {
));
$cache = cache::make('phpunit', 'accelerated');
$this->assertInstanceOf('cache_phpunit_application', $cache);
$this->assertInstanceOf(cache_phpunit_application::class, $cache);
// Set and get three elements.
$this->assertTrue($cache->set('a', 'A'));
@@ -2350,12 +2359,12 @@ class cache_test extends advanced_testcase {
// Get the value from the backend store, populating the static cache.
$cachevalue = $cache->get('a');
$this->assertInstanceOf('cache_phpunit_dummy_object', $cachevalue);
$this->assertInstanceOf(cache_phpunit_dummy_object::class, $cachevalue);
$this->assertGreaterThanOrEqual($staticaccelerationreturntime, $cachevalue->propertytime);
$backingstorereturntime = $cachevalue->propertytime;
$results = $cache->get_many(array('b'));
$this->assertInstanceOf('cache_phpunit_dummy_object', $results['b']);
$this->assertInstanceOf(cache_phpunit_dummy_object::class, $results['b']);
$this->assertGreaterThanOrEqual($staticaccelerationreturntimeb, $results['b']->propertytime);
$backingstorereturntimeb = $results['b']->propertytime;
@@ -2363,16 +2372,16 @@ class cache_test extends advanced_testcase {
// Upon failure, the times are not adjusted as wake_from_cache is skipped as the
// value is stored serialized in the static acceleration cache.
$cachevalue = $cache->phpunit_static_acceleration_get('a');
$this->assertInstanceOf('cache_phpunit_dummy_object', $cachevalue);
$this->assertInstanceOf(cache_phpunit_dummy_object::class, $cachevalue);
$this->assertGreaterThanOrEqual($backingstorereturntime, $cachevalue->propertytime);
$results = $cache->get_many(array('b'));
$this->assertInstanceOf('cache_phpunit_dummy_object', $results['b']);
$this->assertInstanceOf(cache_phpunit_dummy_object::class, $results['b']);
$this->assertGreaterThanOrEqual($backingstorereturntimeb, $results['b']->propertytime);
/** @var cache_phpunit_application $cache */
$cache = cache::make('phpunit', 'accelerated2');
$this->assertInstanceOf('cache_phpunit_application', $cache);
$this->assertInstanceOf(cache_phpunit_application::class, $cache);
// Check that the array holds the last accessed items by get/set.
$this->assertTrue($cache->set('a', 'A'));
@@ -2406,7 +2415,7 @@ class cache_test extends advanced_testcase {
$cache = cache::make('phpunit', 'accelerated3');
$this->assertInstanceOf('cache_phpunit_application', $cache);
$this->assertInstanceOf(cache_phpunit_application::class, $cache);
// Check that the array holds the last accessed items by get/set.
$this->assertTrue($cache->set('a', 'A'));
@@ -2435,7 +2444,7 @@ class cache_test extends advanced_testcase {
$this->assertEquals('E', $cache->phpunit_static_acceleration_get('e'));
$cache = cache::make('phpunit', 'accelerated4');
$this->assertInstanceOf('cache_phpunit_application', $cache);
$this->assertInstanceOf(cache_phpunit_application::class, $cache);
$this->assertTrue($cache->set('a', 'A'));
$this->assertTrue($cache->set('a', 'A'));
$this->assertTrue($cache->set('a', 'A'));
@@ -2448,7 +2457,7 @@ class cache_test extends advanced_testcase {
// Setting simpledata to false objects are cloned when retrieving data.
$cache = cache::make('phpunit', 'simpledataarea1');
$notreallysimple = new stdClass();
$notreallysimple = new \stdClass();
$notreallysimple->name = 'a';
$cache->set('a', $notreallysimple);
$returnedinstance1 = $cache->get('a');
@@ -2458,7 +2467,7 @@ class cache_test extends advanced_testcase {
// Setting simpledata to true we assume that data does not contain references.
$cache = cache::make('phpunit', 'simpledataarea2');
$notreallysimple = new stdClass();
$notreallysimple = new \stdClass();
$notreallysimple->name = 'a';
$cache->set('a', $notreallysimple);
$returnedinstance1 = $cache->get('a');
@@ -2769,7 +2778,7 @@ class cache_test extends advanced_testcase {
$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 = cache_factory::instance();
$factory->reset_cache_instances();
$cache = cache::make('phpunit', 'eventpurgetest');
$cache->set('testkey1', 'test data 2');
@@ -2777,7 +2786,7 @@ class cache_test extends advanced_testcase {
// Trick the cache into thinking that this is a new request.
cache_phpunit_cache::simulate_new_request();
$factory = \cache_factory::instance();
$factory = cache_factory::instance();
$factory->reset_cache_instances();
// Set up the cache again.