/**
  * Test the maxsize option.
  */
 public function test_maxsize()
 {
     $defid = 'phpunit/testmaxsize';
     $config = cache_config_phpunittest::instance();
     $config->phpunit_add_definition($defid, array('mode' => cache_store::MODE_REQUEST, 'component' => 'phpunit', 'area' => 'testmaxsize', 'maxsize' => 3));
     $definition = cache_definition::load($defid, $config->get_definition_by_id($defid));
     $instance = cachestore_static::initialise_test_instance($definition);
     $this->assertTrue($instance->set('key1', 'value1'));
     $this->assertTrue($instance->set('key2', 'value2'));
     $this->assertTrue($instance->set('key3', 'value3'));
     $this->assertTrue($instance->has('key1'));
     $this->assertTrue($instance->has('key2'));
     $this->assertTrue($instance->has('key3'));
     $this->assertTrue($instance->set('key4', 'value4'));
     $this->assertTrue($instance->set('key5', 'value5'));
     $this->assertFalse($instance->has('key1'));
     $this->assertFalse($instance->has('key2'));
     $this->assertTrue($instance->has('key3'));
     $this->assertTrue($instance->has('key4'));
     $this->assertTrue($instance->has('key5'));
     $this->assertFalse($instance->get('key1'));
     $this->assertFalse($instance->get('key2'));
     $this->assertEquals('value3', $instance->get('key3'));
     $this->assertEquals('value4', $instance->get('key4'));
     $this->assertEquals('value5', $instance->get('key5'));
     // Test adding one more.
     $this->assertTrue($instance->set('key6', 'value6'));
     $this->assertFalse($instance->get('key3'));
     // Test reducing and then adding to make sure we don't lost one.
     $this->assertTrue($instance->delete('key6'));
     $this->assertTrue($instance->set('key7', 'value7'));
     $this->assertEquals('value4', $instance->get('key4'));
     // Set the same key three times to make sure it doesn't count overrides.
     for ($i = 0; $i < 3; $i++) {
         $this->assertTrue($instance->set('key8', 'value8'));
     }
     $this->assertEquals('value7', $instance->get('key7'), 'Overrides are incorrectly incrementing size');
     // Test adding many.
     $this->assertEquals(3, $instance->set_many(array(array('key' => 'keyA', 'value' => 'valueA'), array('key' => 'keyB', 'value' => 'valueB'), array('key' => 'keyC', 'value' => 'valueC'))));
     $this->assertEquals(array('key4' => false, 'key5' => false, 'key6' => false, 'key7' => false, 'keyA' => 'valueA', 'keyB' => 'valueB', 'keyC' => 'valueC'), $instance->get_many(array('key4', 'key5', 'key6', 'key7', 'keyA', 'keyB', 'keyC')));
 }
