Exemple #1
0
 /**
  * Purges the cache store, and loader if there is one.
  *
  * @return bool True on success, false otherwise
  */
 public function purge()
 {
     // 1. Purge the static acceleration array.
     $this->static_acceleration_purge();
     // 2. Purge the store.
     $this->store->purge();
     // 3. Optionally pruge any stacked loaders.
     if ($this->loader) {
         $this->loader->purge();
     }
     return true;
 }
Exemple #2
0
 /**
  * Purges the cache store, and loader if there is one.
  *
  * @return bool True on success, false otherwise
  */
 public function purge()
 {
     // 1. Purge the persist cache.
     $this->persistcache = array();
     // 2. Purge the store.
     $this->store->purge();
     // 3. Optionally pruge any stacked loaders.
     if ($this->loader) {
         $this->loader->purge();
     }
     return true;
 }
 /**
  * Purges the cache store, and loader if there is one.
  *
  * @return bool True on success, false otherwise
  */
 public function purge()
 {
     // 1. Purge the static acceleration array.
     $this->staticaccelerationarray = array();
     if ($this->staticaccelerationsize !== false) {
         $this->staticaccelerationkeys = array();
         $this->staticaccelerationcount = 0;
     }
     // 2. Purge the store.
     $this->store->purge();
     // 3. Optionally pruge any stacked loaders.
     if ($this->loader) {
         $this->loader->purge();
     }
     return true;
 }
