first commit
This commit is contained in:
28
modules/productcomments/vendor/doctrine/cache/tests/Doctrine/Tests/Common/Cache/ApcCacheTest.php
vendored
Normal file
28
modules/productcomments/vendor/doctrine/cache/tests/Doctrine/Tests/Common/Cache/ApcCacheTest.php
vendored
Normal file
@@ -0,0 +1,28 @@
|
||||
<?php
|
||||
|
||||
namespace Doctrine\Tests\Common\Cache;
|
||||
|
||||
use Doctrine\Common\Cache\ApcCache;
|
||||
|
||||
/**
|
||||
* @requires extension apc
|
||||
*/
|
||||
class ApcCacheTest extends CacheTest
|
||||
{
|
||||
protected function setUp()
|
||||
{
|
||||
if (!ini_get('apc.enable_cli')) {
|
||||
$this->markTestSkipped('APC must be enabled for the CLI with the ini setting apc.enable_cli=1');
|
||||
}
|
||||
}
|
||||
|
||||
protected function _getCacheDriver()
|
||||
{
|
||||
return new ApcCache();
|
||||
}
|
||||
|
||||
public function testLifetime()
|
||||
{
|
||||
$this->markTestSkipped('The APC cache TTL is not working in a single process/request. See https://bugs.php.net/bug.php?id=58084');
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,28 @@
|
||||
<?php
|
||||
|
||||
namespace Doctrine\Tests\Common\Cache;
|
||||
|
||||
use Doctrine\Common\Cache\ApcuCache;
|
||||
|
||||
/**
|
||||
* @requires extension apcu
|
||||
*/
|
||||
class ApcuCacheTest extends CacheTest
|
||||
{
|
||||
protected function setUp()
|
||||
{
|
||||
if (!ini_get('apc.enable_cli')) {
|
||||
$this->markTestSkipped('APC must be enabled for the CLI with the ini setting apc.enable_cli=1');
|
||||
}
|
||||
}
|
||||
|
||||
protected function _getCacheDriver()
|
||||
{
|
||||
return new ApcuCache();
|
||||
}
|
||||
|
||||
public function testLifetime()
|
||||
{
|
||||
$this->markTestSkipped('The APC cache TTL is not working in a single process/request. See https://bugs.php.net/bug.php?id=58084');
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,52 @@
|
||||
<?php
|
||||
|
||||
namespace Doctrine\Tests\Common\Cache;
|
||||
|
||||
use Doctrine\Common\Cache\ArrayCache;
|
||||
use Doctrine\Common\Cache\Cache;
|
||||
|
||||
class ArrayCacheTest extends CacheTest
|
||||
{
|
||||
protected function _getCacheDriver()
|
||||
{
|
||||
return new ArrayCache();
|
||||
}
|
||||
|
||||
public function testGetStats()
|
||||
{
|
||||
$cache = $this->_getCacheDriver();
|
||||
$cache->fetch('test1');
|
||||
$cache->fetch('test2');
|
||||
$cache->fetch('test3');
|
||||
|
||||
$cache->save('test1', 123);
|
||||
$cache->save('test2', 123);
|
||||
|
||||
$cache->fetch('test1');
|
||||
$cache->fetch('test2');
|
||||
$cache->fetch('test3');
|
||||
|
||||
$stats = $cache->getStats();
|
||||
$this->assertEquals(2, $stats[Cache::STATS_HITS]);
|
||||
$this->assertEquals(5, $stats[Cache::STATS_MISSES]); // +1 for internal call to DoctrineNamespaceCacheKey
|
||||
$this->assertNotNull($stats[Cache::STATS_UPTIME]);
|
||||
$this->assertNull($stats[Cache::STATS_MEMORY_USAGE]);
|
||||
$this->assertNull($stats[Cache::STATS_MEMORY_AVAILABLE]);
|
||||
|
||||
$cache->delete('test1');
|
||||
$cache->delete('test2');
|
||||
|
||||
$cache->fetch('test1');
|
||||
$cache->fetch('test2');
|
||||
$cache->fetch('test3');
|
||||
|
||||
$stats = $cache->getStats();
|
||||
$this->assertEquals(2, $stats[Cache::STATS_HITS]);
|
||||
$this->assertEquals(8, $stats[Cache::STATS_MISSES]); // +1 for internal call to DoctrineNamespaceCacheKey
|
||||
}
|
||||
|
||||
protected function isSharedStorage()
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,155 @@
|
||||
<?php
|
||||
|
||||
namespace Doctrine\Tests\Common\Cache;
|
||||
|
||||
use Doctrine\Common\Cache\FileCache;
|
||||
use RecursiveDirectoryIterator;
|
||||
use RecursiveIteratorIterator;
|
||||
|
||||
abstract class BaseFileCacheTest extends CacheTest
|
||||
{
|
||||
protected $directory;
|
||||
|
||||
protected function setUp()
|
||||
{
|
||||
do {
|
||||
$this->directory = sys_get_temp_dir() . '/doctrine_cache_'. uniqid();
|
||||
} while (file_exists($this->directory));
|
||||
}
|
||||
|
||||
protected function tearDown()
|
||||
{
|
||||
if ( ! is_dir($this->directory)) {
|
||||
return;
|
||||
}
|
||||
|
||||
$iterator = new RecursiveDirectoryIterator($this->directory);
|
||||
|
||||
foreach (new RecursiveIteratorIterator($iterator, RecursiveIteratorIterator::CHILD_FIRST) as $file) {
|
||||
if ($file->isFile()) {
|
||||
@unlink($file->getRealPath());
|
||||
} elseif ($file->isDir()) {
|
||||
@rmdir($file->getRealPath());
|
||||
}
|
||||
}
|
||||
|
||||
@rmdir($this->directory);
|
||||
}
|
||||
|
||||
public function testFlushAllRemovesBalancingDirectories()
|
||||
{
|
||||
$cache = $this->_getCacheDriver();
|
||||
|
||||
$this->assertTrue($cache->save('key1', 1));
|
||||
$this->assertTrue($cache->save('key2', 2));
|
||||
$this->assertTrue($cache->flushAll());
|
||||
|
||||
$iterator = new \RecursiveIteratorIterator(new \RecursiveDirectoryIterator($this->directory, \FilesystemIterator::SKIP_DOTS), \RecursiveIteratorIterator::CHILD_FIRST);
|
||||
|
||||
$this->assertCount(0, $iterator);
|
||||
}
|
||||
|
||||
protected function isSharedStorage()
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
public function getPathLengthsToTest()
|
||||
{
|
||||
// Windows officially supports 260 bytes including null terminator
|
||||
// 258 bytes available to use due to php bug #70943
|
||||
// Windows officially supports 260 bytes including null terminator
|
||||
// 259 characters is too large due to PHP bug (https://bugs.php.net/bug.php?id=70943)
|
||||
// 260 characters is too large - null terminator is included in allowable length
|
||||
return array(
|
||||
array(257, false),
|
||||
array(258, false),
|
||||
array(259, true),
|
||||
array(260, true)
|
||||
);
|
||||
}
|
||||
|
||||
private static function getBasePathForWindowsPathLengthTests($pathLength)
|
||||
{
|
||||
return FileCacheTest::getBasePathForWindowsPathLengthTests($pathLength);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param int $length
|
||||
* @param string $basePath
|
||||
*
|
||||
* @return array
|
||||
*/
|
||||
private static function getKeyAndPathFittingLength($length, $basePath)
|
||||
{
|
||||
$baseDirLength = strlen($basePath);
|
||||
$extensionLength = strlen('.doctrine.cache');
|
||||
$directoryLength = strlen(DIRECTORY_SEPARATOR . 'aa' . DIRECTORY_SEPARATOR);
|
||||
$namespaceAndBracketLength = strlen(bin2hex("[][1]"));
|
||||
$keyLength = $length
|
||||
- ($baseDirLength
|
||||
+ $extensionLength
|
||||
+ $directoryLength
|
||||
+ $namespaceAndBracketLength);
|
||||
|
||||
$key = str_repeat('a', floor($keyLength / 2));
|
||||
$namespacedKey = '[' . $key . '][1]';
|
||||
|
||||
$keyHash = hash('sha256', $namespacedKey);
|
||||
|
||||
$keyPath = $basePath
|
||||
. DIRECTORY_SEPARATOR
|
||||
. substr($keyHash, 0, 2)
|
||||
. DIRECTORY_SEPARATOR
|
||||
. bin2hex($namespacedKey)
|
||||
. '.doctrine.cache';
|
||||
|
||||
$hashedKeyPath = $basePath
|
||||
. DIRECTORY_SEPARATOR
|
||||
. substr($keyHash, 0, 2)
|
||||
. DIRECTORY_SEPARATOR
|
||||
. '_' . $keyHash
|
||||
. '.doctrine.cache';
|
||||
|
||||
return array($key, $keyPath, $hashedKeyPath);
|
||||
}
|
||||
|
||||
/**
|
||||
* @dataProvider getPathLengthsToTest
|
||||
*
|
||||
* @param int $length
|
||||
* @param bool $pathShouldBeHashed
|
||||
*/
|
||||
public function testWindowsPathLengthLimitIsCorrectlyHandled($length, $pathShouldBeHashed)
|
||||
{
|
||||
$this->directory = self::getBasePathForWindowsPathLengthTests($length);
|
||||
|
||||
list($key, $keyPath, $hashedKeyPath) = self::getKeyAndPathFittingLength($length, $this->directory);
|
||||
|
||||
$this->assertEquals($length, strlen($keyPath), 'Unhashed path should be of correct length.');
|
||||
|
||||
$cacheClass = get_class($this->_getCacheDriver());
|
||||
/* @var $cache \Doctrine\Common\Cache\FileCache */
|
||||
$cache = new $cacheClass($this->directory, '.doctrine.cache');
|
||||
|
||||
// Trick it into thinking this is windows.
|
||||
$reflClass = new \ReflectionClass(FileCache::class);
|
||||
$reflProp = $reflClass->getProperty('isRunningOnWindows');
|
||||
$reflProp->setAccessible(true);
|
||||
$reflProp->setValue($cache, true);
|
||||
$reflProp->setAccessible(false);
|
||||
|
||||
$value = uniqid('value', true);
|
||||
|
||||
$cache->save($key, $value);
|
||||
$this->assertEquals($value, $cache->fetch($key));
|
||||
|
||||
if ($pathShouldBeHashed) {
|
||||
$this->assertFileExists($hashedKeyPath, 'Path generated for key should be hashed.');
|
||||
unlink($hashedKeyPath);
|
||||
} else {
|
||||
$this->assertFileExists($keyPath, 'Path generated for key should not be hashed.');
|
||||
unlink($keyPath);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,103 @@
|
||||
<?php
|
||||
|
||||
namespace Doctrine\Tests\Common\Cache;
|
||||
|
||||
class CacheProviderTest extends \Doctrine\Tests\DoctrineTestCase
|
||||
{
|
||||
public function testFetchMultiWillFilterNonRequestedKeys()
|
||||
{
|
||||
/* @var $cache \Doctrine\Common\Cache\CacheProvider|\PHPUnit_Framework_MockObject_MockObject */
|
||||
$cache = $this->getMockForAbstractClass(
|
||||
'Doctrine\Common\Cache\CacheProvider',
|
||||
array(),
|
||||
'',
|
||||
true,
|
||||
true,
|
||||
true,
|
||||
array('doFetchMultiple')
|
||||
);
|
||||
|
||||
$cache
|
||||
->expects($this->once())
|
||||
->method('doFetchMultiple')
|
||||
->will($this->returnValue(array(
|
||||
'[foo][1]' => 'bar',
|
||||
'[bar][1]' => 'baz',
|
||||
'[baz][1]' => 'tab',
|
||||
)));
|
||||
|
||||
$this->assertEquals(
|
||||
array('foo' => 'bar', 'bar' => 'baz'),
|
||||
$cache->fetchMultiple(array('foo', 'bar'))
|
||||
);
|
||||
}
|
||||
|
||||
public function testFailedDeleteAllDoesNotChangeNamespaceVersion()
|
||||
{
|
||||
/* @var $cache \Doctrine\Common\Cache\CacheProvider|\PHPUnit_Framework_MockObject_MockObject */
|
||||
$cache = $this->getMockForAbstractClass(
|
||||
'Doctrine\Common\Cache\CacheProvider',
|
||||
array(),
|
||||
'',
|
||||
true,
|
||||
true,
|
||||
true,
|
||||
array('doFetch', 'doSave', 'doContains')
|
||||
);
|
||||
|
||||
$cache
|
||||
->expects($this->once())
|
||||
->method('doFetch')
|
||||
->with('DoctrineNamespaceCacheKey[]')
|
||||
->will($this->returnValue(false));
|
||||
|
||||
// doSave is only called once from deleteAll as we do not need to persist the default version in getNamespaceVersion()
|
||||
$cache
|
||||
->expects($this->once())
|
||||
->method('doSave')
|
||||
->with('DoctrineNamespaceCacheKey[]')
|
||||
->will($this->returnValue(false));
|
||||
|
||||
// After a failed deleteAll() the local namespace version is not increased (still 1). Otherwise all data written afterwards
|
||||
// would be lost outside the current instance.
|
||||
$cache
|
||||
->expects($this->once())
|
||||
->method('doContains')
|
||||
->with('[key][1]')
|
||||
->will($this->returnValue(true));
|
||||
|
||||
$this->assertFalse($cache->deleteAll(), 'deleteAll() returns false when saving the namespace version fails');
|
||||
$cache->contains('key');
|
||||
}
|
||||
|
||||
public function testSaveMultipleNoFail()
|
||||
{
|
||||
/* @var $cache \Doctrine\Common\Cache\CacheProvider|\PHPUnit_Framework_MockObject_MockObject */
|
||||
$cache = $this->getMockForAbstractClass(
|
||||
'Doctrine\Common\Cache\CacheProvider',
|
||||
array(),
|
||||
'',
|
||||
true,
|
||||
true,
|
||||
true,
|
||||
array('doSave')
|
||||
);
|
||||
|
||||
$cache
|
||||
->expects($this->at(1))
|
||||
->method('doSave')
|
||||
->with('[kerr][1]', 'verr', 0)
|
||||
->will($this->returnValue(false));
|
||||
|
||||
$cache
|
||||
->expects($this->at(2))
|
||||
->method('doSave')
|
||||
->with('[kok][1]', 'vok', 0)
|
||||
->will($this->returnValue(true));
|
||||
|
||||
$cache->saveMultiple(array(
|
||||
'kerr' => 'verr',
|
||||
'kok' => 'vok',
|
||||
));
|
||||
}
|
||||
}
|
||||
473
modules/productcomments/vendor/doctrine/cache/tests/Doctrine/Tests/Common/Cache/CacheTest.php
vendored
Normal file
473
modules/productcomments/vendor/doctrine/cache/tests/Doctrine/Tests/Common/Cache/CacheTest.php
vendored
Normal file
@@ -0,0 +1,473 @@
|
||||
<?php
|
||||
|
||||
namespace Doctrine\Tests\Common\Cache;
|
||||
|
||||
use Doctrine\Common\Cache\Cache;
|
||||
use ArrayObject;
|
||||
|
||||
abstract class CacheTest extends \Doctrine\Tests\DoctrineTestCase
|
||||
{
|
||||
/**
|
||||
* @dataProvider provideDataToCache
|
||||
*/
|
||||
public function testSetContainsFetchDelete($value)
|
||||
{
|
||||
$cache = $this->_getCacheDriver();
|
||||
|
||||
// Test saving a value, checking if it exists, and fetching it back
|
||||
$this->assertTrue($cache->save('key', $value));
|
||||
$this->assertTrue($cache->contains('key'));
|
||||
if (is_object($value)) {
|
||||
$this->assertEquals($value, $cache->fetch('key'), 'Objects retrieved from the cache must be equal but not necessarily the same reference');
|
||||
} else {
|
||||
$this->assertSame($value, $cache->fetch('key'), 'Scalar and array data retrieved from the cache must be the same as the original, e.g. same type');
|
||||
}
|
||||
|
||||
// Test deleting a value
|
||||
$this->assertTrue($cache->delete('key'));
|
||||
$this->assertFalse($cache->contains('key'));
|
||||
$this->assertFalse($cache->fetch('key'));
|
||||
}
|
||||
|
||||
/**
|
||||
* @dataProvider provideDataToCache
|
||||
*/
|
||||
public function testUpdateExistingEntry($value)
|
||||
{
|
||||
$cache = $this->_getCacheDriver();
|
||||
|
||||
$this->assertTrue($cache->save('key', 'old-value'));
|
||||
$this->assertTrue($cache->contains('key'));
|
||||
|
||||
$this->assertTrue($cache->save('key', $value));
|
||||
$this->assertTrue($cache->contains('key'));
|
||||
if (is_object($value)) {
|
||||
$this->assertEquals($value, $cache->fetch('key'), 'Objects retrieved from the cache must be equal but not necessarily the same reference');
|
||||
} else {
|
||||
$this->assertSame($value, $cache->fetch('key'), 'Scalar and array data retrieved from the cache must be the same as the original, e.g. same type');
|
||||
}
|
||||
}
|
||||
|
||||
public function testCacheKeyIsCaseSensitive()
|
||||
{
|
||||
$cache = $this->_getCacheDriver();
|
||||
|
||||
$this->assertTrue($cache->save('key', 'value'));
|
||||
$this->assertTrue($cache->contains('key'));
|
||||
$this->assertSame('value', $cache->fetch('key'));
|
||||
|
||||
$this->assertFalse($cache->contains('KEY'));
|
||||
$this->assertFalse($cache->fetch('KEY'));
|
||||
|
||||
$cache->delete('KEY');
|
||||
$this->assertTrue($cache->contains('key', 'Deleting cache item with different case must not affect other cache item'));
|
||||
}
|
||||
|
||||
public function testFetchMultiple()
|
||||
{
|
||||
$cache = $this->_getCacheDriver();
|
||||
$values = $this->provideDataToCache();
|
||||
$saved = array();
|
||||
|
||||
foreach ($values as $key => $value) {
|
||||
$cache->save($key, $value[0]);
|
||||
|
||||
$saved[$key] = $value[0];
|
||||
}
|
||||
|
||||
$keys = array_keys($saved);
|
||||
|
||||
$this->assertEquals(
|
||||
$saved,
|
||||
$cache->fetchMultiple($keys),
|
||||
'Testing fetchMultiple with different data types'
|
||||
);
|
||||
$this->assertEquals(
|
||||
array_slice($saved, 0, 1),
|
||||
$cache->fetchMultiple(array_slice($keys, 0, 1)),
|
||||
'Testing fetchMultiple with a single key'
|
||||
);
|
||||
|
||||
$keysWithNonExisting = array();
|
||||
$keysWithNonExisting[] = 'non_existing1';
|
||||
$keysWithNonExisting[] = $keys[0];
|
||||
$keysWithNonExisting[] = 'non_existing2';
|
||||
$keysWithNonExisting[] = $keys[1];
|
||||
$keysWithNonExisting[] = 'non_existing3';
|
||||
|
||||
$this->assertEquals(
|
||||
array_slice($saved, 0, 2),
|
||||
$cache->fetchMultiple($keysWithNonExisting),
|
||||
'Testing fetchMultiple with a subset of keys and mixed with non-existing ones'
|
||||
);
|
||||
}
|
||||
|
||||
public function testFetchMultipleWithNoKeys()
|
||||
{
|
||||
$cache = $this->_getCacheDriver();
|
||||
|
||||
$this->assertSame(array(), $cache->fetchMultiple(array()));
|
||||
}
|
||||
|
||||
public function testSaveMultiple()
|
||||
{
|
||||
$cache = $this->_getCacheDriver();
|
||||
$cache->deleteAll();
|
||||
|
||||
$data = array_map(function ($value) {
|
||||
return $value[0];
|
||||
}, $this->provideDataToCache());
|
||||
|
||||
$this->assertTrue($cache->saveMultiple($data));
|
||||
|
||||
$keys = array_keys($data);
|
||||
|
||||
$this->assertEquals($data, $cache->fetchMultiple($keys));
|
||||
}
|
||||
|
||||
public function provideDataToCache()
|
||||
{
|
||||
$obj = new \stdClass();
|
||||
$obj->foo = 'bar';
|
||||
$obj2 = new \stdClass();
|
||||
$obj2->bar = 'foo';
|
||||
$obj2->obj = $obj;
|
||||
$obj->obj2 = $obj2;
|
||||
|
||||
return array(
|
||||
'array' => array(array('one', 2, 3.01)),
|
||||
'string' => array('value'),
|
||||
'string_invalid_utf8' => array("\xc3\x28"),
|
||||
'string_null_byte' => array('with'."\0".'null char'),
|
||||
'integer' => array(1),
|
||||
'float' => array(1.5),
|
||||
'object' => array(new ArrayObject(array('one', 2, 3.01))),
|
||||
'object_recursive' => array($obj),
|
||||
'true' => array(true),
|
||||
// the following are considered FALSE in boolean context, but caches should still recognize their existence
|
||||
'null' => array(null),
|
||||
'false' => array(false),
|
||||
'array_empty' => array(array()),
|
||||
'string_zero' => array('0'),
|
||||
'integer_zero' => array(0),
|
||||
'float_zero' => array(0.0),
|
||||
'string_empty' => array(''),
|
||||
);
|
||||
}
|
||||
|
||||
public function testDeleteIsSuccessfulWhenKeyDoesNotExist()
|
||||
{
|
||||
$cache = $this->_getCacheDriver();
|
||||
|
||||
$cache->delete('key');
|
||||
$this->assertFalse($cache->contains('key'));
|
||||
$this->assertTrue($cache->delete('key'));
|
||||
}
|
||||
|
||||
public function testDeleteAll()
|
||||
{
|
||||
$cache = $this->_getCacheDriver();
|
||||
|
||||
$this->assertTrue($cache->save('key1', 1));
|
||||
$this->assertTrue($cache->save('key2', 2));
|
||||
$this->assertTrue($cache->deleteAll());
|
||||
$this->assertFalse($cache->contains('key1'));
|
||||
$this->assertFalse($cache->contains('key2'));
|
||||
}
|
||||
|
||||
/**
|
||||
* @dataProvider provideCacheIds
|
||||
*/
|
||||
public function testCanHandleSpecialCacheIds($id)
|
||||
{
|
||||
$cache = $this->_getCacheDriver();
|
||||
|
||||
$this->assertTrue($cache->save($id, 'value'));
|
||||
$this->assertTrue($cache->contains($id));
|
||||
$this->assertEquals('value', $cache->fetch($id));
|
||||
|
||||
$this->assertTrue($cache->delete($id));
|
||||
$this->assertFalse($cache->contains($id));
|
||||
$this->assertFalse($cache->fetch($id));
|
||||
}
|
||||
|
||||
public function testNoCacheIdCollisions()
|
||||
{
|
||||
$cache = $this->_getCacheDriver();
|
||||
|
||||
$ids = $this->provideCacheIds();
|
||||
|
||||
// fill cache with each id having a different value
|
||||
foreach ($ids as $index => $id) {
|
||||
$cache->save($id[0], $index);
|
||||
}
|
||||
|
||||
// then check value of each cache id
|
||||
foreach ($ids as $index => $id) {
|
||||
$value = $cache->fetch($id[0]);
|
||||
$this->assertNotFalse($value, sprintf('Failed to retrieve data for cache id "%s".', $id[0]));
|
||||
if ($index !== $value) {
|
||||
$this->fail(sprintf('Cache id "%s" collides with id "%s".', $id[0], $ids[$value][0]));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns cache ids with special characters that should still work.
|
||||
*
|
||||
* For example, the characters :\/<>"*?| are not valid in Windows filenames. So they must be encoded properly.
|
||||
* Each cache id should be considered different from the others.
|
||||
*
|
||||
* @return array
|
||||
*/
|
||||
public function provideCacheIds()
|
||||
{
|
||||
return array(
|
||||
array(':'),
|
||||
array('\\'),
|
||||
array('/'),
|
||||
array('<'),
|
||||
array('>'),
|
||||
array('"'),
|
||||
array('*'),
|
||||
array('?'),
|
||||
array('|'),
|
||||
array('['),
|
||||
array(']'),
|
||||
array('ä'),
|
||||
array('a'),
|
||||
array('é'),
|
||||
array('e'),
|
||||
array('.'), // directory traversal
|
||||
array('..'), // directory traversal
|
||||
array('-'),
|
||||
array('_'),
|
||||
array('$'),
|
||||
array('%'),
|
||||
array(' '),
|
||||
array("\0"),
|
||||
array(''),
|
||||
array(str_repeat('a', 300)), // long key
|
||||
array(str_repeat('a', 113)),
|
||||
);
|
||||
}
|
||||
|
||||
public function testLifetime()
|
||||
{
|
||||
$cache = $this->_getCacheDriver();
|
||||
$cache->save('expire', 'value', 1);
|
||||
$this->assertTrue($cache->contains('expire'), 'Data should not be expired yet');
|
||||
// @TODO should more TTL-based tests pop up, so then we should mock the `time` API instead
|
||||
sleep(2);
|
||||
$this->assertFalse($cache->contains('expire'), 'Data should be expired');
|
||||
}
|
||||
|
||||
public function testNoExpire()
|
||||
{
|
||||
$cache = $this->_getCacheDriver();
|
||||
$cache->save('noexpire', 'value', 0);
|
||||
// @TODO should more TTL-based tests pop up, so then we should mock the `time` API instead
|
||||
sleep(1);
|
||||
$this->assertTrue($cache->contains('noexpire'), 'Data with lifetime of zero should not expire');
|
||||
}
|
||||
|
||||
public function testLongLifetime()
|
||||
{
|
||||
$cache = $this->_getCacheDriver();
|
||||
$cache->save('longlifetime', 'value', 30 * 24 * 3600 + 1);
|
||||
$this->assertTrue($cache->contains('longlifetime'), 'Data with lifetime > 30 days should be accepted');
|
||||
}
|
||||
|
||||
public function testDeleteAllAndNamespaceVersioningBetweenCaches()
|
||||
{
|
||||
if ( ! $this->isSharedStorage()) {
|
||||
$this->markTestSkipped('The cache storage needs to be shared.');
|
||||
}
|
||||
|
||||
$cache1 = $this->_getCacheDriver();
|
||||
$cache2 = $this->_getCacheDriver();
|
||||
|
||||
$this->assertTrue($cache1->save('key1', 1));
|
||||
$this->assertTrue($cache2->save('key2', 2));
|
||||
|
||||
/* Both providers are initialized with the same namespace version, so
|
||||
* they can see entries set by each other.
|
||||
*/
|
||||
$this->assertTrue($cache1->contains('key1'));
|
||||
$this->assertTrue($cache1->contains('key2'));
|
||||
$this->assertTrue($cache2->contains('key1'));
|
||||
$this->assertTrue($cache2->contains('key2'));
|
||||
|
||||
/* Deleting all entries through one provider will only increment the
|
||||
* namespace version on that object (and in the cache itself, which new
|
||||
* instances will use to initialize). The second provider will retain
|
||||
* its original version and still see stale data.
|
||||
*/
|
||||
$this->assertTrue($cache1->deleteAll());
|
||||
$this->assertFalse($cache1->contains('key1'));
|
||||
$this->assertFalse($cache1->contains('key2'));
|
||||
$this->assertTrue($cache2->contains('key1'));
|
||||
$this->assertTrue($cache2->contains('key2'));
|
||||
|
||||
/* A new cache provider should not see the deleted entries, since its
|
||||
* namespace version will be initialized.
|
||||
*/
|
||||
$cache3 = $this->_getCacheDriver();
|
||||
$this->assertFalse($cache3->contains('key1'));
|
||||
$this->assertFalse($cache3->contains('key2'));
|
||||
}
|
||||
|
||||
public function testFlushAll()
|
||||
{
|
||||
$cache = $this->_getCacheDriver();
|
||||
|
||||
$this->assertTrue($cache->save('key1', 1));
|
||||
$this->assertTrue($cache->save('key2', 2));
|
||||
$this->assertTrue($cache->flushAll());
|
||||
$this->assertFalse($cache->contains('key1'));
|
||||
$this->assertFalse($cache->contains('key2'));
|
||||
}
|
||||
|
||||
public function testFlushAllAndNamespaceVersioningBetweenCaches()
|
||||
{
|
||||
if ( ! $this->isSharedStorage()) {
|
||||
$this->markTestSkipped('The cache storage needs to be shared.');
|
||||
}
|
||||
|
||||
$cache1 = $this->_getCacheDriver();
|
||||
$cache2 = $this->_getCacheDriver();
|
||||
|
||||
/* Deleting all elements from the first provider should increment its
|
||||
* namespace version before saving the first entry.
|
||||
*/
|
||||
$cache1->deleteAll();
|
||||
$this->assertTrue($cache1->save('key1', 1));
|
||||
|
||||
/* The second provider will be initialized with the same namespace
|
||||
* version upon its first save operation.
|
||||
*/
|
||||
$this->assertTrue($cache2->save('key2', 2));
|
||||
|
||||
/* Both providers have the same namespace version and can see entries
|
||||
* set by each other.
|
||||
*/
|
||||
$this->assertTrue($cache1->contains('key1'));
|
||||
$this->assertTrue($cache1->contains('key2'));
|
||||
$this->assertTrue($cache2->contains('key1'));
|
||||
$this->assertTrue($cache2->contains('key2'));
|
||||
|
||||
/* Flushing all entries through one cache will remove all entries from
|
||||
* the cache but leave their namespace version as-is.
|
||||
*/
|
||||
$this->assertTrue($cache1->flushAll());
|
||||
$this->assertFalse($cache1->contains('key1'));
|
||||
$this->assertFalse($cache1->contains('key2'));
|
||||
$this->assertFalse($cache2->contains('key1'));
|
||||
$this->assertFalse($cache2->contains('key2'));
|
||||
|
||||
/* Inserting a new entry will use the same, incremented namespace
|
||||
* version, and it will be visible to both providers.
|
||||
*/
|
||||
$this->assertTrue($cache1->save('key1', 1));
|
||||
$this->assertTrue($cache1->contains('key1'));
|
||||
$this->assertTrue($cache2->contains('key1'));
|
||||
|
||||
/* A new cache provider will be initialized with the original namespace
|
||||
* version and not share any visibility with the first two providers.
|
||||
*/
|
||||
$cache3 = $this->_getCacheDriver();
|
||||
$this->assertFalse($cache3->contains('key1'));
|
||||
$this->assertFalse($cache3->contains('key2'));
|
||||
$this->assertTrue($cache3->save('key3', 3));
|
||||
$this->assertTrue($cache3->contains('key3'));
|
||||
}
|
||||
|
||||
public function testNamespace()
|
||||
{
|
||||
$cache = $this->_getCacheDriver();
|
||||
|
||||
$cache->setNamespace('ns1_');
|
||||
|
||||
$this->assertTrue($cache->save('key1', 1));
|
||||
$this->assertTrue($cache->contains('key1'));
|
||||
|
||||
$cache->setNamespace('ns2_');
|
||||
|
||||
$this->assertFalse($cache->contains('key1'));
|
||||
}
|
||||
|
||||
public function testDeleteAllNamespace()
|
||||
{
|
||||
$cache = $this->_getCacheDriver();
|
||||
|
||||
$cache->setNamespace('ns1');
|
||||
$this->assertFalse($cache->contains('key1'));
|
||||
$cache->save('key1', 'test');
|
||||
$this->assertTrue($cache->contains('key1'));
|
||||
|
||||
$cache->setNamespace('ns2');
|
||||
$this->assertFalse($cache->contains('key1'));
|
||||
$cache->save('key1', 'test');
|
||||
$this->assertTrue($cache->contains('key1'));
|
||||
|
||||
$cache->setNamespace('ns1');
|
||||
$this->assertTrue($cache->contains('key1'));
|
||||
$cache->deleteAll();
|
||||
$this->assertFalse($cache->contains('key1'));
|
||||
|
||||
$cache->setNamespace('ns2');
|
||||
$this->assertTrue($cache->contains('key1'));
|
||||
$cache->deleteAll();
|
||||
$this->assertFalse($cache->contains('key1'));
|
||||
}
|
||||
|
||||
/**
|
||||
* @group DCOM-43
|
||||
*/
|
||||
public function testGetStats()
|
||||
{
|
||||
$cache = $this->_getCacheDriver();
|
||||
$stats = $cache->getStats();
|
||||
|
||||
$this->assertArrayHasKey(Cache::STATS_HITS, $stats);
|
||||
$this->assertArrayHasKey(Cache::STATS_MISSES, $stats);
|
||||
$this->assertArrayHasKey(Cache::STATS_UPTIME, $stats);
|
||||
$this->assertArrayHasKey(Cache::STATS_MEMORY_USAGE, $stats);
|
||||
$this->assertArrayHasKey(Cache::STATS_MEMORY_AVAILABLE, $stats);
|
||||
}
|
||||
|
||||
public function testSaveReturnsTrueWithAndWithoutTTlSet()
|
||||
{
|
||||
$cache = $this->_getCacheDriver();
|
||||
$cache->deleteAll();
|
||||
$this->assertTrue($cache->save('without_ttl', 'without_ttl'));
|
||||
$this->assertTrue($cache->save('with_ttl', 'with_ttl', 3600));
|
||||
}
|
||||
|
||||
public function testValueThatIsFalseBooleanIsProperlyRetrieved()
|
||||
{
|
||||
$cache = $this->_getCacheDriver();
|
||||
$cache->deleteAll();
|
||||
|
||||
$this->assertTrue($cache->save('key1', false));
|
||||
$this->assertTrue($cache->contains('key1'));
|
||||
$this->assertFalse($cache->fetch('key1'));
|
||||
}
|
||||
|
||||
/**
|
||||
* Return whether multiple cache providers share the same storage.
|
||||
*
|
||||
* This is used for skipping certain tests for shared storage behavior.
|
||||
*
|
||||
* @return bool
|
||||
*/
|
||||
protected function isSharedStorage()
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return \Doctrine\Common\Cache\CacheProvider
|
||||
*/
|
||||
abstract protected function _getCacheDriver();
|
||||
}
|
||||
@@ -0,0 +1,99 @@
|
||||
<?php
|
||||
|
||||
namespace Doctrine\Tests\Common\Cache;
|
||||
|
||||
use Doctrine\Common\Cache\ApcCache;
|
||||
use Doctrine\Common\Cache\ArrayCache;
|
||||
use Doctrine\Common\Cache\ChainCache;
|
||||
|
||||
class ChainCacheTest extends CacheTest
|
||||
{
|
||||
protected function _getCacheDriver()
|
||||
{
|
||||
return new ChainCache(array(new ArrayCache()));
|
||||
}
|
||||
|
||||
public function testLifetime()
|
||||
{
|
||||
$this->markTestSkipped('The ChainCache test uses ArrayCache which does not implement TTL currently.');
|
||||
}
|
||||
|
||||
public function testGetStats()
|
||||
{
|
||||
$cache = $this->_getCacheDriver();
|
||||
$stats = $cache->getStats();
|
||||
|
||||
$this->assertInternalType('array', $stats);
|
||||
}
|
||||
|
||||
public function testOnlyFetchFirstOne()
|
||||
{
|
||||
$cache1 = new ArrayCache();
|
||||
$cache2 = $this->getMockForAbstractClass('Doctrine\Common\Cache\CacheProvider');
|
||||
|
||||
$cache2->expects($this->never())->method('doFetch');
|
||||
|
||||
$chainCache = new ChainCache(array($cache1, $cache2));
|
||||
$chainCache->save('id', 'bar');
|
||||
|
||||
$this->assertEquals('bar', $chainCache->fetch('id'));
|
||||
}
|
||||
|
||||
public function testFetchPropagateToFastestCache()
|
||||
{
|
||||
$cache1 = new ArrayCache();
|
||||
$cache2 = new ArrayCache();
|
||||
|
||||
$cache2->save('bar', 'value');
|
||||
|
||||
$chainCache = new ChainCache(array($cache1, $cache2));
|
||||
|
||||
$this->assertFalse($cache1->contains('bar'));
|
||||
|
||||
$result = $chainCache->fetch('bar');
|
||||
|
||||
$this->assertEquals('value', $result);
|
||||
$this->assertTrue($cache2->contains('bar'));
|
||||
}
|
||||
|
||||
public function testNamespaceIsPropagatedToAllProviders()
|
||||
{
|
||||
$cache1 = new ArrayCache();
|
||||
$cache2 = new ArrayCache();
|
||||
|
||||
$chainCache = new ChainCache(array($cache1, $cache2));
|
||||
$chainCache->setNamespace('bar');
|
||||
|
||||
$this->assertEquals('bar', $cache1->getNamespace());
|
||||
$this->assertEquals('bar', $cache2->getNamespace());
|
||||
}
|
||||
|
||||
public function testDeleteToAllProviders()
|
||||
{
|
||||
$cache1 = $this->getMockForAbstractClass('Doctrine\Common\Cache\CacheProvider');
|
||||
$cache2 = $this->getMockForAbstractClass('Doctrine\Common\Cache\CacheProvider');
|
||||
|
||||
$cache1->expects($this->once())->method('doDelete');
|
||||
$cache2->expects($this->once())->method('doDelete');
|
||||
|
||||
$chainCache = new ChainCache(array($cache1, $cache2));
|
||||
$chainCache->delete('bar');
|
||||
}
|
||||
|
||||
public function testFlushToAllProviders()
|
||||
{
|
||||
$cache1 = $this->getMockForAbstractClass('Doctrine\Common\Cache\CacheProvider');
|
||||
$cache2 = $this->getMockForAbstractClass('Doctrine\Common\Cache\CacheProvider');
|
||||
|
||||
$cache1->expects($this->once())->method('doFlush');
|
||||
$cache2->expects($this->once())->method('doFlush');
|
||||
|
||||
$chainCache = new ChainCache(array($cache1, $cache2));
|
||||
$chainCache->flushAll();
|
||||
}
|
||||
|
||||
protected function isSharedStorage()
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,30 @@
|
||||
<?php
|
||||
|
||||
namespace Doctrine\Tests\Common\Cache;
|
||||
|
||||
use Couchbase;
|
||||
use Doctrine\Common\Cache\CouchbaseCache;
|
||||
|
||||
/**
|
||||
* @requires extension couchbase
|
||||
*/
|
||||
class CouchbaseCacheTest extends CacheTest
|
||||
{
|
||||
private $couchbase;
|
||||
|
||||
protected function setUp()
|
||||
{
|
||||
try {
|
||||
$this->couchbase = new Couchbase('127.0.0.1', 'Administrator', 'password', 'default');
|
||||
} catch(Exception $ex) {
|
||||
$this->markTestSkipped('Could not instantiate the Couchbase cache because of: ' . $ex);
|
||||
}
|
||||
}
|
||||
|
||||
protected function _getCacheDriver()
|
||||
{
|
||||
$driver = new CouchbaseCache();
|
||||
$driver->setCouchbase($this->couchbase);
|
||||
return $driver;
|
||||
}
|
||||
}
|
||||
268
modules/productcomments/vendor/doctrine/cache/tests/Doctrine/Tests/Common/Cache/FileCacheTest.php
vendored
Normal file
268
modules/productcomments/vendor/doctrine/cache/tests/Doctrine/Tests/Common/Cache/FileCacheTest.php
vendored
Normal file
@@ -0,0 +1,268 @@
|
||||
<?php
|
||||
|
||||
namespace Doctrine\Tests\Common\Cache;
|
||||
|
||||
use Doctrine\Common\Cache\Cache;
|
||||
|
||||
/**
|
||||
* @group DCOM-101
|
||||
*/
|
||||
class FileCacheTest extends \Doctrine\Tests\DoctrineTestCase
|
||||
{
|
||||
/**
|
||||
* @var \Doctrine\Common\Cache\FileCache
|
||||
*/
|
||||
private $driver;
|
||||
|
||||
protected function setUp()
|
||||
{
|
||||
$this->driver = $this->getMock(
|
||||
'Doctrine\Common\Cache\FileCache',
|
||||
array('doFetch', 'doContains', 'doSave'),
|
||||
array(), '', false
|
||||
);
|
||||
}
|
||||
|
||||
public function testFilenameShouldCreateThePathWithOneSubDirectory()
|
||||
{
|
||||
$cache = $this->driver;
|
||||
$method = new \ReflectionMethod($cache, 'getFilename');
|
||||
$key = 'item-key';
|
||||
$expectedDir = array(
|
||||
'84',
|
||||
);
|
||||
$expectedDir = implode(DIRECTORY_SEPARATOR, $expectedDir);
|
||||
|
||||
$method->setAccessible(true);
|
||||
|
||||
$path = $method->invoke($cache, $key);
|
||||
$dirname = pathinfo($path, PATHINFO_DIRNAME);
|
||||
|
||||
$this->assertEquals(DIRECTORY_SEPARATOR . $expectedDir, $dirname);
|
||||
}
|
||||
|
||||
public function testFileExtensionCorrectlyEscaped()
|
||||
{
|
||||
$driver1 = $this->getMock(
|
||||
'Doctrine\Common\Cache\FileCache',
|
||||
array('doFetch', 'doContains', 'doSave'),
|
||||
array(__DIR__, '.*')
|
||||
);
|
||||
$driver2 = $this->getMock(
|
||||
'Doctrine\Common\Cache\FileCache',
|
||||
array('doFetch', 'doContains', 'doSave'),
|
||||
array(__DIR__, '.php')
|
||||
);
|
||||
|
||||
$doGetStats = new \ReflectionMethod($driver1, 'doGetStats');
|
||||
|
||||
$doGetStats->setAccessible(true);
|
||||
|
||||
$stats1 = $doGetStats->invoke($driver1);
|
||||
$stats2 = $doGetStats->invoke($driver2);
|
||||
|
||||
$this->assertSame(0, $stats1[Cache::STATS_MEMORY_USAGE]);
|
||||
$this->assertGreaterThan(0, $stats2[Cache::STATS_MEMORY_USAGE]);
|
||||
}
|
||||
|
||||
/**
|
||||
* @group DCOM-266
|
||||
*/
|
||||
public function testFileExtensionSlashCorrectlyEscaped()
|
||||
{
|
||||
$driver = $this->getMock(
|
||||
'Doctrine\Common\Cache\FileCache',
|
||||
array('doFetch', 'doContains', 'doSave'),
|
||||
array(__DIR__ . '/../', DIRECTORY_SEPARATOR . basename(__FILE__))
|
||||
);
|
||||
|
||||
$doGetStats = new \ReflectionMethod($driver, 'doGetStats');
|
||||
|
||||
$doGetStats->setAccessible(true);
|
||||
|
||||
$stats = $doGetStats->invoke($driver);
|
||||
|
||||
$this->assertGreaterThan(0, $stats[Cache::STATS_MEMORY_USAGE]);
|
||||
}
|
||||
|
||||
public function testNonIntUmaskThrowsInvalidArgumentException()
|
||||
{
|
||||
$this->setExpectedException('InvalidArgumentException');
|
||||
|
||||
$this->getMock(
|
||||
'Doctrine\Common\Cache\FileCache',
|
||||
array('doFetch', 'doContains', 'doSave'),
|
||||
array('', '', 'invalid')
|
||||
);
|
||||
}
|
||||
|
||||
public function testGetDirectoryReturnsRealpathDirectoryString()
|
||||
{
|
||||
$directory = __DIR__ . '/../';
|
||||
$driver = $this->getMock(
|
||||
'Doctrine\Common\Cache\FileCache',
|
||||
array('doFetch', 'doContains', 'doSave'),
|
||||
array($directory)
|
||||
);
|
||||
|
||||
$doGetDirectory = new \ReflectionMethod($driver, 'getDirectory');
|
||||
|
||||
$actualDirectory = $doGetDirectory->invoke($driver);
|
||||
$expectedDirectory = realpath($directory);
|
||||
|
||||
$this->assertEquals($expectedDirectory, $actualDirectory);
|
||||
}
|
||||
|
||||
public function testGetExtensionReturnsExtensionString()
|
||||
{
|
||||
$directory = __DIR__ . '/../';
|
||||
$extension = DIRECTORY_SEPARATOR . basename(__FILE__);
|
||||
$driver = $this->getMock(
|
||||
'Doctrine\Common\Cache\FileCache',
|
||||
array('doFetch', 'doContains', 'doSave'),
|
||||
array($directory, $extension)
|
||||
);
|
||||
|
||||
$doGetExtension = new \ReflectionMethod($driver, 'getExtension');
|
||||
|
||||
$actualExtension = $doGetExtension->invoke($driver);
|
||||
|
||||
$this->assertEquals($extension, $actualExtension);
|
||||
}
|
||||
|
||||
const WIN_MAX_PATH_LEN = 258;
|
||||
|
||||
public static function getBasePathForWindowsPathLengthTests($pathLength)
|
||||
{
|
||||
// Not using __DIR__ because it can get screwed up when xdebug debugger is attached.
|
||||
$basePath = realpath(sys_get_temp_dir()) . '/' . uniqid('doctrine-cache', true);
|
||||
|
||||
/** @noinspection MkdirRaceConditionInspection */
|
||||
@mkdir($basePath);
|
||||
|
||||
$basePath = realpath($basePath);
|
||||
|
||||
// Test whether the desired path length is odd or even.
|
||||
$desiredPathLengthIsOdd = ($pathLength % 2) == 1;
|
||||
|
||||
// If the cache key is not too long, the filecache codepath will add
|
||||
// a slash and bin2hex($key). The length of the added portion will be an odd number.
|
||||
// len(desired) = len(base path) + len(slash . bin2hex($key))
|
||||
// odd = even + odd
|
||||
// even = odd + odd
|
||||
$basePathLengthShouldBeOdd = !$desiredPathLengthIsOdd;
|
||||
|
||||
$basePathLengthIsOdd = (strlen($basePath) % 2) == 1;
|
||||
|
||||
// If the base path needs to be odd or even where it is not, we add an odd number of
|
||||
// characters as a pad. In this case, we're adding '\aa' (or '/aa' depending on platform)
|
||||
// This is all to make it so that the key we're testing would result in
|
||||
// a path that is exactly the length we want to test IF the path length limit
|
||||
// were not in place in FileCache.
|
||||
if ($basePathLengthIsOdd != $basePathLengthShouldBeOdd) {
|
||||
$basePath .= DIRECTORY_SEPARATOR . "aa";
|
||||
}
|
||||
|
||||
return $basePath;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param int $length
|
||||
* @param string $basePath
|
||||
*
|
||||
* @return array
|
||||
*/
|
||||
public static function getKeyAndPathFittingLength($length, $basePath)
|
||||
{
|
||||
$baseDirLength = strlen($basePath);
|
||||
$extensionLength = strlen('.doctrine.cache');
|
||||
$directoryLength = strlen(DIRECTORY_SEPARATOR . 'aa' . DIRECTORY_SEPARATOR);
|
||||
$keyLength = $length - ($baseDirLength + $extensionLength + $directoryLength); // - 1 because of slash
|
||||
|
||||
$key = str_repeat('a', floor($keyLength / 2));
|
||||
|
||||
$keyHash = hash('sha256', $key);
|
||||
|
||||
$keyPath = $basePath
|
||||
. DIRECTORY_SEPARATOR
|
||||
. substr($keyHash, 0, 2)
|
||||
. DIRECTORY_SEPARATOR
|
||||
. bin2hex($key)
|
||||
. '.doctrine.cache';
|
||||
|
||||
$hashedKeyPath = $basePath
|
||||
. DIRECTORY_SEPARATOR
|
||||
. substr($keyHash, 0, 2)
|
||||
. DIRECTORY_SEPARATOR
|
||||
. '_' . $keyHash
|
||||
. '.doctrine.cache';
|
||||
|
||||
return array($key, $keyPath, $hashedKeyPath);
|
||||
}
|
||||
|
||||
public function getPathLengthsToTest()
|
||||
{
|
||||
// Windows officially supports 260 bytes including null terminator
|
||||
// 259 characters is too large due to PHP bug (https://bugs.php.net/bug.php?id=70943)
|
||||
// 260 characters is too large - null terminator is included in allowable length
|
||||
return array(
|
||||
array(257, false),
|
||||
array(258, false),
|
||||
array(259, true),
|
||||
array(260, true)
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* @runInSeparateProcess
|
||||
* @dataProvider getPathLengthsToTest
|
||||
*
|
||||
* @covers \Doctrine\Common\Cache\FileCache::getFilename
|
||||
*
|
||||
* @param int $length
|
||||
* @param bool $pathShouldBeHashed
|
||||
*/
|
||||
public function testWindowsPathLengthLimitationsAreCorrectlyRespected($length, $pathShouldBeHashed)
|
||||
{
|
||||
if (! defined('PHP_WINDOWS_VERSION_BUILD')) {
|
||||
define('PHP_WINDOWS_VERSION_BUILD', 'Yes, this is the "usual suspect", with the usual limitations');
|
||||
}
|
||||
|
||||
$basePath = self::getBasePathForWindowsPathLengthTests($length);
|
||||
|
||||
$fileCache = $this->getMockForAbstractClass(
|
||||
'Doctrine\Common\Cache\FileCache',
|
||||
array($basePath, '.doctrine.cache')
|
||||
);
|
||||
|
||||
list($key, $keyPath, $hashedKeyPath) = self::getKeyAndPathFittingLength($length, $basePath);
|
||||
|
||||
$getFileName = new \ReflectionMethod($fileCache, 'getFilename');
|
||||
|
||||
$getFileName->setAccessible(true);
|
||||
|
||||
$this->assertEquals(
|
||||
$length,
|
||||
strlen($keyPath),
|
||||
sprintf('Path expected to be %d characters long is %d characters long', $length, strlen($keyPath))
|
||||
);
|
||||
|
||||
if ($pathShouldBeHashed) {
|
||||
$keyPath = $hashedKeyPath;
|
||||
}
|
||||
|
||||
if ($pathShouldBeHashed) {
|
||||
$this->assertSame(
|
||||
$hashedKeyPath,
|
||||
$getFileName->invoke($fileCache, $key),
|
||||
'Keys should be hashed correctly if they are over the limit.'
|
||||
);
|
||||
} else {
|
||||
$this->assertSame(
|
||||
$keyPath,
|
||||
$getFileName->invoke($fileCache, $key),
|
||||
'Keys below limit of the allowed length are used directly, unhashed'
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,61 @@
|
||||
<?php
|
||||
|
||||
namespace Doctrine\Tests\Common\Cache;
|
||||
|
||||
use Doctrine\Common\Cache\Cache;
|
||||
use Doctrine\Common\Cache\FilesystemCache;
|
||||
|
||||
/**
|
||||
* @group DCOM-101
|
||||
*/
|
||||
class FilesystemCacheTest extends BaseFileCacheTest
|
||||
{
|
||||
public function testGetStats()
|
||||
{
|
||||
$cache = $this->_getCacheDriver();
|
||||
$stats = $cache->getStats();
|
||||
|
||||
$this->assertNull($stats[Cache::STATS_HITS]);
|
||||
$this->assertNull($stats[Cache::STATS_MISSES]);
|
||||
$this->assertNull($stats[Cache::STATS_UPTIME]);
|
||||
$this->assertEquals(0, $stats[Cache::STATS_MEMORY_USAGE]);
|
||||
$this->assertGreaterThan(0, $stats[Cache::STATS_MEMORY_AVAILABLE]);
|
||||
}
|
||||
|
||||
public function testCacheInSharedDirectoryIsPerExtension()
|
||||
{
|
||||
$cache1 = new FilesystemCache($this->directory, '.foo');
|
||||
$cache2 = new FilesystemCache($this->directory, '.bar');
|
||||
|
||||
$this->assertTrue($cache1->save('key1', 11));
|
||||
$this->assertTrue($cache1->save('key2', 12));
|
||||
|
||||
$this->assertTrue($cache2->save('key1', 21));
|
||||
$this->assertTrue($cache2->save('key2', 22));
|
||||
|
||||
$this->assertSame(11, $cache1->fetch('key1'), 'Cache value must not be influenced by a different cache in the same directory but different extension');
|
||||
$this->assertSame(12, $cache1->fetch('key2'));
|
||||
$this->assertTrue($cache1->flushAll());
|
||||
$this->assertFalse($cache1->fetch('key1'), 'flushAll() must delete all items with the current extension');
|
||||
$this->assertFalse($cache1->fetch('key2'));
|
||||
|
||||
$this->assertSame(21, $cache2->fetch('key1'), 'flushAll() must not remove items with a different extension in a shared directory');
|
||||
$this->assertSame(22, $cache2->fetch('key2'));
|
||||
}
|
||||
|
||||
public function testFlushAllWithNoExtension()
|
||||
{
|
||||
$cache = new FilesystemCache($this->directory, '');
|
||||
|
||||
$this->assertTrue($cache->save('key1', 1));
|
||||
$this->assertTrue($cache->save('key2', 2));
|
||||
$this->assertTrue($cache->flushAll());
|
||||
$this->assertFalse($cache->contains('key1'));
|
||||
$this->assertFalse($cache->contains('key2'));
|
||||
}
|
||||
|
||||
protected function _getCacheDriver()
|
||||
{
|
||||
return new FilesystemCache($this->directory);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,59 @@
|
||||
<?php
|
||||
|
||||
namespace Doctrine\Tests\Common\Cache;
|
||||
|
||||
use Doctrine\Common\Cache\MemcacheCache;
|
||||
use Memcache;
|
||||
|
||||
/**
|
||||
* @requires extension memcache
|
||||
*/
|
||||
class MemcacheCacheTest extends CacheTest
|
||||
{
|
||||
private $memcache;
|
||||
|
||||
protected function setUp()
|
||||
{
|
||||
$this->memcache = new Memcache();
|
||||
|
||||
if (@$this->memcache->connect('localhost', 11211) === false) {
|
||||
unset($this->memcache);
|
||||
$this->markTestSkipped('Cannot connect to Memcache.');
|
||||
}
|
||||
}
|
||||
|
||||
protected function tearDown()
|
||||
{
|
||||
if ($this->memcache instanceof Memcache) {
|
||||
$this->memcache->flush();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritdoc}
|
||||
*
|
||||
* Memcache does not support " " and null byte as key so we remove them from the tests.
|
||||
*/
|
||||
public function provideCacheIds()
|
||||
{
|
||||
$ids = parent::provideCacheIds();
|
||||
unset($ids[21], $ids[22]);
|
||||
|
||||
return $ids;
|
||||
}
|
||||
|
||||
public function testGetMemcacheReturnsInstanceOfMemcache()
|
||||
{
|
||||
$this->assertInstanceOf('Memcache', $this->_getCacheDriver()->getMemcache());
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function _getCacheDriver()
|
||||
{
|
||||
$driver = new MemcacheCache();
|
||||
$driver->setMemcache($this->memcache);
|
||||
return $driver;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,61 @@
|
||||
<?php
|
||||
|
||||
namespace Doctrine\Tests\Common\Cache;
|
||||
|
||||
use Doctrine\Common\Cache\MemcachedCache;
|
||||
use Memcached;
|
||||
|
||||
/**
|
||||
* @requires extension memcached
|
||||
*/
|
||||
class MemcachedCacheTest extends CacheTest
|
||||
{
|
||||
private $memcached;
|
||||
|
||||
protected function setUp()
|
||||
{
|
||||
$this->memcached = new Memcached();
|
||||
$this->memcached->setOption(Memcached::OPT_COMPRESSION, false);
|
||||
$this->memcached->addServer('127.0.0.1', 11211);
|
||||
|
||||
if (@fsockopen('127.0.0.1', 11211) === false) {
|
||||
unset($this->memcached);
|
||||
$this->markTestSkipped('Cannot connect to Memcached.');
|
||||
}
|
||||
}
|
||||
|
||||
protected function tearDown()
|
||||
{
|
||||
if ($this->memcached instanceof Memcached) {
|
||||
$this->memcached->flush();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritdoc}
|
||||
*
|
||||
* Memcached does not support " ", null byte and very long keys so we remove them from the tests.
|
||||
*/
|
||||
public function provideCacheIds()
|
||||
{
|
||||
$ids = parent::provideCacheIds();
|
||||
unset($ids[21], $ids[22], $ids[24]);
|
||||
|
||||
return $ids;
|
||||
}
|
||||
|
||||
public function testGetMemcachedReturnsInstanceOfMemcached()
|
||||
{
|
||||
$this->assertInstanceOf('Memcached', $this->_getCacheDriver()->getMemcached());
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function _getCacheDriver()
|
||||
{
|
||||
$driver = new MemcachedCache();
|
||||
$driver->setMemcached($this->memcached);
|
||||
return $driver;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,68 @@
|
||||
<?php
|
||||
|
||||
namespace Doctrine\Tests\Common\Cache;
|
||||
|
||||
use Doctrine\Common\Cache\Cache;
|
||||
use Doctrine\Common\Cache\MongoDBCache;
|
||||
use MongoClient;
|
||||
use MongoCollection;
|
||||
|
||||
/**
|
||||
* @requires extension mongo
|
||||
*/
|
||||
class MongoDBCacheTest extends CacheTest
|
||||
{
|
||||
/**
|
||||
* @var MongoCollection
|
||||
*/
|
||||
private $collection;
|
||||
|
||||
protected function setUp()
|
||||
{
|
||||
if ( ! version_compare(phpversion('mongo'), '1.3.0', '>=')) {
|
||||
$this->markTestSkipped('Mongo >= 1.3.0 is required.');
|
||||
}
|
||||
|
||||
$mongo = new MongoClient();
|
||||
$this->collection = $mongo->selectCollection('doctrine_common_cache', 'test');
|
||||
}
|
||||
|
||||
protected function tearDown()
|
||||
{
|
||||
if ($this->collection instanceof MongoCollection) {
|
||||
$this->collection->drop();
|
||||
}
|
||||
}
|
||||
|
||||
public function testGetStats()
|
||||
{
|
||||
$cache = $this->_getCacheDriver();
|
||||
$stats = $cache->getStats();
|
||||
|
||||
$this->assertNull($stats[Cache::STATS_HITS]);
|
||||
$this->assertNull($stats[Cache::STATS_MISSES]);
|
||||
$this->assertGreaterThan(0, $stats[Cache::STATS_UPTIME]);
|
||||
$this->assertEquals(0, $stats[Cache::STATS_MEMORY_USAGE]);
|
||||
$this->assertNull($stats[Cache::STATS_MEMORY_AVAILABLE]);
|
||||
}
|
||||
|
||||
/**
|
||||
* @group 108
|
||||
*/
|
||||
public function testMongoCursorExceptionsDoNotBubbleUp()
|
||||
{
|
||||
/* @var $collection \MongoCollection|\PHPUnit_Framework_MockObject_MockObject */
|
||||
$collection = $this->getMock('MongoCollection', array(), array(), '', false);
|
||||
|
||||
$collection->expects(self::once())->method('update')->willThrowException(new \MongoCursorException());
|
||||
|
||||
$cache = new MongoDBCache($collection);
|
||||
|
||||
self::assertFalse($cache->save('foo', 'bar'));
|
||||
}
|
||||
|
||||
protected function _getCacheDriver()
|
||||
{
|
||||
return new MongoDBCache($this->collection);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,98 @@
|
||||
<?php
|
||||
|
||||
namespace Doctrine\Tests\Common\Cache;
|
||||
|
||||
use Doctrine\Common\Cache\Cache;
|
||||
use Doctrine\Common\Cache\PhpFileCache;
|
||||
|
||||
/**
|
||||
* @group DCOM-101
|
||||
*/
|
||||
class PhpFileCacheTest extends BaseFileCacheTest
|
||||
{
|
||||
public function provideDataToCache()
|
||||
{
|
||||
$data = parent::provideDataToCache();
|
||||
|
||||
unset($data['object'], $data['object_recursive']); // PhpFileCache only allows objects that implement __set_state() and fully support var_export()
|
||||
|
||||
if (PHP_VERSION_ID < 70002) {
|
||||
unset($data['float_zero']); // var_export exports float(0) as int(0): https://bugs.php.net/bug.php?id=66179
|
||||
}
|
||||
|
||||
return $data;
|
||||
}
|
||||
|
||||
public function testImplementsSetState()
|
||||
{
|
||||
$cache = $this->_getCacheDriver();
|
||||
|
||||
// Test save
|
||||
$cache->save('test_set_state', new SetStateClass(array(1,2,3)));
|
||||
|
||||
//Test __set_state call
|
||||
$this->assertCount(0, SetStateClass::$values);
|
||||
|
||||
// Test fetch
|
||||
$value = $cache->fetch('test_set_state');
|
||||
$this->assertInstanceOf('Doctrine\Tests\Common\Cache\SetStateClass', $value);
|
||||
$this->assertEquals(array(1,2,3), $value->getValue());
|
||||
|
||||
//Test __set_state call
|
||||
$this->assertCount(1, SetStateClass::$values);
|
||||
|
||||
// Test contains
|
||||
$this->assertTrue($cache->contains('test_set_state'));
|
||||
}
|
||||
|
||||
public function testNotImplementsSetState()
|
||||
{
|
||||
$cache = $this->_getCacheDriver();
|
||||
|
||||
$this->setExpectedException('InvalidArgumentException');
|
||||
$cache->save('test_not_set_state', new NotSetStateClass(array(1,2,3)));
|
||||
}
|
||||
|
||||
public function testGetStats()
|
||||
{
|
||||
$cache = $this->_getCacheDriver();
|
||||
$stats = $cache->getStats();
|
||||
|
||||
$this->assertNull($stats[Cache::STATS_HITS]);
|
||||
$this->assertNull($stats[Cache::STATS_MISSES]);
|
||||
$this->assertNull($stats[Cache::STATS_UPTIME]);
|
||||
$this->assertEquals(0, $stats[Cache::STATS_MEMORY_USAGE]);
|
||||
$this->assertGreaterThan(0, $stats[Cache::STATS_MEMORY_AVAILABLE]);
|
||||
}
|
||||
|
||||
protected function _getCacheDriver()
|
||||
{
|
||||
return new PhpFileCache($this->directory);
|
||||
}
|
||||
}
|
||||
|
||||
class NotSetStateClass
|
||||
{
|
||||
private $value;
|
||||
|
||||
public function __construct($value)
|
||||
{
|
||||
$this->value = $value;
|
||||
}
|
||||
|
||||
public function getValue()
|
||||
{
|
||||
return $this->value;
|
||||
}
|
||||
}
|
||||
|
||||
class SetStateClass extends NotSetStateClass
|
||||
{
|
||||
public static $values = array();
|
||||
|
||||
public static function __set_state($data)
|
||||
{
|
||||
self::$values = $data;
|
||||
return new self($data['value']);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,87 @@
|
||||
<?php
|
||||
|
||||
namespace Doctrine\Tests\Common\Cache;
|
||||
|
||||
use Doctrine\Common\Cache\Cache;
|
||||
use Doctrine\Common\Cache\PredisCache;
|
||||
use Predis\Client;
|
||||
use Predis\Connection\ConnectionException;
|
||||
|
||||
class PredisCacheTest extends CacheTest
|
||||
{
|
||||
private $client;
|
||||
|
||||
protected function setUp()
|
||||
{
|
||||
if (!class_exists('Predis\Client')) {
|
||||
$this->markTestSkipped('Predis\Client is missing. Make sure to "composer install" to have all dev dependencies.');
|
||||
}
|
||||
|
||||
$this->client = new Client();
|
||||
|
||||
try {
|
||||
$this->client->connect();
|
||||
} catch (ConnectionException $e) {
|
||||
$this->markTestSkipped('Cannot connect to Redis because of: ' . $e);
|
||||
}
|
||||
}
|
||||
|
||||
public function testHitMissesStatsAreProvided()
|
||||
{
|
||||
$cache = $this->_getCacheDriver();
|
||||
$stats = $cache->getStats();
|
||||
|
||||
$this->assertNotNull($stats[Cache::STATS_HITS]);
|
||||
$this->assertNotNull($stats[Cache::STATS_MISSES]);
|
||||
}
|
||||
|
||||
/**
|
||||
* @return PredisCache
|
||||
*/
|
||||
protected function _getCacheDriver()
|
||||
{
|
||||
return new PredisCache($this->client);
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*
|
||||
* @dataProvider provideDataToCache
|
||||
*/
|
||||
public function testSetContainsFetchDelete($value)
|
||||
{
|
||||
if (array() === $value) {
|
||||
$this->markTestIncomplete(
|
||||
'Predis currently doesn\'t support saving empty array values. '
|
||||
. 'See https://github.com/nrk/predis/issues/241'
|
||||
);
|
||||
}
|
||||
|
||||
parent::testSetContainsFetchDelete($value);
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*
|
||||
* @dataProvider provideDataToCache
|
||||
*/
|
||||
public function testUpdateExistingEntry($value)
|
||||
{
|
||||
if (array() === $value) {
|
||||
$this->markTestIncomplete(
|
||||
'Predis currently doesn\'t support saving empty array values. '
|
||||
. 'See https://github.com/nrk/predis/issues/241'
|
||||
);
|
||||
}
|
||||
|
||||
parent::testUpdateExistingEntry($value);
|
||||
}
|
||||
|
||||
public function testAllowsGenericPredisClient()
|
||||
{
|
||||
/* @var $predisClient \Predis\ClientInterface */
|
||||
$predisClient = $this->getMock('Predis\\ClientInterface');
|
||||
|
||||
$this->assertInstanceOf('Doctrine\\Common\\Cache\\PredisCache', new PredisCache($predisClient));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,59 @@
|
||||
<?php
|
||||
|
||||
namespace Doctrine\Tests\Common\Cache;
|
||||
|
||||
use Doctrine\Common\Cache\RedisCache;
|
||||
use Doctrine\Common\Cache\Cache;
|
||||
|
||||
/**
|
||||
* @requires extension redis
|
||||
*/
|
||||
class RedisCacheTest extends CacheTest
|
||||
{
|
||||
private $_redis;
|
||||
|
||||
protected function setUp()
|
||||
{
|
||||
$this->_redis = new \Redis();
|
||||
$ok = @$this->_redis->connect('127.0.0.1');
|
||||
if (!$ok) {
|
||||
$this->markTestSkipped('Cannot connect to Redis.');
|
||||
}
|
||||
}
|
||||
|
||||
public function testHitMissesStatsAreProvided()
|
||||
{
|
||||
$cache = $this->_getCacheDriver();
|
||||
$stats = $cache->getStats();
|
||||
|
||||
$this->assertNotNull($stats[Cache::STATS_HITS]);
|
||||
$this->assertNotNull($stats[Cache::STATS_MISSES]);
|
||||
}
|
||||
|
||||
public function testGetRedisReturnsInstanceOfRedis()
|
||||
{
|
||||
$this->assertInstanceOf('Redis', $this->_getCacheDriver()->getRedis());
|
||||
}
|
||||
|
||||
public function testSerializerOptionWithOutIgbinaryExtension()
|
||||
{
|
||||
if (defined('Redis::SERIALIZER_IGBINARY') && extension_loaded('igbinary')) {
|
||||
$this->markTestSkipped('Extension igbinary is loaded.');
|
||||
}
|
||||
|
||||
$this->assertEquals(
|
||||
\Redis::SERIALIZER_PHP,
|
||||
$this->_getCacheDriver()->getRedis()->getOption(\Redis::OPT_SERIALIZER)
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function _getCacheDriver()
|
||||
{
|
||||
$driver = new RedisCache();
|
||||
$driver->setRedis($this->_redis);
|
||||
return $driver;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,58 @@
|
||||
<?php
|
||||
|
||||
namespace Doctrine\Tests\Common\Cache;
|
||||
|
||||
use Riak\Bucket;
|
||||
use Riak\Connection;
|
||||
use Riak\Exception;
|
||||
use Doctrine\Common\Cache\RiakCache;
|
||||
|
||||
/**
|
||||
* RiakCache test
|
||||
*
|
||||
* @group Riak
|
||||
* @requires extension riak
|
||||
*/
|
||||
class RiakCacheTest extends CacheTest
|
||||
{
|
||||
/**
|
||||
* @var \Riak\Connection
|
||||
*/
|
||||
private $connection;
|
||||
|
||||
/**
|
||||
* @var \Riak\Bucket
|
||||
*/
|
||||
private $bucket;
|
||||
|
||||
protected function setUp()
|
||||
{
|
||||
try {
|
||||
$this->connection = new Connection('127.0.0.1', 8087);
|
||||
$this->bucket = new Bucket($this->connection, 'test');
|
||||
} catch (Exception\RiakException $e) {
|
||||
$this->markTestSkipped('Cannot connect to Riak.');
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritdoc}
|
||||
*/
|
||||
public function testGetStats()
|
||||
{
|
||||
$cache = $this->_getCacheDriver();
|
||||
$stats = $cache->getStats();
|
||||
|
||||
$this->assertNull($stats);
|
||||
}
|
||||
|
||||
/**
|
||||
* Retrieve RiakCache instance.
|
||||
*
|
||||
* @return \Doctrine\Common\Cache\RiakCache
|
||||
*/
|
||||
protected function _getCacheDriver()
|
||||
{
|
||||
return new RiakCache($this->bucket);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,42 @@
|
||||
<?php
|
||||
|
||||
namespace Doctrine\Tests\Common\Cache;
|
||||
|
||||
use Doctrine\Common\Cache\Cache;
|
||||
use Doctrine\Common\Cache\SQLite3Cache;
|
||||
use SQLite3;
|
||||
|
||||
/**
|
||||
* @requires extension sqlite3
|
||||
*/
|
||||
class SQLite3Test extends CacheTest
|
||||
{
|
||||
private $file;
|
||||
private $sqlite;
|
||||
|
||||
protected function setUp()
|
||||
{
|
||||
$this->file = tempnam(null, 'doctrine-cache-test-');
|
||||
unlink($this->file);
|
||||
$this->sqlite = new SQLite3($this->file);
|
||||
}
|
||||
|
||||
protected function tearDown()
|
||||
{
|
||||
$this->sqlite = null; // DB must be closed before
|
||||
unlink($this->file);
|
||||
}
|
||||
|
||||
public function testGetStats()
|
||||
{
|
||||
$this->assertNull($this->_getCacheDriver()->getStats());
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function _getCacheDriver()
|
||||
{
|
||||
return new SQLite3Cache($this->sqlite, 'test_table');
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,58 @@
|
||||
<?php
|
||||
|
||||
namespace Doctrine\Tests\Common\Cache;
|
||||
|
||||
use Doctrine\Common\Cache\VoidCache;
|
||||
|
||||
/**
|
||||
* @covers \Doctrine\Common\Cache\VoidCache
|
||||
*/
|
||||
class VoidCacheTest extends \PHPUnit_Framework_TestCase
|
||||
{
|
||||
public function testShouldAlwaysReturnFalseOnContains()
|
||||
{
|
||||
$cache = new VoidCache();
|
||||
|
||||
$this->assertFalse($cache->contains('foo'));
|
||||
$this->assertFalse($cache->contains('bar'));
|
||||
}
|
||||
|
||||
public function testShouldAlwaysReturnFalseOnFetch()
|
||||
{
|
||||
$cache = new VoidCache();
|
||||
|
||||
$this->assertFalse($cache->fetch('foo'));
|
||||
$this->assertFalse($cache->fetch('bar'));
|
||||
}
|
||||
|
||||
public function testShouldAlwaysReturnTrueOnSaveButNotStoreAnything()
|
||||
{
|
||||
$cache = new VoidCache();
|
||||
|
||||
$this->assertTrue($cache->save('foo', 'fooVal'));
|
||||
|
||||
$this->assertFalse($cache->contains('foo'));
|
||||
$this->assertFalse($cache->fetch('foo'));
|
||||
}
|
||||
|
||||
public function testShouldAlwaysReturnTrueOnDelete()
|
||||
{
|
||||
$cache = new VoidCache();
|
||||
|
||||
$this->assertTrue($cache->delete('foo'));
|
||||
}
|
||||
|
||||
public function testShouldAlwaysReturnNullOnGetStatus()
|
||||
{
|
||||
$cache = new VoidCache();
|
||||
|
||||
$this->assertNull($cache->getStats());
|
||||
}
|
||||
|
||||
public function testShouldAlwaysReturnTrueOnFlush()
|
||||
{
|
||||
$cache = new VoidCache();
|
||||
|
||||
$this->assertTrue($cache->flushAll());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,16 @@
|
||||
<?php
|
||||
|
||||
namespace Doctrine\Tests\Common\Cache;
|
||||
|
||||
use Doctrine\Common\Cache\WincacheCache;
|
||||
|
||||
/**
|
||||
* @requires extension wincache
|
||||
*/
|
||||
class WincacheCacheTest extends CacheTest
|
||||
{
|
||||
protected function _getCacheDriver()
|
||||
{
|
||||
return new WincacheCache();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,16 @@
|
||||
<?php
|
||||
|
||||
namespace Doctrine\Tests\Common\Cache;
|
||||
|
||||
use Doctrine\Common\Cache\XcacheCache;
|
||||
|
||||
/**
|
||||
* @requires extension xcache
|
||||
*/
|
||||
class XcacheCacheTest extends CacheTest
|
||||
{
|
||||
protected function _getCacheDriver()
|
||||
{
|
||||
return new XcacheCache();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,31 @@
|
||||
<?php
|
||||
|
||||
namespace Doctrine\Tests\Common\Cache;
|
||||
|
||||
use Doctrine\Common\Cache\ZendDataCache;
|
||||
|
||||
/**
|
||||
* @requires function zend_shm_cache_fetch
|
||||
*/
|
||||
class ZendDataCacheTest extends CacheTest
|
||||
{
|
||||
protected function setUp()
|
||||
{
|
||||
if ('apache2handler' !== php_sapi_name()) {
|
||||
$this->markTestSkipped('Zend Data Cache only works in apache2handler SAPI.');
|
||||
}
|
||||
}
|
||||
|
||||
public function testGetStats()
|
||||
{
|
||||
$cache = $this->_getCacheDriver();
|
||||
$stats = $cache->getStats();
|
||||
|
||||
$this->assertNull($stats);
|
||||
}
|
||||
|
||||
protected function _getCacheDriver()
|
||||
{
|
||||
return new ZendDataCache();
|
||||
}
|
||||
}
|
||||
10
modules/productcomments/vendor/doctrine/cache/tests/Doctrine/Tests/DoctrineTestCase.php
vendored
Normal file
10
modules/productcomments/vendor/doctrine/cache/tests/Doctrine/Tests/DoctrineTestCase.php
vendored
Normal file
@@ -0,0 +1,10 @@
|
||||
<?php
|
||||
|
||||
namespace Doctrine\Tests;
|
||||
|
||||
/**
|
||||
* Base testcase class for all Doctrine testcases.
|
||||
*/
|
||||
abstract class DoctrineTestCase extends \PHPUnit_Framework_TestCase
|
||||
{
|
||||
}
|
||||
7
modules/productcomments/vendor/doctrine/cache/tests/travis/php.ini
vendored
Normal file
7
modules/productcomments/vendor/doctrine/cache/tests/travis/php.ini
vendored
Normal file
@@ -0,0 +1,7 @@
|
||||
extension="mongo.so"
|
||||
extension="memcache.so"
|
||||
extension="memcached.so"
|
||||
extension="redis.so"
|
||||
|
||||
apc.enabled=1
|
||||
apc.enable_cli=1
|
||||
34
modules/productcomments/vendor/doctrine/cache/tests/travis/phpunit.travis.xml
vendored
Normal file
34
modules/productcomments/vendor/doctrine/cache/tests/travis/phpunit.travis.xml
vendored
Normal file
@@ -0,0 +1,34 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
|
||||
<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
|
||||
xsi:noNamespaceSchemaLocation="http://schema.phpunit.de/4.1/phpunit.xsd"
|
||||
backupGlobals="false"
|
||||
colors="true"
|
||||
bootstrap="../../vendor/autoload.php"
|
||||
>
|
||||
<php>
|
||||
<ini name="error_reporting" value="-1" />
|
||||
</php>
|
||||
|
||||
<logging>
|
||||
<log type="coverage-clover" target="../../build/logs/clover.xml"/>
|
||||
</logging>
|
||||
|
||||
<testsuites>
|
||||
<testsuite name="Doctrine Cache Test Suite">
|
||||
<directory>../Doctrine/</directory>
|
||||
</testsuite>
|
||||
</testsuites>
|
||||
|
||||
<filter>
|
||||
<whitelist>
|
||||
<directory>../../lib/Doctrine/</directory>
|
||||
</whitelist>
|
||||
</filter>
|
||||
|
||||
<groups>
|
||||
<exclude>
|
||||
<group>performance</group>
|
||||
</exclude>
|
||||
</groups>
|
||||
</phpunit>
|
||||
Reference in New Issue
Block a user