Exemplo n.º 2
0
 /**
  * Test that multiple loaders work ok.
  */
 public function test_multiple_loaders()
 {
     $instance = cache_config_phpunittest::instance(true);
     $instance->phpunit_add_file_store('phpunittest1');
     $instance->phpunit_add_file_store('phpunittest2');
     $instance->phpunit_add_definition('phpunit/multi_loader', array('mode' => cache_store::MODE_APPLICATION, 'component' => 'phpunit', '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', $cache);
     $this->assertFalse($cache->get('test'));
     $this->assertTrue($cache->set('test', 'test'));
     $this->assertEquals('test', $cache->get('test'));
 }
Exemplo n.º 3
0
 /**
  * Test the hash_key functionality.
  */
 public function test_hash_key()
 {
     global $CFG;
     $currentdebugging = $CFG->debug;
     $CFG->debug = E_ALL;
     // First with simplekeys
     $instance = cache_config_phpunittest::instance(true);
     $instance->phpunit_add_definition('phpunit/hashtest', array('mode' => cache_store::MODE_APPLICATION, 'component' => 'phpunit', 'area' => 'hashtest', 'simplekeys' => true));
     $factory = cache_factory::instance();
     $definition = $factory->create_definition('phpunit', 'hashtest');
     $result = cache_helper::hash_key('test', $definition);
     $this->assertEquals('test-' . $definition->generate_single_key_prefix(), $result);
     try {
         cache_helper::hash_key('test/test', $definition);
         $this->fail('Invalid key was allowed, you should see this.');
     } catch (coding_exception $e) {
         $this->assertEquals('test/test', $e->debuginfo);
     }
     // Second without simple keys
     $instance->phpunit_add_definition('phpunit/hashtest2', array('mode' => cache_store::MODE_APPLICATION, 'component' => 'phpunit', 'area' => 'hashtest2', 'simplekeys' => false));
     $definition = $factory->create_definition('phpunit', 'hashtest2');
     $result = cache_helper::hash_key('test', $definition);
     $this->assertEquals(sha1($definition->generate_single_key_prefix() . '-test'), $result);
     $result = cache_helper::hash_key('test/test', $definition);
     $this->assertEquals(sha1($definition->generate_single_key_prefix() . '-test/test'), $result);
     $CFG->debug = $currentdebugging;
 }
Exemplo n.º 4
0
 public function test_static_acceleration()
 {
     $instance = cache_config_phpunittest::instance();
     $instance->phpunit_add_definition('phpunit/accelerated', array('mode' => cache_store::MODE_APPLICATION, 'component' => 'phpunit', 'area' => 'accelerated', 'staticacceleration' => true, 'staticaccelerationsize' => 3));
     $instance->phpunit_add_definition('phpunit/accelerated2', array('mode' => cache_store::MODE_APPLICATION, 'component' => 'phpunit', 'area' => 'accelerated2', 'staticacceleration' => true, 'staticaccelerationsize' => 3));
     $instance->phpunit_add_definition('phpunit/accelerated3', array('mode' => cache_store::MODE_APPLICATION, 'component' => 'phpunit', 'area' => 'accelerated3', 'staticacceleration' => true, 'staticaccelerationsize' => 3));
     $instance->phpunit_add_definition('phpunit/accelerated4', array('mode' => cache_store::MODE_APPLICATION, 'component' => 'phpunit', 'area' => 'accelerated4', 'staticacceleration' => true, 'staticaccelerationsize' => 4));
     $cache = cache::make('phpunit', 'accelerated');
     $this->assertInstanceOf('cache_phpunit_application', $cache);
     // Set and get three elements.
     $this->assertTrue($cache->set('a', 'A'));
     $this->assertTrue($cache->set('b', 'B'));
     $this->assertTrue($cache->set('c', 'C'));
     $this->assertEquals('A', $cache->get('a'));
     $this->assertEquals(array('b' => 'B', 'c' => 'C'), $cache->get_many(array('b', 'c')));
     // Make sure all items are in static acceleration array.
     $this->assertEquals('A', $cache->phpunit_static_acceleration_get('a'));
     $this->assertEquals('B', $cache->phpunit_static_acceleration_get('b'));
     $this->assertEquals('C', $cache->phpunit_static_acceleration_get('c'));
     // Add new value and make sure it is in cache and it is in array.
     $this->assertTrue($cache->set('d', 'D'));
     $this->assertEquals('D', $cache->phpunit_static_acceleration_get('d'));
     $this->assertEquals('D', $cache->get('d'));
     // Now the least recent accessed item (a) is no longer in acceleration array.
     $this->assertFalse($cache->phpunit_static_acceleration_get('a'));
     $this->assertEquals('B', $cache->phpunit_static_acceleration_get('b'));
     $this->assertEquals('C', $cache->phpunit_static_acceleration_get('c'));
     // Adding and deleting element.
     $this->assertTrue($cache->set('a', 'A'));
     $this->assertTrue($cache->delete('a'));
     $this->assertFalse($cache->phpunit_static_acceleration_get('a'));
     $this->assertFalse($cache->has('a'));
     // Make sure "purge" deletes from the array as well.
     $cache->purge();
     $this->assertFalse($cache->phpunit_static_acceleration_get('a'));
     $this->assertFalse($cache->phpunit_static_acceleration_get('b'));
     $this->assertFalse($cache->phpunit_static_acceleration_get('c'));
     $this->assertFalse($cache->phpunit_static_acceleration_get('d'));
     $this->assertFalse($cache->phpunit_static_acceleration_get('e'));
     // Check that the array holds the last accessed items by get/set.
     $this->assertTrue($cache->set('a', 'A'));
     $this->assertTrue($cache->set('b', 'B'));
     $this->assertTrue($cache->set('c', 'C'));
     $this->assertTrue($cache->set('d', 'D'));
     $this->assertTrue($cache->set('e', 'E'));
     $this->assertFalse($cache->phpunit_static_acceleration_get('a'));
     $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'));
     /** @var cache_phpunit_application $cache */
     $cache = cache::make('phpunit', 'accelerated2');
     $this->assertInstanceOf('cache_phpunit_application', $cache);
     // Check that the array holds the last accessed items by get/set.
     $this->assertTrue($cache->set('a', 'A'));
     $this->assertTrue($cache->set('b', 'B'));
     $this->assertTrue($cache->set('c', 'C'));
     $this->assertTrue($cache->set('d', 'D'));
     $this->assertTrue($cache->set('e', 'E'));
     // Current keys in the array: c, d, e.
     $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'));
     $this->assertFalse($cache->phpunit_static_acceleration_get('a'));
     $this->assertFalse($cache->phpunit_static_acceleration_get('b'));
     $this->assertEquals('A', $cache->get('a'));
     // Current keys in the array: d, e, a.
     $this->assertEquals('D', $cache->phpunit_static_acceleration_get('d'));
     $this->assertEquals('E', $cache->phpunit_static_acceleration_get('e'));
     $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')));
     // 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->assertFalse($cache->phpunit_static_acceleration_get('b'));
     $this->assertFalse($cache->phpunit_static_acceleration_get('d'));
     $cache = cache::make('phpunit', 'accelerated3');
     $this->assertInstanceOf('cache_phpunit_application', $cache);
     // Check that the array holds the last accessed items by get/set.
     $this->assertTrue($cache->set('a', 'A'));
     $this->assertTrue($cache->set('b', 'B'));
     $this->assertTrue($cache->set('c', 'C'));
     $this->assertTrue($cache->set('d', 'D'));
     $this->assertTrue($cache->set('e', 'E'));
     $this->assertFalse($cache->phpunit_static_acceleration_get('a'));
     $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'));
     $this->assertTrue($cache->set('b', 'B2'));
     $this->assertFalse($cache->phpunit_static_acceleration_get('a'));
     $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->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'));
     $this->assertEquals('E', $cache->phpunit_static_acceleration_get('e'));
     $cache = cache::make('phpunit', 'accelerated4');
     $this->assertInstanceOf('cache_phpunit_application', $cache);
     $this->assertTrue($cache->set('a', 'A'));
     $this->assertTrue($cache->set('a', 'A'));
     $this->assertTrue($cache->set('a', 'A'));
     $this->assertTrue($cache->set('a', 'A'));
     $this->assertTrue($cache->set('a', 'A'));
     $this->assertTrue($cache->set('a', 'A'));
     $this->assertTrue($cache->set('a', 'A'));
     $this->assertEquals('A', $cache->phpunit_static_acceleration_get('a'));
     $this->assertEquals('A', $cache->get('a'));
 }
Exemplo n.º 5
0
 /**
  * Test the use of an alt path.
  * If we can generate a config instance we are done :)
  */
 public function test_alt_cache_path()
 {
     global $CFG;
     $this->resetAfterTest();
     $CFG->altcacheconfigpath = $CFG->dataroot . '/cache/altcacheconfigpath';
     $instance = cache_config_phpunittest::instance();
     $this->assertInstanceOf('cache_config', $instance);
 }
Exemplo n.º 6
0
 /**
  * Test purge routines.
  */
 public function test_purge_routines()
 {
     $instance = cache_config_phpunittest::instance(true);
     $instance->phpunit_add_definition('phpunit/purge1', array('mode' => cache_store::MODE_APPLICATION, 'component' => 'phpunit', 'area' => 'purge1'));
     $instance->phpunit_add_definition('phpunit/purge2', array('mode' => cache_store::MODE_APPLICATION, 'component' => 'phpunit', 'area' => 'purge2', 'requireidentifiers' => array('id')));
     $factory = cache_factory::instance();
     $definition = $factory->create_definition('phpunit', 'purge1');
     $this->assertFalse($definition->has_required_identifiers());
     $cache = $factory->create_cache($definition);
     $this->assertInstanceOf('cache_application', $cache);
     $this->assertTrue($cache->set('test', 'test'));
     $this->assertTrue($cache->has('test'));
     cache_helper::purge_by_definition('phpunit', 'purge1');
     $this->assertFalse($cache->has('test'));
     $factory = cache_factory::instance();
     $definition = $factory->create_definition('phpunit', 'purge2');
     $this->assertTrue($definition->has_required_identifiers());
     $cache = $factory->create_cache($definition);
     $this->assertInstanceOf('cache_application', $cache);
     $this->assertTrue($cache->set('test', 'test'));
     $this->assertTrue($cache->has('test'));
     cache_helper::purge_stores_used_by_definition('phpunit', 'purge2');
     $this->assertFalse($cache->has('test'));
     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) {
         $this->assertContains('Identifier required for cache has not been provided', $ex->getMessage());
     }
 }