Exemple #4
0
 /**
  * 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
  */
 protected function run_on_cache(cache_loader $cache)
 {
     $key = 'testkey';
     $datascalar = 'test data';
     $dataarray = array('test' => 'data', 'part' => 'two');
     $dataobject = (object) $dataarray;
     $this->assertTrue($cache->purge());
     // Check all read methods.
     $this->assertFalse($cache->get($key));
     $this->assertFalse($cache->has($key));
     $result = $cache->get_many(array($key));
     $this->assertCount(1, $result);
     $this->assertFalse(reset($result));
     $this->assertFalse($cache->has_any(array($key)));
     $this->assertFalse($cache->has_all(array($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));
     $this->assertCount(1, $result);
     $this->assertEquals($datascalar, reset($result));
     $this->assertTrue($cache->has_any(array($key)));
     $this->assertTrue($cache->has_all(array($key)));
     // Delete it.
     $this->assertTrue($cache->delete($key));
     // Check its gone.
     $this->assertFalse($cache->get($key));
     $this->assertFalse($cache->has($key));
     // Test arrays.
     $this->assertTrue($cache->set($key, $dataarray));
     $this->assertEquals($dataarray, $cache->get($key));
     // Test objects.
     $this->assertTrue($cache->set($key, $dataobject));
     $this->assertEquals($dataobject, $cache->get($key));
     $specobject = new cache_phpunit_dummy_object('red', 'blue');
     $this->assertTrue($cache->set($key, $specobject));
     $result = $cache->get($key);
     $this->assertInstanceOf('cache_phpunit_dummy_object', $result);
     $this->assertEquals('red_ptc_wfc', $result->property1);
     $this->assertEquals('blue_ptc_wfc', $result->property2);
     // Test set many.
     $cache->set_many(array('key1' => 'data1', 'key2' => 'data2'));
     $this->assertEquals('data1', $cache->get('key1'));
     $this->assertEquals('data2', $cache->get('key2'));
     $this->assertTrue($cache->delete('key1'));
     $this->assertTrue($cache->delete('key2'));
     // Test delete many.
     $this->assertTrue($cache->set('key1', 'data1'));
     $this->assertTrue($cache->set('key2', 'data2'));
     $this->assertEquals('data1', $cache->get('key1'));
     $this->assertEquals('data2', $cache->get('key2'));
     $this->assertEquals(2, $cache->delete_many(array('key1', 'key2')));
     $this->assertFalse($cache->get('key1'));
     $this->assertFalse($cache->get('key2'));
     // Quick reference test.
     $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->assertEquals('value', $var->key);
     $ref->key = 'eulav';
     $var = $cache->get('obj');
     $this->assertInstanceOf('stdClass', $var);
     $this->assertEquals('value', $var->key);
     $this->assertTrue($cache->delete('obj'));
     // Deep reference test.
     $obj1 = new stdClass();
     $obj1->key = 'value';
     $obj2 = new stdClass();
     $obj2->key = 'test';
     $obj3 = new stdClass();
     $obj3->key = 'pork';
     $obj1->subobj =& $obj2;
     $obj2->subobj =& $obj3;
     $this->assertTrue($cache->set('obj', $obj1));
     $obj1->key = 'eulav';
     $obj2->key = 'tset';
     $obj3->key = 'krop';
     $var = $cache->get('obj');
     $this->assertInstanceOf('stdClass', $var);
     $this->assertEquals('value', $var->key);
     $this->assertInstanceOf('stdClass', $var->subobj);
     $this->assertEquals('test', $var->subobj->key);
     $this->assertInstanceOf('stdClass', $var->subobj->subobj);
     $this->assertEquals('pork', $var->subobj->subobj->key);
     $this->assertTrue($cache->delete('obj'));
     // Death reference test... basicaly we don't want this to die.
     $obj = new stdClass();
     $obj->key = 'value';
     $obj->self =& $obj;
     $this->assertTrue($cache->set('obj', $obj));
     $var = $cache->get('obj');
     $this->assertInstanceOf('stdClass', $var);
     $this->assertEquals('value', $var->key);
     // Reference test after retrieve.
     $obj = new stdClass();
     $obj->key = 'value';
     $this->assertTrue($cache->set('obj', $obj));
     $var1 = $cache->get('obj');
     $this->assertInstanceOf('stdClass', $var1);
     $this->assertEquals('value', $var1->key);
     $var1->key = 'eulav';
     $this->assertEquals('eulav', $var1->key);
     $var2 = $cache->get('obj');
     $this->assertInstanceOf('stdClass', $var2);
     $this->assertEquals('value', $var2->key);
     $this->assertTrue($cache->delete('obj'));
 }
Exemple #5
0
 /**
  * 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
  */
 protected function run_on_cache(cache_loader $cache)
 {
     $key = 'contestkey';
     $datascalars = array('test data', null);
     $dataarray = array('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));
         $this->assertCount(1, $result);
         $this->assertFalse(reset($result));
         $this->assertFalse($cache->has_any(array($key)));
         $this->assertFalse($cache->has_all(array($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));
         $this->assertCount(1, $result);
         $this->assertEquals($datascalar, reset($result));
         $this->assertTrue($cache->has_any(array($key)));
         $this->assertTrue($cache->has_all(array($key)));
         // Delete it.
         $this->assertTrue($cache->delete($key));
         // Check its gone.
         $this->assertFalse($cache->get($key));
         $this->assertFalse($cache->has($key));
     }
     // Test arrays.
     $this->assertTrue($cache->set($key, $dataarray));
     $this->assertEquals($dataarray, $cache->get($key));
     // Test objects.
     $this->assertTrue($cache->set($key, $dataobject));
     $this->assertEquals($dataobject, $cache->get($key));
     $specobject = new cache_phpunit_dummy_object('red', 'blue');
     $this->assertTrue($cache->set($key, $specobject));
     $result = $cache->get($key);
     $this->assertInstanceOf('cache_phpunit_dummy_object', $result);
     $this->assertEquals('red_ptc_wfc', $result->property1);
     $this->assertEquals('blue_ptc_wfc', $result->property2);
     // Test array of objects.
     $specobject = new cache_phpunit_dummy_object('red', 'blue');
     $data = new cacheable_object_array(array(clone $specobject, clone $specobject, clone $specobject));
     $this->assertTrue($cache->set($key, $data));
     $result = $cache->get($key);
     $this->assertInstanceOf('cacheable_object_array', $result);
     $this->assertCount(3, $data);
     foreach ($result as $item) {
         $this->assertInstanceOf('cache_phpunit_dummy_object', $item);
         $this->assertEquals('red_ptc_wfc', $item->property1);
         $this->assertEquals('blue_ptc_wfc', $item->property2);
     }
     // Test set many.
     $cache->set_many(array('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('key1' => array(1, 2, 3), 'key2' => array(3, 2, 1)));
     $this->assertInternalType('array', $cache->get('key1'));
     $this->assertInternalType('array', $cache->get('key2'));
     $this->assertCount(3, $cache->get('key1'));
     $this->assertCount(3, $cache->get('key2'));
     $this->assertInternalType('array', $cache->get_many(array('key1', 'key2')));
     $this->assertCount(2, $cache->get_many(array('key1', 'key2')));
     $this->assertEquals(2, $cache->delete_many(array('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->assertFalse($cache->get('key1'));
     $this->assertFalse($cache->get('key2'));
     $this->assertFalse($cache->get('key3'));
     // Quick reference test.
     $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->assertEquals('value', $var->key);
     $ref->key = 'eulav';
     $var = $cache->get('obj');
     $this->assertInstanceOf('stdClass', $var);
     $this->assertEquals('value', $var->key);
     $this->assertTrue($cache->delete('obj'));
     // Deep reference test.
     $obj1 = new stdClass();
     $obj1->key = 'value';
     $obj2 = new stdClass();
     $obj2->key = 'test';
     $obj3 = new stdClass();
     $obj3->key = 'pork';
     $obj1->subobj =& $obj2;
     $obj2->subobj =& $obj3;
     $this->assertTrue($cache->set('obj', $obj1));
     $obj1->key = 'eulav';
     $obj2->key = 'tset';
     $obj3->key = 'krop';
     $var = $cache->get('obj');
     $this->assertInstanceOf('stdClass', $var);
     $this->assertEquals('value', $var->key);
     $this->assertInstanceOf('stdClass', $var->subobj);
     $this->assertEquals('test', $var->subobj->key);
     $this->assertInstanceOf('stdClass', $var->subobj->subobj);
     $this->assertEquals('pork', $var->subobj->subobj->key);
     $this->assertTrue($cache->delete('obj'));
     // Death reference test... basicaly we don't want this to die.
     $obj = new stdClass();
     $obj->key = 'value';
     $obj->self =& $obj;
     $this->assertTrue($cache->set('obj', $obj));
     $var = $cache->get('obj');
     $this->assertInstanceOf('stdClass', $var);
     $this->assertEquals('value', $var->key);
     // Reference test after retrieve.
     $obj = new stdClass();
     $obj->key = 'value';
     $this->assertTrue($cache->set('obj', $obj));
     $var1 = $cache->get('obj');
     $this->assertInstanceOf('stdClass', $var1);
     $this->assertEquals('value', $var1->key);
     $var1->key = 'eulav';
     $this->assertEquals('eulav', $var1->key);
     $var2 = $cache->get('obj');
     $this->assertInstanceOf('stdClass', $var2);
     $this->assertEquals('value', $var2->key);
     $this->assertTrue($cache->delete('obj'));
     // Test strictness exceptions.
     try {
         $cache->get('exception', MUST_EXIST);
         $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);
         $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);
         $this->fail('Exception expected from cache::get_many using MUST_EXIST');
     } catch (Exception $e) {
         $this->assertTrue(true);
     }
 }