Exemplo n.º 7
0
 public function test_ttl()
 {
     $config = cache_config_phpunittest::instance();
     $config->phpunit_add_definition('phpunit/three', array('mode' => cache_store::MODE_SESSION, 'component' => 'phpunit', 'area' => 'three', 'maxsize' => 3, 'ttl' => 3));
     $cachethree = cache::make('phpunit', 'three');
     // Make sure that when cache with ttl is full the elements that were added first are deleted first regardless of access time.
     $cachethree->set('key1', 'value1');
     $cachethree->set('key2', 'value2');
     $cachethree->set('key3', 'value3');
     $cachethree->set('key4', 'value4');
     $this->assertFalse($cachethree->get('key1'));
     $this->assertEquals('value4', $cachethree->get('key4'));
     $cachethree->set('key5', 'value5');
     $this->assertFalse($cachethree->get('key2'));
     $this->assertEquals('value4', $cachethree->get('key4'));
     $cachethree->set_many(array('key6' => 'value6', 'key7' => 'value7'));
     $this->assertEquals(array('key3' => false, 'key4' => false, 'key5' => 'value5', 'key6' => 'value6', 'key7' => 'value7'), $cachethree->get_many(array('key3', 'key4', 'key5', 'key6', 'key7')));
 }
 /**
  * Test setting some definition mappings.
  */
 public function test_set_definition_mappings()
 {
     $config = cache_config_phpunittest::instance(true);
     $config->phpunit_add_definition('phpunit/testdefinition', array('mode' => cache_store::MODE_APPLICATION, 'component' => 'phpunit', 'area' => 'testdefinition'));
     $config = cache_config_writer::instance();
     $this->assertTrue($config->add_store_instance('setdefinitiontest', 'file'));
     $this->assertInternalType('array', $config->get_definition_by_id('phpunit/testdefinition'));
     $config->set_definition_mappings('phpunit/testdefinition', array('setdefinitiontest', 'default_application'));
     try {
         $config->set_definition_mappings('phpunit/testdefinition', array('something that does not exist'));
         $this->fail('You should not be able to set a mapping for a store that does not exist.');
     } catch (Exception $e) {
         $this->assertInstanceOf('coding_exception', $e);
     }
     try {
         $config->set_definition_mappings('something/crazy', array('setdefinitiontest'));
         $this->fail('You should not be able to set a mapping for a definition that does not exist.');
     } catch (Exception $e) {
         $this->assertInstanceOf('coding_exception', $e);
     }
 }