更新代码

vendor/symfony/cache/Tests/Adapter/AbstractRedisAdapterTest.php

@@ -0,0 +1,46 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Tests\Adapter;
+
+use Symfony\Component\Cache\Adapter\RedisAdapter;
+
+abstract class AbstractRedisAdapterTest extends AdapterTestCase
+{
+    protected $skippedTests = array(
+        'testExpiration' => 'Testing expiration slows down the test suite',
+        'testHasItemReturnsFalseWhenDeferredItemIsExpired' => 'Testing expiration slows down the test suite',
+        'testDefaultLifeTime' => 'Testing expiration slows down the test suite',
+    );
+
+    protected static $redis;
+
+    public function createCachePool($defaultLifetime = 0)
+    {
+        return new RedisAdapter(self::$redis, str_replace('\\', '.', __CLASS__), $defaultLifetime);
+    }
+
+    public static function setupBeforeClass()
+    {
+        if (!\extension_loaded('redis')) {
+            self::markTestSkipped('Extension redis required.');
+        }
+        if (!@((new \Redis())->connect(getenv('REDIS_HOST')))) {
+            $e = error_get_last();
+            self::markTestSkipped($e['message']);
+        }
+    }
+
+    public static function tearDownAfterClass()
+    {
+        self::$redis = null;
+    }
+}

vendor/symfony/cache/Tests/Adapter/AdapterTestCase.php

@@ -0,0 +1,171 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Tests\Adapter;
+
+use Cache\IntegrationTests\CachePoolTest;
+use Psr\Cache\CacheItemPoolInterface;
+use Symfony\Component\Cache\PruneableInterface;
+
+abstract class AdapterTestCase extends CachePoolTest
+{
+    protected function setUp()
+    {
+        parent::setUp();
+
+        if (!array_key_exists('testPrune', $this->skippedTests) && !$this->createCachePool() instanceof PruneableInterface) {
+            $this->skippedTests['testPrune'] = 'Not a pruneable cache pool.';
+        }
+    }
+
+    public function testDefaultLifeTime()
+    {
+        if (isset($this->skippedTests[__FUNCTION__])) {
+            $this->markTestSkipped($this->skippedTests[__FUNCTION__]);
+        }
+
+        $cache = $this->createCachePool(2);
+
+        $item = $cache->getItem('key.dlt');
+        $item->set('value');
+        $cache->save($item);
+        sleep(1);
+
+        $item = $cache->getItem('key.dlt');
+        $this->assertTrue($item->isHit());
+
+        sleep(2);
+        $item = $cache->getItem('key.dlt');
+        $this->assertFalse($item->isHit());
+    }
+
+    public function testExpiration()
+    {
+        if (isset($this->skippedTests[__FUNCTION__])) {
+            $this->markTestSkipped($this->skippedTests[__FUNCTION__]);
+        }
+
+        $cache = $this->createCachePool();
+        $cache->save($cache->getItem('k1')->set('v1')->expiresAfter(2));
+        $cache->save($cache->getItem('k2')->set('v2')->expiresAfter(366 * 86400));
+
+        sleep(3);
+        $item = $cache->getItem('k1');
+        $this->assertFalse($item->isHit());
+        $this->assertNull($item->get(), "Item's value must be null when isHit() is false.");
+
+        $item = $cache->getItem('k2');
+        $this->assertTrue($item->isHit());
+        $this->assertSame('v2', $item->get());
+    }
+
+    public function testNotUnserializable()
+    {
+        if (isset($this->skippedTests[__FUNCTION__])) {
+            $this->markTestSkipped($this->skippedTests[__FUNCTION__]);
+        }
+
+        $cache = $this->createCachePool();
+
+        $item = $cache->getItem('foo');
+        $cache->save($item->set(new NotUnserializable()));
+
+        $item = $cache->getItem('foo');
+        $this->assertFalse($item->isHit());
+
+        foreach ($cache->getItems(array('foo')) as $item) {
+        }
+        $cache->save($item->set(new NotUnserializable()));
+
+        foreach ($cache->getItems(array('foo')) as $item) {
+        }
+        $this->assertFalse($item->isHit());
+    }
+
+    public function testPrune()
+    {
+        if (isset($this->skippedTests[__FUNCTION__])) {
+            $this->markTestSkipped($this->skippedTests[__FUNCTION__]);
+        }
+
+        if (!method_exists($this, 'isPruned')) {
+            $this->fail('Test classes for pruneable caches must implement `isPruned($cache, $name)` method.');
+        }
+
+        /** @var PruneableInterface|CacheItemPoolInterface $cache */
+        $cache = $this->createCachePool();
+
+        $doSet = function ($name, $value, \DateInterval $expiresAfter = null) use ($cache) {
+            $item = $cache->getItem($name);
+            $item->set($value);
+
+            if ($expiresAfter) {
+                $item->expiresAfter($expiresAfter);
+            }
+
+            $cache->save($item);
+        };
+
+        $doSet('foo', 'foo-val', new \DateInterval('PT05S'));
+        $doSet('bar', 'bar-val', new \DateInterval('PT10S'));
+        $doSet('baz', 'baz-val', new \DateInterval('PT15S'));
+        $doSet('qux', 'qux-val', new \DateInterval('PT20S'));
+
+        sleep(30);
+        $cache->prune();
+        $this->assertTrue($this->isPruned($cache, 'foo'));
+        $this->assertTrue($this->isPruned($cache, 'bar'));
+        $this->assertTrue($this->isPruned($cache, 'baz'));
+        $this->assertTrue($this->isPruned($cache, 'qux'));
+
+        $doSet('foo', 'foo-val');
+        $doSet('bar', 'bar-val', new \DateInterval('PT20S'));
+        $doSet('baz', 'baz-val', new \DateInterval('PT40S'));
+        $doSet('qux', 'qux-val', new \DateInterval('PT80S'));
+
+        $cache->prune();
+        $this->assertFalse($this->isPruned($cache, 'foo'));
+        $this->assertFalse($this->isPruned($cache, 'bar'));
+        $this->assertFalse($this->isPruned($cache, 'baz'));
+        $this->assertFalse($this->isPruned($cache, 'qux'));
+
+        sleep(30);
+        $cache->prune();
+        $this->assertFalse($this->isPruned($cache, 'foo'));
+        $this->assertTrue($this->isPruned($cache, 'bar'));
+        $this->assertFalse($this->isPruned($cache, 'baz'));
+        $this->assertFalse($this->isPruned($cache, 'qux'));
+
+        sleep(30);
+        $cache->prune();
+        $this->assertFalse($this->isPruned($cache, 'foo'));
+        $this->assertTrue($this->isPruned($cache, 'baz'));
+        $this->assertFalse($this->isPruned($cache, 'qux'));
+
+        sleep(30);
+        $cache->prune();
+        $this->assertFalse($this->isPruned($cache, 'foo'));
+        $this->assertTrue($this->isPruned($cache, 'qux'));
+    }
+}
+
+class NotUnserializable implements \Serializable
+{
+    public function serialize()
+    {
+        return serialize(123);
+    }
+
+    public function unserialize($ser)
+    {
+        throw new \Exception(__CLASS__);
+    }
+}

vendor/symfony/cache/Tests/Adapter/ApcuAdapterTest.php

@@ -0,0 +1,124 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Tests\Adapter;
+
+use Psr\Log\NullLogger;
+use Symfony\Component\Cache\Adapter\ApcuAdapter;
+
+class ApcuAdapterTest extends AdapterTestCase
+{
+    protected $skippedTests = array(
+        'testExpiration' => 'Testing expiration slows down the test suite',
+        'testHasItemReturnsFalseWhenDeferredItemIsExpired' => 'Testing expiration slows down the test suite',
+        'testDefaultLifeTime' => 'Testing expiration slows down the test suite',
+    );
+
+    public function createCachePool($defaultLifetime = 0)
+    {
+        if (!\function_exists('apcu_fetch') || !ini_get('apc.enabled')) {
+            $this->markTestSkipped('APCu extension is required.');
+        }
+        if ('cli' === \PHP_SAPI && !ini_get('apc.enable_cli')) {
+            if ('testWithCliSapi' !== $this->getName()) {
+                $this->markTestSkipped('apc.enable_cli=1 is required.');
+            }
+        }
+        if ('\\' === \DIRECTORY_SEPARATOR) {
+            $this->markTestSkipped('Fails transiently on Windows.');
+        }
+
+        return new ApcuAdapter(str_replace('\\', '.', __CLASS__), $defaultLifetime);
+    }
+
+    public function testUnserializable()
+    {
+        $pool = $this->createCachePool();
+
+        $item = $pool->getItem('foo');
+        $item->set(function () {});
+
+        $this->assertFalse($pool->save($item));
+
+        $item = $pool->getItem('foo');
+        $this->assertFalse($item->isHit());
+    }
+
+    public function testVersion()
+    {
+        $namespace = str_replace('\\', '.', \get_class($this));
+
+        $pool1 = new ApcuAdapter($namespace, 0, 'p1');
+
+        $item = $pool1->getItem('foo');
+        $this->assertFalse($item->isHit());
+        $this->assertTrue($pool1->save($item->set('bar')));
+
+        $item = $pool1->getItem('foo');
+        $this->assertTrue($item->isHit());
+        $this->assertSame('bar', $item->get());
+
+        $pool2 = new ApcuAdapter($namespace, 0, 'p2');
+
+        $item = $pool2->getItem('foo');
+        $this->assertFalse($item->isHit());
+        $this->assertNull($item->get());
+
+        $item = $pool1->getItem('foo');
+        $this->assertFalse($item->isHit());
+        $this->assertNull($item->get());
+    }
+
+    public function testNamespace()
+    {
+        $namespace = str_replace('\\', '.', \get_class($this));
+
+        $pool1 = new ApcuAdapter($namespace.'_1', 0, 'p1');
+
+        $item = $pool1->getItem('foo');
+        $this->assertFalse($item->isHit());
+        $this->assertTrue($pool1->save($item->set('bar')));
+
+        $item = $pool1->getItem('foo');
+        $this->assertTrue($item->isHit());
+        $this->assertSame('bar', $item->get());
+
+        $pool2 = new ApcuAdapter($namespace.'_2', 0, 'p1');
+
+        $item = $pool2->getItem('foo');
+        $this->assertFalse($item->isHit());
+        $this->assertNull($item->get());
+
+        $item = $pool1->getItem('foo');
+        $this->assertTrue($item->isHit());
+        $this->assertSame('bar', $item->get());
+    }
+
+    public function testWithCliSapi()
+    {
+        try {
+            // disable PHPUnit error handler to mimic a production environment
+            $isCalled = false;
+            set_error_handler(function () use (&$isCalled) {
+                $isCalled = true;
+            });
+            $pool = new ApcuAdapter(str_replace('\\', '.', __CLASS__));
+            $pool->setLogger(new NullLogger());
+
+            $item = $pool->getItem('foo');
+            $item->isHit();
+            $pool->save($item->set('bar'));
+            $this->assertFalse($isCalled);
+        } finally {
+            restore_error_handler();
+        }
+    }
+}

vendor/symfony/cache/Tests/Adapter/ArrayAdapterTest.php

@@ -0,0 +1,56 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Tests\Adapter;
+
+use Symfony\Component\Cache\Adapter\ArrayAdapter;
+
+/**
+ * @group time-sensitive
+ */
+class ArrayAdapterTest extends AdapterTestCase
+{
+    protected $skippedTests = array(
+        'testDeferredSaveWithoutCommit' => 'Assumes a shared cache which ArrayAdapter is not.',
+        'testSaveWithoutExpire' => 'Assumes a shared cache which ArrayAdapter is not.',
+    );
+
+    public function createCachePool($defaultLifetime = 0)
+    {
+        return new ArrayAdapter($defaultLifetime);
+    }
+
+    public function testGetValuesHitAndMiss()
+    {
+        /** @var ArrayAdapter $cache */
+        $cache = $this->createCachePool();
+
+        // Hit
+        $item = $cache->getItem('foo');
+        $item->set('4711');
+        $cache->save($item);
+
+        $fooItem = $cache->getItem('foo');
+        $this->assertTrue($fooItem->isHit());
+        $this->assertEquals('4711', $fooItem->get());
+
+        // Miss (should be present as NULL in $values)
+        $cache->getItem('bar');
+
+        $values = $cache->getValues();
+
+        $this->assertCount(2, $values);
+        $this->assertArrayHasKey('foo', $values);
+        $this->assertSame(serialize('4711'), $values['foo']);
+        $this->assertArrayHasKey('bar', $values);
+        $this->assertNull($values['bar']);
+    }
+}

vendor/symfony/cache/Tests/Adapter/ChainAdapterTest.php

@@ -0,0 +1,118 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Tests\Adapter;
+
+use Symfony\Component\Cache\Adapter\AdapterInterface;
+use Symfony\Component\Cache\Adapter\ArrayAdapter;
+use Symfony\Component\Cache\Adapter\ChainAdapter;
+use Symfony\Component\Cache\Adapter\FilesystemAdapter;
+use Symfony\Component\Cache\PruneableInterface;
+use Symfony\Component\Cache\Tests\Fixtures\ExternalAdapter;
+
+/**
+ * @author Kévin Dunglas <dunglas@gmail.com>
+ * @group time-sensitive
+ */
+class ChainAdapterTest extends AdapterTestCase
+{
+    public function createCachePool($defaultLifetime = 0)
+    {
+        return new ChainAdapter(array(new ArrayAdapter($defaultLifetime), new ExternalAdapter(), new FilesystemAdapter('', $defaultLifetime)), $defaultLifetime);
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Cache\Exception\InvalidArgumentException
+     * @expectedExceptionMessage At least one adapter must be specified.
+     */
+    public function testEmptyAdaptersException()
+    {
+        new ChainAdapter(array());
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Cache\Exception\InvalidArgumentException
+     * @expectedExceptionMessage The class "stdClass" does not implement
+     */
+    public function testInvalidAdapterException()
+    {
+        new ChainAdapter(array(new \stdClass()));
+    }
+
+    public function testPrune()
+    {
+        if (isset($this->skippedTests[__FUNCTION__])) {
+            $this->markTestSkipped($this->skippedTests[__FUNCTION__]);
+        }
+
+        $cache = new ChainAdapter(array(
+            $this->getPruneableMock(),
+            $this->getNonPruneableMock(),
+            $this->getPruneableMock(),
+        ));
+        $this->assertTrue($cache->prune());
+
+        $cache = new ChainAdapter(array(
+            $this->getPruneableMock(),
+            $this->getFailingPruneableMock(),
+            $this->getPruneableMock(),
+        ));
+        $this->assertFalse($cache->prune());
+    }
+
+    /**
+     * @return \PHPUnit_Framework_MockObject_MockObject|PruneableCacheInterface
+     */
+    private function getPruneableMock()
+    {
+        $pruneable = $this
+            ->getMockBuilder(PruneableCacheInterface::class)
+            ->getMock();
+
+        $pruneable
+            ->expects($this->atLeastOnce())
+            ->method('prune')
+            ->will($this->returnValue(true));
+
+        return $pruneable;
+    }
+
+    /**
+     * @return \PHPUnit_Framework_MockObject_MockObject|PruneableCacheInterface
+     */
+    private function getFailingPruneableMock()
+    {
+        $pruneable = $this
+            ->getMockBuilder(PruneableCacheInterface::class)
+            ->getMock();
+
+        $pruneable
+            ->expects($this->atLeastOnce())
+            ->method('prune')
+            ->will($this->returnValue(false));
+
+        return $pruneable;
+    }
+
+    /**
+     * @return \PHPUnit_Framework_MockObject_MockObject|AdapterInterface
+     */
+    private function getNonPruneableMock()
+    {
+        return $this
+            ->getMockBuilder(AdapterInterface::class)
+            ->getMock();
+    }
+}
+
+interface PruneableCacheInterface extends PruneableInterface, AdapterInterface
+{
+}

vendor/symfony/cache/Tests/Adapter/DoctrineAdapterTest.php

@@ -0,0 +1,32 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Tests\Adapter;
+
+use Symfony\Component\Cache\Adapter\DoctrineAdapter;
+use Symfony\Component\Cache\Tests\Fixtures\ArrayCache;
+
+/**
+ * @group time-sensitive
+ */
+class DoctrineAdapterTest extends AdapterTestCase
+{
+    protected $skippedTests = array(
+        'testDeferredSaveWithoutCommit' => 'Assumes a shared cache which ArrayCache is not.',
+        'testSaveWithoutExpire' => 'Assumes a shared cache which ArrayCache is not.',
+        'testNotUnserializable' => 'ArrayCache does not use serialize/unserialize',
+    );
+
+    public function createCachePool($defaultLifetime = 0)
+    {
+        return new DoctrineAdapter(new ArrayCache($defaultLifetime), '', $defaultLifetime);
+    }
+}

vendor/symfony/cache/Tests/Adapter/FilesystemAdapterTest.php

@@ -0,0 +1,61 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Tests\Adapter;
+
+use Psr\Cache\CacheItemPoolInterface;
+use Symfony\Component\Cache\Adapter\FilesystemAdapter;
+
+/**
+ * @group time-sensitive
+ */
+class FilesystemAdapterTest extends AdapterTestCase
+{
+    public function createCachePool($defaultLifetime = 0)
+    {
+        return new FilesystemAdapter('', $defaultLifetime);
+    }
+
+    public static function tearDownAfterClass()
+    {
+        self::rmdir(sys_get_temp_dir().'/symfony-cache');
+    }
+
+    public static function rmdir($dir)
+    {
+        if (!file_exists($dir)) {
+            return;
+        }
+        if (!$dir || 0 !== strpos(\dirname($dir), sys_get_temp_dir())) {
+            throw new \Exception(__METHOD__."() operates only on subdirs of system's temp dir");
+        }
+        $children = new \RecursiveIteratorIterator(
+            new \RecursiveDirectoryIterator($dir, \RecursiveDirectoryIterator::SKIP_DOTS),
+            \RecursiveIteratorIterator::CHILD_FIRST
+        );
+        foreach ($children as $child) {
+            if ($child->isDir()) {
+                rmdir($child);
+            } else {
+                unlink($child);
+            }
+        }
+        rmdir($dir);
+    }
+
+    protected function isPruned(CacheItemPoolInterface $cache, $name)
+    {
+        $getFileMethod = (new \ReflectionObject($cache))->getMethod('getFile');
+        $getFileMethod->setAccessible(true);
+
+        return !file_exists($getFileMethod->invoke($cache, $name));
+    }
+}

vendor/symfony/cache/Tests/Adapter/MaxIdLengthAdapterTest.php

@@ -0,0 +1,85 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Tests\Adapter;
+
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Cache\Adapter\AbstractAdapter;
+
+class MaxIdLengthAdapterTest extends TestCase
+{
+    public function testLongKey()
+    {
+        $cache = $this->getMockBuilder(MaxIdLengthAdapter::class)
+            ->setConstructorArgs(array(str_repeat('-', 10)))
+            ->setMethods(array('doHave', 'doFetch', 'doDelete', 'doSave', 'doClear'))
+            ->getMock();
+
+        $cache->expects($this->exactly(2))
+            ->method('doHave')
+            ->withConsecutive(
+                array($this->equalTo('----------:0GTYWa9n4ed8vqNlOT2iEr:')),
+                array($this->equalTo('----------:---------------------------------------'))
+            );
+
+        $cache->hasItem(str_repeat('-', 40));
+        $cache->hasItem(str_repeat('-', 39));
+    }
+
+    public function testLongKeyVersioning()
+    {
+        $cache = $this->getMockBuilder(MaxIdLengthAdapter::class)
+            ->setConstructorArgs(array(str_repeat('-', 26)))
+            ->getMock();
+
+        $reflectionClass = new \ReflectionClass(AbstractAdapter::class);
+
+        $reflectionMethod = $reflectionClass->getMethod('getId');
+        $reflectionMethod->setAccessible(true);
+
+        // No versioning enabled
+        $this->assertEquals('--------------------------:------------', $reflectionMethod->invokeArgs($cache, array(str_repeat('-', 12))));
+        $this->assertLessThanOrEqual(50, \strlen($reflectionMethod->invokeArgs($cache, array(str_repeat('-', 12)))));
+        $this->assertLessThanOrEqual(50, \strlen($reflectionMethod->invokeArgs($cache, array(str_repeat('-', 23)))));
+        $this->assertLessThanOrEqual(50, \strlen($reflectionMethod->invokeArgs($cache, array(str_repeat('-', 40)))));
+
+        $reflectionProperty = $reflectionClass->getProperty('versioningIsEnabled');
+        $reflectionProperty->setAccessible(true);
+        $reflectionProperty->setValue($cache, true);
+
+        // Versioning enabled
+        $this->assertEquals('--------------------------:1:------------', $reflectionMethod->invokeArgs($cache, array(str_repeat('-', 12))));
+        $this->assertLessThanOrEqual(50, \strlen($reflectionMethod->invokeArgs($cache, array(str_repeat('-', 12)))));
+        $this->assertLessThanOrEqual(50, \strlen($reflectionMethod->invokeArgs($cache, array(str_repeat('-', 23)))));
+        $this->assertLessThanOrEqual(50, \strlen($reflectionMethod->invokeArgs($cache, array(str_repeat('-', 40)))));
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Cache\Exception\InvalidArgumentException
+     * @expectedExceptionMessage Namespace must be 26 chars max, 40 given ("----------------------------------------")
+     */
+    public function testTooLongNamespace()
+    {
+        $cache = $this->getMockBuilder(MaxIdLengthAdapter::class)
+            ->setConstructorArgs(array(str_repeat('-', 40)))
+            ->getMock();
+    }
+}
+
+abstract class MaxIdLengthAdapter extends AbstractAdapter
+{
+    protected $maxIdLength = 50;
+
+    public function __construct($ns)
+    {
+        parent::__construct($ns);
+    }
+}

vendor/symfony/cache/Tests/Adapter/MemcachedAdapterTest.php

@@ -0,0 +1,195 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Tests\Adapter;
+
+use Symfony\Component\Cache\Adapter\AbstractAdapter;
+use Symfony\Component\Cache\Adapter\MemcachedAdapter;
+
+class MemcachedAdapterTest extends AdapterTestCase
+{
+    protected $skippedTests = array(
+        'testHasItemReturnsFalseWhenDeferredItemIsExpired' => 'Testing expiration slows down the test suite',
+        'testDefaultLifeTime' => 'Testing expiration slows down the test suite',
+    );
+
+    protected static $client;
+
+    public static function setupBeforeClass()
+    {
+        if (!MemcachedAdapter::isSupported()) {
+            self::markTestSkipped('Extension memcached >=2.2.0 required.');
+        }
+        self::$client = AbstractAdapter::createConnection('memcached://'.getenv('MEMCACHED_HOST'), array('binary_protocol' => false));
+        self::$client->get('foo');
+        $code = self::$client->getResultCode();
+
+        if (\Memcached::RES_SUCCESS !== $code && \Memcached::RES_NOTFOUND !== $code) {
+            self::markTestSkipped('Memcached error: '.strtolower(self::$client->getResultMessage()));
+        }
+    }
+
+    public function createCachePool($defaultLifetime = 0)
+    {
+        $client = $defaultLifetime ? AbstractAdapter::createConnection('memcached://'.getenv('MEMCACHED_HOST')) : self::$client;
+
+        return new MemcachedAdapter($client, str_replace('\\', '.', __CLASS__), $defaultLifetime);
+    }
+
+    public function testOptions()
+    {
+        $client = MemcachedAdapter::createConnection(array(), array(
+            'libketama_compatible' => false,
+            'distribution' => 'modula',
+            'compression' => true,
+            'serializer' => 'php',
+            'hash' => 'md5',
+        ));
+
+        $this->assertSame(\Memcached::SERIALIZER_PHP, $client->getOption(\Memcached::OPT_SERIALIZER));
+        $this->assertSame(\Memcached::HASH_MD5, $client->getOption(\Memcached::OPT_HASH));
+        $this->assertTrue($client->getOption(\Memcached::OPT_COMPRESSION));
+        $this->assertSame(0, $client->getOption(\Memcached::OPT_LIBKETAMA_COMPATIBLE));
+        $this->assertSame(\Memcached::DISTRIBUTION_MODULA, $client->getOption(\Memcached::OPT_DISTRIBUTION));
+    }
+
+    /**
+     * @dataProvider provideBadOptions
+     * @expectedException \ErrorException
+     * @expectedExceptionMessage constant(): Couldn't find constant Memcached::
+     */
+    public function testBadOptions($name, $value)
+    {
+        MemcachedAdapter::createConnection(array(), array($name => $value));
+    }
+
+    public function provideBadOptions()
+    {
+        return array(
+            array('foo', 'bar'),
+            array('hash', 'zyx'),
+            array('serializer', 'zyx'),
+            array('distribution', 'zyx'),
+        );
+    }
+
+    public function testDefaultOptions()
+    {
+        $this->assertTrue(MemcachedAdapter::isSupported());
+
+        $client = MemcachedAdapter::createConnection(array());
+
+        $this->assertTrue($client->getOption(\Memcached::OPT_COMPRESSION));
+        $this->assertSame(1, $client->getOption(\Memcached::OPT_BINARY_PROTOCOL));
+        $this->assertSame(1, $client->getOption(\Memcached::OPT_TCP_NODELAY));
+        $this->assertSame(1, $client->getOption(\Memcached::OPT_LIBKETAMA_COMPATIBLE));
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Cache\Exception\CacheException
+     * @expectedExceptionMessage MemcachedAdapter: "serializer" option must be "php" or "igbinary".
+     */
+    public function testOptionSerializer()
+    {
+        if (!\Memcached::HAVE_JSON) {
+            $this->markTestSkipped('Memcached::HAVE_JSON required');
+        }
+
+        new MemcachedAdapter(MemcachedAdapter::createConnection(array(), array('serializer' => 'json')));
+    }
+
+    /**
+     * @dataProvider provideServersSetting
+     */
+    public function testServersSetting($dsn, $host, $port)
+    {
+        $client1 = MemcachedAdapter::createConnection($dsn);
+        $client2 = MemcachedAdapter::createConnection(array($dsn));
+        $client3 = MemcachedAdapter::createConnection(array(array($host, $port)));
+        $expect = array(
+            'host' => $host,
+            'port' => $port,
+        );
+
+        $f = function ($s) { return array('host' => $s['host'], 'port' => $s['port']); };
+        $this->assertSame(array($expect), array_map($f, $client1->getServerList()));
+        $this->assertSame(array($expect), array_map($f, $client2->getServerList()));
+        $this->assertSame(array($expect), array_map($f, $client3->getServerList()));
+    }
+
+    public function provideServersSetting()
+    {
+        yield array(
+            'memcached://127.0.0.1/50',
+            '127.0.0.1',
+            11211,
+        );
+        yield array(
+            'memcached://localhost:11222?weight=25',
+            'localhost',
+            11222,
+        );
+        if (ini_get('memcached.use_sasl')) {
+            yield array(
+                'memcached://user:password@127.0.0.1?weight=50',
+                '127.0.0.1',
+                11211,
+            );
+        }
+        yield array(
+            'memcached:///var/run/memcached.sock?weight=25',
+            '/var/run/memcached.sock',
+            0,
+        );
+        yield array(
+            'memcached:///var/local/run/memcached.socket?weight=25',
+            '/var/local/run/memcached.socket',
+            0,
+        );
+        if (ini_get('memcached.use_sasl')) {
+            yield array(
+                'memcached://user:password@/var/local/run/memcached.socket?weight=25',
+                '/var/local/run/memcached.socket',
+                0,
+            );
+        }
+    }
+
+    /**
+     * @dataProvider provideDsnWithOptions
+     */
+    public function testDsnWithOptions($dsn, array $options, array $expectedOptions)
+    {
+        $client = MemcachedAdapter::createConnection($dsn, $options);
+
+        foreach ($expectedOptions as $option => $expect) {
+            $this->assertSame($expect, $client->getOption($option));
+        }
+    }
+
+    public function provideDsnWithOptions()
+    {
+        if (!class_exists('\Memcached')) {
+            self::markTestSkipped('Extension memcached required.');
+        }
+
+        yield array(
+            'memcached://localhost:11222?retry_timeout=10',
+            array(\Memcached::OPT_RETRY_TIMEOUT => 8),
+            array(\Memcached::OPT_RETRY_TIMEOUT => 10),
+        );
+        yield array(
+            'memcached://localhost:11222?socket_recv_size=1&socket_send_size=2',
+            array(\Memcached::OPT_RETRY_TIMEOUT => 8),
+            array(\Memcached::OPT_SOCKET_RECV_SIZE => 1, \Memcached::OPT_SOCKET_SEND_SIZE => 2, \Memcached::OPT_RETRY_TIMEOUT => 8),
+        );
+    }
+}

vendor/symfony/cache/Tests/Adapter/NamespacedProxyAdapterTest.php

@@ -0,0 +1,26 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Tests\Adapter;
+
+use Symfony\Component\Cache\Adapter\ArrayAdapter;
+use Symfony\Component\Cache\Adapter\ProxyAdapter;
+
+/**
+ * @group time-sensitive
+ */
+class NamespacedProxyAdapterTest extends ProxyAdapterTest
+{
+    public function createCachePool($defaultLifetime = 0)
+    {
+        return new ProxyAdapter(new ArrayAdapter($defaultLifetime), 'foo', $defaultLifetime);
+    }
+}

vendor/symfony/cache/Tests/Adapter/NullAdapterTest.php

@@ -0,0 +1,128 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Tests\Adapter;
+
+use PHPUnit\Framework\TestCase;
+use Psr\Cache\CacheItemInterface;
+use Symfony\Component\Cache\Adapter\NullAdapter;
+
+/**
+ * @group time-sensitive
+ */
+class NullAdapterTest extends TestCase
+{
+    public function createCachePool()
+    {
+        return new NullAdapter();
+    }
+
+    public function testGetItem()
+    {
+        $adapter = $this->createCachePool();
+
+        $item = $adapter->getItem('key');
+        $this->assertFalse($item->isHit());
+        $this->assertNull($item->get(), "Item's value must be null when isHit is false.");
+    }
+
+    public function testHasItem()
+    {
+        $this->assertFalse($this->createCachePool()->hasItem('key'));
+    }
+
+    public function testGetItems()
+    {
+        $adapter = $this->createCachePool();
+
+        $keys = array('foo', 'bar', 'baz', 'biz');
+
+        /** @var CacheItemInterface[] $items */
+        $items = $adapter->getItems($keys);
+        $count = 0;
+
+        foreach ($items as $key => $item) {
+            $itemKey = $item->getKey();
+
+            $this->assertEquals($itemKey, $key, 'Keys must be preserved when fetching multiple items');
+            $this->assertContains($key, $keys, 'Cache key can not change.');
+            $this->assertFalse($item->isHit());
+
+            // Remove $key for $keys
+            foreach ($keys as $k => $v) {
+                if ($v === $key) {
+                    unset($keys[$k]);
+                }
+            }
+
+            ++$count;
+        }
+
+        $this->assertSame(4, $count);
+    }
+
+    public function testIsHit()
+    {
+        $adapter = $this->createCachePool();
+
+        $item = $adapter->getItem('key');
+        $this->assertFalse($item->isHit());
+    }
+
+    public function testClear()
+    {
+        $this->assertTrue($this->createCachePool()->clear());
+    }
+
+    public function testDeleteItem()
+    {
+        $this->assertTrue($this->createCachePool()->deleteItem('key'));
+    }
+
+    public function testDeleteItems()
+    {
+        $this->assertTrue($this->createCachePool()->deleteItems(array('key', 'foo', 'bar')));
+    }
+
+    public function testSave()
+    {
+        $adapter = $this->createCachePool();
+
+        $item = $adapter->getItem('key');
+        $this->assertFalse($item->isHit());
+        $this->assertNull($item->get(), "Item's value must be null when isHit is false.");
+
+        $this->assertFalse($adapter->save($item));
+    }
+
+    public function testDeferredSave()
+    {
+        $adapter = $this->createCachePool();
+
+        $item = $adapter->getItem('key');
+        $this->assertFalse($item->isHit());
+        $this->assertNull($item->get(), "Item's value must be null when isHit is false.");
+
+        $this->assertFalse($adapter->saveDeferred($item));
+    }
+
+    public function testCommit()
+    {
+        $adapter = $this->createCachePool();
+
+        $item = $adapter->getItem('key');
+        $this->assertFalse($item->isHit());
+        $this->assertNull($item->get(), "Item's value must be null when isHit is false.");
+
+        $this->assertFalse($adapter->saveDeferred($item));
+        $this->assertFalse($this->createCachePool()->commit());
+    }
+}

vendor/symfony/cache/Tests/Adapter/PdoAdapterTest.php

@@ -0,0 +1,73 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Tests\Adapter;
+
+use Symfony\Component\Cache\Adapter\PdoAdapter;
+use Symfony\Component\Cache\Tests\Traits\PdoPruneableTrait;
+
+/**
+ * @group time-sensitive
+ */
+class PdoAdapterTest extends AdapterTestCase
+{
+    use PdoPruneableTrait;
+
+    protected static $dbFile;
+
+    public static function setupBeforeClass()
+    {
+        if (!\extension_loaded('pdo_sqlite')) {
+            self::markTestSkipped('Extension pdo_sqlite required.');
+        }
+
+        self::$dbFile = tempnam(sys_get_temp_dir(), 'sf_sqlite_cache');
+
+        $pool = new PdoAdapter('sqlite:'.self::$dbFile);
+        $pool->createTable();
+    }
+
+    public static function tearDownAfterClass()
+    {
+        @unlink(self::$dbFile);
+    }
+
+    public function createCachePool($defaultLifetime = 0)
+    {
+        return new PdoAdapter('sqlite:'.self::$dbFile, 'ns', $defaultLifetime);
+    }
+
+    public function testCleanupExpiredItems()
+    {
+        $pdo = new \PDO('sqlite:'.self::$dbFile);
+
+        $getCacheItemCount = function () use ($pdo) {
+            return (int) $pdo->query('SELECT COUNT(*) FROM cache_items')->fetch(\PDO::FETCH_COLUMN);
+        };
+
+        $this->assertSame(0, $getCacheItemCount());
+
+        $cache = $this->createCachePool();
+
+        $item = $cache->getItem('some_nice_key');
+        $item->expiresAfter(1);
+        $item->set(1);
+
+        $cache->save($item);
+        $this->assertSame(1, $getCacheItemCount());
+
+        sleep(2);
+
+        $newItem = $cache->getItem($item->getKey());
+        $this->assertFalse($newItem->isHit());
+        $this->assertSame(0, $getCacheItemCount(), 'PDOAdapter must clean up expired items');
+    }
+}

vendor/symfony/cache/Tests/Adapter/PdoDbalAdapterTest.php

@@ -0,0 +1,48 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Tests\Adapter;
+
+use Doctrine\DBAL\DriverManager;
+use Symfony\Component\Cache\Adapter\PdoAdapter;
+use Symfony\Component\Cache\Tests\Traits\PdoPruneableTrait;
+
+/**
+ * @group time-sensitive
+ */
+class PdoDbalAdapterTest extends AdapterTestCase
+{
+    use PdoPruneableTrait;
+
+    protected static $dbFile;
+
+    public static function setupBeforeClass()
+    {
+        if (!\extension_loaded('pdo_sqlite')) {
+            self::markTestSkipped('Extension pdo_sqlite required.');
+        }
+
+        self::$dbFile = tempnam(sys_get_temp_dir(), 'sf_sqlite_cache');
+
+        $pool = new PdoAdapter(DriverManager::getConnection(array('driver' => 'pdo_sqlite', 'path' => self::$dbFile)));
+        $pool->createTable();
+    }
+
+    public static function tearDownAfterClass()
+    {
+        @unlink(self::$dbFile);
+    }
+
+    public function createCachePool($defaultLifetime = 0)
+    {
+        return new PdoAdapter(DriverManager::getConnection(array('driver' => 'pdo_sqlite', 'path' => self::$dbFile)), '', $defaultLifetime);
+    }
+}

vendor/symfony/cache/Tests/Adapter/PhpArrayAdapterTest.php

@@ -0,0 +1,133 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Tests\Adapter;
+
+use Psr\Cache\CacheItemInterface;
+use Symfony\Component\Cache\Adapter\NullAdapter;
+use Symfony\Component\Cache\Adapter\PhpArrayAdapter;
+
+/**
+ * @group time-sensitive
+ */
+class PhpArrayAdapterTest extends AdapterTestCase
+{
+    protected $skippedTests = array(
+        'testBasicUsage' => 'PhpArrayAdapter is read-only.',
+        'testBasicUsageWithLongKey' => 'PhpArrayAdapter is read-only.',
+        'testClear' => 'PhpArrayAdapter is read-only.',
+        'testClearWithDeferredItems' => 'PhpArrayAdapter is read-only.',
+        'testDeleteItem' => 'PhpArrayAdapter is read-only.',
+        'testSaveExpired' => 'PhpArrayAdapter is read-only.',
+        'testSaveWithoutExpire' => 'PhpArrayAdapter is read-only.',
+        'testDeferredSave' => 'PhpArrayAdapter is read-only.',
+        'testDeferredSaveWithoutCommit' => 'PhpArrayAdapter is read-only.',
+        'testDeleteItems' => 'PhpArrayAdapter is read-only.',
+        'testDeleteDeferredItem' => 'PhpArrayAdapter is read-only.',
+        'testCommit' => 'PhpArrayAdapter is read-only.',
+        'testSaveDeferredWhenChangingValues' => 'PhpArrayAdapter is read-only.',
+        'testSaveDeferredOverwrite' => 'PhpArrayAdapter is read-only.',
+        'testIsHitDeferred' => 'PhpArrayAdapter is read-only.',
+
+        'testExpiresAt' => 'PhpArrayAdapter does not support expiration.',
+        'testExpiresAtWithNull' => 'PhpArrayAdapter does not support expiration.',
+        'testExpiresAfterWithNull' => 'PhpArrayAdapter does not support expiration.',
+        'testDeferredExpired' => 'PhpArrayAdapter does not support expiration.',
+        'testExpiration' => 'PhpArrayAdapter does not support expiration.',
+
+        'testGetItemInvalidKeys' => 'PhpArrayAdapter does not throw exceptions on invalid key.',
+        'testGetItemsInvalidKeys' => 'PhpArrayAdapter does not throw exceptions on invalid key.',
+        'testHasItemInvalidKeys' => 'PhpArrayAdapter does not throw exceptions on invalid key.',
+        'testDeleteItemInvalidKeys' => 'PhpArrayAdapter does not throw exceptions on invalid key.',
+        'testDeleteItemsInvalidKeys' => 'PhpArrayAdapter does not throw exceptions on invalid key.',
+
+        'testDefaultLifeTime' => 'PhpArrayAdapter does not allow configuring a default lifetime.',
+        'testPrune' => 'PhpArrayAdapter just proxies',
+    );
+
+    protected static $file;
+
+    public static function setupBeforeClass()
+    {
+        self::$file = sys_get_temp_dir().'/symfony-cache/php-array-adapter-test.php';
+    }
+
+    protected function tearDown()
+    {
+        if (file_exists(sys_get_temp_dir().'/symfony-cache')) {
+            FilesystemAdapterTest::rmdir(sys_get_temp_dir().'/symfony-cache');
+        }
+    }
+
+    public function createCachePool()
+    {
+        return new PhpArrayAdapterWrapper(self::$file, new NullAdapter());
+    }
+
+    public function testStore()
+    {
+        $arrayWithRefs = array();
+        $arrayWithRefs[0] = 123;
+        $arrayWithRefs[1] = &$arrayWithRefs[0];
+
+        $object = (object) array(
+            'foo' => 'bar',
+            'foo2' => 'bar2',
+        );
+
+        $expected = array(
+            'null' => null,
+            'serializedString' => serialize($object),
+            'arrayWithRefs' => $arrayWithRefs,
+            'object' => $object,
+            'arrayWithObject' => array('bar' => $object),
+        );
+
+        $adapter = $this->createCachePool();
+        $adapter->warmUp($expected);
+
+        foreach ($expected as $key => $value) {
+            $this->assertSame(serialize($value), serialize($adapter->getItem($key)->get()), 'Warm up should create a PHP file that OPCache can load in memory');
+        }
+    }
+
+    public function testStoredFile()
+    {
+        $expected = array(
+            'integer' => 42,
+            'float' => 42.42,
+            'boolean' => true,
+            'array_simple' => array('foo', 'bar'),
+            'array_associative' => array('foo' => 'bar', 'foo2' => 'bar2'),
+        );
+
+        $adapter = $this->createCachePool();
+        $adapter->warmUp($expected);
+
+        $values = eval(substr(file_get_contents(self::$file), 6));
+
+        $this->assertSame($expected, $values, 'Warm up should create a PHP file that OPCache can load in memory');
+    }
+}
+
+class PhpArrayAdapterWrapper extends PhpArrayAdapter
+{
+    public function save(CacheItemInterface $item)
+    {
+        \call_user_func(\Closure::bind(function () use ($item) {
+            $this->values[$item->getKey()] = $item->get();
+            $this->warmUp($this->values);
+            $this->values = eval(substr(file_get_contents($this->file), 6));
+        }, $this, PhpArrayAdapter::class));
+
+        return true;
+    }
+}

vendor/symfony/cache/Tests/Adapter/PhpArrayAdapterWithFallbackTest.php

@@ -0,0 +1,49 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Tests\Adapter;
+
+use Symfony\Component\Cache\Adapter\FilesystemAdapter;
+use Symfony\Component\Cache\Adapter\PhpArrayAdapter;
+
+/**
+ * @group time-sensitive
+ */
+class PhpArrayAdapterWithFallbackTest extends AdapterTestCase
+{
+    protected $skippedTests = array(
+        'testGetItemInvalidKeys' => 'PhpArrayAdapter does not throw exceptions on invalid key.',
+        'testGetItemsInvalidKeys' => 'PhpArrayAdapter does not throw exceptions on invalid key.',
+        'testHasItemInvalidKeys' => 'PhpArrayAdapter does not throw exceptions on invalid key.',
+        'testDeleteItemInvalidKeys' => 'PhpArrayAdapter does not throw exceptions on invalid key.',
+        'testDeleteItemsInvalidKeys' => 'PhpArrayAdapter does not throw exceptions on invalid key.',
+        'testPrune' => 'PhpArrayAdapter just proxies',
+    );
+
+    protected static $file;
+
+    public static function setupBeforeClass()
+    {
+        self::$file = sys_get_temp_dir().'/symfony-cache/php-array-adapter-test.php';
+    }
+
+    protected function tearDown()
+    {
+        if (file_exists(sys_get_temp_dir().'/symfony-cache')) {
+            FilesystemAdapterTest::rmdir(sys_get_temp_dir().'/symfony-cache');
+        }
+    }
+
+    public function createCachePool($defaultLifetime = 0)
+    {
+        return new PhpArrayAdapter(self::$file, new FilesystemAdapter('php-array-fallback', $defaultLifetime));
+    }
+}

vendor/symfony/cache/Tests/Adapter/PhpFilesAdapterTest.php

@@ -0,0 +1,47 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Tests\Adapter;
+
+use Psr\Cache\CacheItemPoolInterface;
+use Symfony\Component\Cache\Adapter\PhpFilesAdapter;
+
+/**
+ * @group time-sensitive
+ */
+class PhpFilesAdapterTest extends AdapterTestCase
+{
+    protected $skippedTests = array(
+        'testDefaultLifeTime' => 'PhpFilesAdapter does not allow configuring a default lifetime.',
+    );
+
+    public function createCachePool()
+    {
+        if (!PhpFilesAdapter::isSupported()) {
+            $this->markTestSkipped('OPcache extension is not enabled.');
+        }
+
+        return new PhpFilesAdapter('sf-cache');
+    }
+
+    public static function tearDownAfterClass()
+    {
+        FilesystemAdapterTest::rmdir(sys_get_temp_dir().'/symfony-cache');
+    }
+
+    protected function isPruned(CacheItemPoolInterface $cache, $name)
+    {
+        $getFileMethod = (new \ReflectionObject($cache))->getMethod('getFile');
+        $getFileMethod->setAccessible(true);
+
+        return !file_exists($getFileMethod->invoke($cache, $name));
+    }
+}

vendor/symfony/cache/Tests/Adapter/PredisAdapterTest.php

@@ -0,0 +1,53 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Tests\Adapter;
+
+use Predis\Connection\StreamConnection;
+use Symfony\Component\Cache\Adapter\RedisAdapter;
+
+class PredisAdapterTest extends AbstractRedisAdapterTest
+{
+    public static function setupBeforeClass()
+    {
+        parent::setupBeforeClass();
+        self::$redis = new \Predis\Client(array('host' => getenv('REDIS_HOST')));
+    }
+
+    public function testCreateConnection()
+    {
+        $redisHost = getenv('REDIS_HOST');
+
+        $redis = RedisAdapter::createConnection('redis://'.$redisHost.'/1', array('class' => \Predis\Client::class, 'timeout' => 3));
+        $this->assertInstanceOf(\Predis\Client::class, $redis);
+
+        $connection = $redis->getConnection();
+        $this->assertInstanceOf(StreamConnection::class, $connection);
+
+        $params = array(
+            'scheme' => 'tcp',
+            'host' => $redisHost,
+            'path' => '',
+            'dbindex' => '1',
+            'port' => 6379,
+            'class' => 'Predis\Client',
+            'timeout' => 3,
+            'persistent' => 0,
+            'persistent_id' => null,
+            'read_timeout' => 0,
+            'retry_interval' => 0,
+            'lazy' => false,
+            'database' => '1',
+            'password' => null,
+        );
+        $this->assertSame($params, $connection->getParameters()->toArray());
+    }
+}

vendor/symfony/cache/Tests/Adapter/PredisClusterAdapterTest.php

@@ -0,0 +1,26 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Tests\Adapter;
+
+class PredisClusterAdapterTest extends AbstractRedisAdapterTest
+{
+    public static function setupBeforeClass()
+    {
+        parent::setupBeforeClass();
+        self::$redis = new \Predis\Client(array(array('host' => getenv('REDIS_HOST'))));
+    }
+
+    public static function tearDownAfterClass()
+    {
+        self::$redis = null;
+    }
+}

vendor/symfony/cache/Tests/Adapter/ProxyAdapterTest.php

@@ -0,0 +1,71 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Tests\Adapter;
+
+use Psr\Cache\CacheItemInterface;
+use Symfony\Component\Cache\Adapter\ArrayAdapter;
+use Symfony\Component\Cache\Adapter\ProxyAdapter;
+use Symfony\Component\Cache\CacheItem;
+
+/**
+ * @group time-sensitive
+ */
+class ProxyAdapterTest extends AdapterTestCase
+{
+    protected $skippedTests = array(
+        'testDeferredSaveWithoutCommit' => 'Assumes a shared cache which ArrayAdapter is not.',
+        'testSaveWithoutExpire' => 'Assumes a shared cache which ArrayAdapter is not.',
+        'testPrune' => 'ProxyAdapter just proxies',
+    );
+
+    public function createCachePool($defaultLifetime = 0)
+    {
+        return new ProxyAdapter(new ArrayAdapter(), '', $defaultLifetime);
+    }
+
+    /**
+     * @expectedException \Exception
+     * @expectedExceptionMessage OK bar
+     */
+    public function testProxyfiedItem()
+    {
+        $item = new CacheItem();
+        $pool = new ProxyAdapter(new TestingArrayAdapter($item));
+
+        $proxyItem = $pool->getItem('foo');
+
+        $this->assertNotSame($item, $proxyItem);
+        $pool->save($proxyItem->set('bar'));
+    }
+}
+
+class TestingArrayAdapter extends ArrayAdapter
+{
+    private $item;
+
+    public function __construct(CacheItemInterface $item)
+    {
+        $this->item = $item;
+    }
+
+    public function getItem($key)
+    {
+        return $this->item;
+    }
+
+    public function save(CacheItemInterface $item)
+    {
+        if ($item === $this->item) {
+            throw new \Exception('OK '.$item->get());
+        }
+    }
+}

vendor/symfony/cache/Tests/Adapter/RedisAdapterTest.php

@@ -0,0 +1,92 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Tests\Adapter;
+
+use Symfony\Component\Cache\Adapter\AbstractAdapter;
+use Symfony\Component\Cache\Adapter\RedisAdapter;
+use Symfony\Component\Cache\Traits\RedisProxy;
+
+class RedisAdapterTest extends AbstractRedisAdapterTest
+{
+    public static function setupBeforeClass()
+    {
+        parent::setupBeforeClass();
+        self::$redis = AbstractAdapter::createConnection('redis://'.getenv('REDIS_HOST'), array('lazy' => true));
+    }
+
+    public function createCachePool($defaultLifetime = 0)
+    {
+        $adapter = parent::createCachePool($defaultLifetime);
+        $this->assertInstanceOf(RedisProxy::class, self::$redis);
+
+        return $adapter;
+    }
+
+    public function testCreateConnection()
+    {
+        $redisHost = getenv('REDIS_HOST');
+
+        $redis = RedisAdapter::createConnection('redis://'.$redisHost);
+        $this->assertInstanceOf(\Redis::class, $redis);
+        $this->assertTrue($redis->isConnected());
+        $this->assertSame(0, $redis->getDbNum());
+
+        $redis = RedisAdapter::createConnection('redis://'.$redisHost.'/2');
+        $this->assertSame(2, $redis->getDbNum());
+
+        $redis = RedisAdapter::createConnection('redis://'.$redisHost, array('timeout' => 3));
+        $this->assertEquals(3, $redis->getTimeout());
+
+        $redis = RedisAdapter::createConnection('redis://'.$redisHost.'?timeout=4');
+        $this->assertEquals(4, $redis->getTimeout());
+
+        $redis = RedisAdapter::createConnection('redis://'.$redisHost, array('read_timeout' => 5));
+        $this->assertEquals(5, $redis->getReadTimeout());
+    }
+
+    /**
+     * @dataProvider provideFailedCreateConnection
+     * @expectedException \Symfony\Component\Cache\Exception\InvalidArgumentException
+     * @expectedExceptionMessage Redis connection failed
+     */
+    public function testFailedCreateConnection($dsn)
+    {
+        RedisAdapter::createConnection($dsn);
+    }
+
+    public function provideFailedCreateConnection()
+    {
+        return array(
+            array('redis://localhost:1234'),
+            array('redis://foo@localhost'),
+            array('redis://localhost/123'),
+        );
+    }
+
+    /**
+     * @dataProvider provideInvalidCreateConnection
+     * @expectedException \Symfony\Component\Cache\Exception\InvalidArgumentException
+     * @expectedExceptionMessage Invalid Redis DSN
+     */
+    public function testInvalidCreateConnection($dsn)
+    {
+        RedisAdapter::createConnection($dsn);
+    }
+
+    public function provideInvalidCreateConnection()
+    {
+        return array(
+            array('foo://localhost'),
+            array('redis://'),
+        );
+    }
+}

vendor/symfony/cache/Tests/Adapter/RedisArrayAdapterTest.php

@@ -0,0 +1,24 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Tests\Adapter;
+
+class RedisArrayAdapterTest extends AbstractRedisAdapterTest
+{
+    public static function setupBeforeClass()
+    {
+        parent::setupBeforeClass();
+        if (!class_exists('RedisArray')) {
+            self::markTestSkipped('The RedisArray class is required.');
+        }
+        self::$redis = new \RedisArray(array(getenv('REDIS_HOST')), array('lazy_connect' => true));
+    }
+}

vendor/symfony/cache/Tests/Adapter/RedisClusterAdapterTest.php

@@ -0,0 +1,27 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Tests\Adapter;
+
+class RedisClusterAdapterTest extends AbstractRedisAdapterTest
+{
+    public static function setupBeforeClass()
+    {
+        if (!class_exists('RedisCluster')) {
+            self::markTestSkipped('The RedisCluster class is required.');
+        }
+        if (!$hosts = getenv('REDIS_CLUSTER_HOSTS')) {
+            self::markTestSkipped('REDIS_CLUSTER_HOSTS env var is not defined.');
+        }
+
+        self::$redis = new \RedisCluster(null, explode(' ', $hosts));
+    }
+}

vendor/symfony/cache/Tests/Adapter/SimpleCacheAdapterTest.php

@@ -0,0 +1,30 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Tests\Adapter;
+
+use Symfony\Component\Cache\Adapter\SimpleCacheAdapter;
+use Symfony\Component\Cache\Simple\FilesystemCache;
+
+/**
+ * @group time-sensitive
+ */
+class SimpleCacheAdapterTest extends AdapterTestCase
+{
+    protected $skippedTests = array(
+        'testPrune' => 'SimpleCache just proxies',
+    );
+
+    public function createCachePool($defaultLifetime = 0)
+    {
+        return new SimpleCacheAdapter(new FilesystemCache(), '', $defaultLifetime);
+    }
+}

vendor/symfony/cache/Tests/Adapter/TagAwareAdapterTest.php

@@ -0,0 +1,207 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Tests\Adapter;
+
+use Symfony\Component\Cache\Adapter\AdapterInterface;
+use Symfony\Component\Cache\Adapter\FilesystemAdapter;
+use Symfony\Component\Cache\Adapter\TagAwareAdapter;
+
+/**
+ * @group time-sensitive
+ */
+class TagAwareAdapterTest extends AdapterTestCase
+{
+    public function createCachePool($defaultLifetime = 0)
+    {
+        return new TagAwareAdapter(new FilesystemAdapter('', $defaultLifetime));
+    }
+
+    public static function tearDownAfterClass()
+    {
+        FilesystemAdapterTest::rmdir(sys_get_temp_dir().'/symfony-cache');
+    }
+
+    /**
+     * @expectedException \Psr\Cache\InvalidArgumentException
+     */
+    public function testInvalidTag()
+    {
+        $pool = $this->createCachePool();
+        $item = $pool->getItem('foo');
+        $item->tag(':');
+    }
+
+    public function testInvalidateTags()
+    {
+        $pool = $this->createCachePool();
+
+        $i0 = $pool->getItem('i0');
+        $i1 = $pool->getItem('i1');
+        $i2 = $pool->getItem('i2');
+        $i3 = $pool->getItem('i3');
+        $foo = $pool->getItem('foo');
+
+        $pool->save($i0->tag('bar'));
+        $pool->save($i1->tag('foo'));
+        $pool->save($i2->tag('foo')->tag('bar'));
+        $pool->save($i3->tag('foo')->tag('baz'));
+        $pool->save($foo);
+
+        $pool->invalidateTags(array('bar'));
+
+        $this->assertFalse($pool->getItem('i0')->isHit());
+        $this->assertTrue($pool->getItem('i1')->isHit());
+        $this->assertFalse($pool->getItem('i2')->isHit());
+        $this->assertTrue($pool->getItem('i3')->isHit());
+        $this->assertTrue($pool->getItem('foo')->isHit());
+
+        $pool->invalidateTags(array('foo'));
+
+        $this->assertFalse($pool->getItem('i1')->isHit());
+        $this->assertFalse($pool->getItem('i3')->isHit());
+        $this->assertTrue($pool->getItem('foo')->isHit());
+
+        $anotherPoolInstance = $this->createCachePool();
+
+        $this->assertFalse($anotherPoolInstance->getItem('i1')->isHit());
+        $this->assertFalse($anotherPoolInstance->getItem('i3')->isHit());
+        $this->assertTrue($anotherPoolInstance->getItem('foo')->isHit());
+    }
+
+    public function testInvalidateCommits()
+    {
+        $pool1 = $this->createCachePool();
+
+        $foo = $pool1->getItem('foo');
+        $foo->tag('tag');
+
+        $pool1->saveDeferred($foo->set('foo'));
+        $pool1->invalidateTags(array('tag'));
+
+        $pool2 = $this->createCachePool();
+        $foo = $pool2->getItem('foo');
+
+        $this->assertTrue($foo->isHit());
+    }
+
+    public function testTagsAreCleanedOnSave()
+    {
+        $pool = $this->createCachePool();
+
+        $i = $pool->getItem('k');
+        $pool->save($i->tag('foo'));
+
+        $i = $pool->getItem('k');
+        $pool->save($i->tag('bar'));
+
+        $pool->invalidateTags(array('foo'));
+        $this->assertTrue($pool->getItem('k')->isHit());
+    }
+
+    public function testTagsAreCleanedOnDelete()
+    {
+        $pool = $this->createCachePool();
+
+        $i = $pool->getItem('k');
+        $pool->save($i->tag('foo'));
+        $pool->deleteItem('k');
+
+        $pool->save($pool->getItem('k'));
+        $pool->invalidateTags(array('foo'));
+
+        $this->assertTrue($pool->getItem('k')->isHit());
+    }
+
+    public function testTagItemExpiry()
+    {
+        $pool = $this->createCachePool(10);
+
+        $item = $pool->getItem('foo');
+        $item->tag(array('baz'));
+        $item->expiresAfter(100);
+
+        $pool->save($item);
+        $pool->invalidateTags(array('baz'));
+        $this->assertFalse($pool->getItem('foo')->isHit());
+
+        sleep(20);
+
+        $this->assertFalse($pool->getItem('foo')->isHit());
+    }
+
+    public function testGetPreviousTags()
+    {
+        $pool = $this->createCachePool();
+
+        $i = $pool->getItem('k');
+        $pool->save($i->tag('foo'));
+
+        $i = $pool->getItem('k');
+        $this->assertSame(array('foo' => 'foo'), $i->getPreviousTags());
+    }
+
+    public function testPrune()
+    {
+        $cache = new TagAwareAdapter($this->getPruneableMock());
+        $this->assertTrue($cache->prune());
+
+        $cache = new TagAwareAdapter($this->getNonPruneableMock());
+        $this->assertFalse($cache->prune());
+
+        $cache = new TagAwareAdapter($this->getFailingPruneableMock());
+        $this->assertFalse($cache->prune());
+    }
+
+    /**
+     * @return \PHPUnit_Framework_MockObject_MockObject|PruneableCacheInterface
+     */
+    private function getPruneableMock()
+    {
+        $pruneable = $this
+            ->getMockBuilder(PruneableCacheInterface::class)
+            ->getMock();
+
+        $pruneable
+            ->expects($this->atLeastOnce())
+            ->method('prune')
+            ->will($this->returnValue(true));
+
+        return $pruneable;
+    }
+
+    /**
+     * @return \PHPUnit_Framework_MockObject_MockObject|PruneableCacheInterface
+     */
+    private function getFailingPruneableMock()
+    {
+        $pruneable = $this
+            ->getMockBuilder(PruneableCacheInterface::class)
+            ->getMock();
+
+        $pruneable
+            ->expects($this->atLeastOnce())
+            ->method('prune')
+            ->will($this->returnValue(false));
+
+        return $pruneable;
+    }
+
+    /**
+     * @return \PHPUnit_Framework_MockObject_MockObject|AdapterInterface
+     */
+    private function getNonPruneableMock()
+    {
+        return $this
+            ->getMockBuilder(AdapterInterface::class)
+            ->getMock();
+    }
+}

vendor/symfony/cache/Tests/Adapter/TraceableAdapterTest.php

@@ -0,0 +1,191 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Tests\Adapter;
+
+use Symfony\Component\Cache\Adapter\FilesystemAdapter;
+use Symfony\Component\Cache\Adapter\TraceableAdapter;
+
+/**
+ * @group time-sensitive
+ */
+class TraceableAdapterTest extends AdapterTestCase
+{
+    protected $skippedTests = array(
+        'testPrune' => 'TraceableAdapter just proxies',
+    );
+
+    public function createCachePool($defaultLifetime = 0)
+    {
+        return new TraceableAdapter(new FilesystemAdapter('', $defaultLifetime));
+    }
+
+    public function testGetItemMissTrace()
+    {
+        $pool = $this->createCachePool();
+        $pool->getItem('k');
+        $calls = $pool->getCalls();
+        $this->assertCount(1, $calls);
+
+        $call = $calls[0];
+        $this->assertSame('getItem', $call->name);
+        $this->assertSame(array('k' => false), $call->result);
+        $this->assertSame(0, $call->hits);
+        $this->assertSame(1, $call->misses);
+        $this->assertNotEmpty($call->start);
+        $this->assertNotEmpty($call->end);
+    }
+
+    public function testGetItemHitTrace()
+    {
+        $pool = $this->createCachePool();
+        $item = $pool->getItem('k')->set('foo');
+        $pool->save($item);
+        $pool->getItem('k');
+        $calls = $pool->getCalls();
+        $this->assertCount(3, $calls);
+
+        $call = $calls[2];
+        $this->assertSame(1, $call->hits);
+        $this->assertSame(0, $call->misses);
+    }
+
+    public function testGetItemsMissTrace()
+    {
+        $pool = $this->createCachePool();
+        $arg = array('k0', 'k1');
+        $items = $pool->getItems($arg);
+        foreach ($items as $item) {
+        }
+        $calls = $pool->getCalls();
+        $this->assertCount(1, $calls);
+
+        $call = $calls[0];
+        $this->assertSame('getItems', $call->name);
+        $this->assertSame(array('k0' => false, 'k1' => false), $call->result);
+        $this->assertSame(2, $call->misses);
+        $this->assertNotEmpty($call->start);
+        $this->assertNotEmpty($call->end);
+    }
+
+    public function testHasItemMissTrace()
+    {
+        $pool = $this->createCachePool();
+        $pool->hasItem('k');
+        $calls = $pool->getCalls();
+        $this->assertCount(1, $calls);
+
+        $call = $calls[0];
+        $this->assertSame('hasItem', $call->name);
+        $this->assertSame(array('k' => false), $call->result);
+        $this->assertNotEmpty($call->start);
+        $this->assertNotEmpty($call->end);
+    }
+
+    public function testHasItemHitTrace()
+    {
+        $pool = $this->createCachePool();
+        $item = $pool->getItem('k')->set('foo');
+        $pool->save($item);
+        $pool->hasItem('k');
+        $calls = $pool->getCalls();
+        $this->assertCount(3, $calls);
+
+        $call = $calls[2];
+        $this->assertSame('hasItem', $call->name);
+        $this->assertSame(array('k' => true), $call->result);
+        $this->assertNotEmpty($call->start);
+        $this->assertNotEmpty($call->end);
+    }
+
+    public function testDeleteItemTrace()
+    {
+        $pool = $this->createCachePool();
+        $pool->deleteItem('k');
+        $calls = $pool->getCalls();
+        $this->assertCount(1, $calls);
+
+        $call = $calls[0];
+        $this->assertSame('deleteItem', $call->name);
+        $this->assertSame(array('k' => true), $call->result);
+        $this->assertSame(0, $call->hits);
+        $this->assertSame(0, $call->misses);
+        $this->assertNotEmpty($call->start);
+        $this->assertNotEmpty($call->end);
+    }
+
+    public function testDeleteItemsTrace()
+    {
+        $pool = $this->createCachePool();
+        $arg = array('k0', 'k1');
+        $pool->deleteItems($arg);
+        $calls = $pool->getCalls();
+        $this->assertCount(1, $calls);
+
+        $call = $calls[0];
+        $this->assertSame('deleteItems', $call->name);
+        $this->assertSame(array('keys' => $arg, 'result' => true), $call->result);
+        $this->assertSame(0, $call->hits);
+        $this->assertSame(0, $call->misses);
+        $this->assertNotEmpty($call->start);
+        $this->assertNotEmpty($call->end);
+    }
+
+    public function testSaveTrace()
+    {
+        $pool = $this->createCachePool();
+        $item = $pool->getItem('k')->set('foo');
+        $pool->save($item);
+        $calls = $pool->getCalls();
+        $this->assertCount(2, $calls);
+
+        $call = $calls[1];
+        $this->assertSame('save', $call->name);
+        $this->assertSame(array('k' => true), $call->result);
+        $this->assertSame(0, $call->hits);
+        $this->assertSame(0, $call->misses);
+        $this->assertNotEmpty($call->start);
+        $this->assertNotEmpty($call->end);
+    }
+
+    public function testSaveDeferredTrace()
+    {
+        $pool = $this->createCachePool();
+        $item = $pool->getItem('k')->set('foo');
+        $pool->saveDeferred($item);
+        $calls = $pool->getCalls();
+        $this->assertCount(2, $calls);
+
+        $call = $calls[1];
+        $this->assertSame('saveDeferred', $call->name);
+        $this->assertSame(array('k' => true), $call->result);
+        $this->assertSame(0, $call->hits);
+        $this->assertSame(0, $call->misses);
+        $this->assertNotEmpty($call->start);
+        $this->assertNotEmpty($call->end);
+    }
+
+    public function testCommitTrace()
+    {
+        $pool = $this->createCachePool();
+        $pool->commit();
+        $calls = $pool->getCalls();
+        $this->assertCount(1, $calls);
+
+        $call = $calls[0];
+        $this->assertSame('commit', $call->name);
+        $this->assertTrue($call->result);
+        $this->assertSame(0, $call->hits);
+        $this->assertSame(0, $call->misses);
+        $this->assertNotEmpty($call->start);
+        $this->assertNotEmpty($call->end);
+    }
+}

vendor/symfony/cache/Tests/Adapter/TraceableTagAwareAdapterTest.php

@@ -0,0 +1,37 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Tests\Adapter;
+
+use Symfony\Component\Cache\Adapter\FilesystemAdapter;
+use Symfony\Component\Cache\Adapter\TagAwareAdapter;
+use Symfony\Component\Cache\Adapter\TraceableTagAwareAdapter;
+
+/**
+ * @group time-sensitive
+ */
+class TraceableTagAwareAdapterTest extends TraceableAdapterTest
+{
+    public function testInvalidateTags()
+    {
+        $pool = new TraceableTagAwareAdapter(new TagAwareAdapter(new FilesystemAdapter()));
+        $pool->invalidateTags(array('foo'));
+        $calls = $pool->getCalls();
+        $this->assertCount(1, $calls);
+
+        $call = $calls[0];
+        $this->assertSame('invalidateTags', $call->name);
+        $this->assertSame(0, $call->hits);
+        $this->assertSame(0, $call->misses);
+        $this->assertNotEmpty($call->start);
+        $this->assertNotEmpty($call->end);
+    }
+}

vendor/symfony/cache/Tests/CacheItemTest.php

@@ -0,0 +1,77 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Tests;
+
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Cache\CacheItem;
+
+class CacheItemTest extends TestCase
+{
+    public function testValidKey()
+    {
+        $this->assertSame('foo', CacheItem::validateKey('foo'));
+    }
+
+    /**
+     * @dataProvider provideInvalidKey
+     * @expectedException \Symfony\Component\Cache\Exception\InvalidArgumentException
+     * @expectedExceptionMessage Cache key
+     */
+    public function testInvalidKey($key)
+    {
+        CacheItem::validateKey($key);
+    }
+
+    public function provideInvalidKey()
+    {
+        return array(
+            array(''),
+            array('{'),
+            array('}'),
+            array('('),
+            array(')'),
+            array('/'),
+            array('\\'),
+            array('@'),
+            array(':'),
+            array(true),
+            array(null),
+            array(1),
+            array(1.1),
+            array(array(array())),
+            array(new \Exception('foo')),
+        );
+    }
+
+    public function testTag()
+    {
+        $item = new CacheItem();
+
+        $this->assertSame($item, $item->tag('foo'));
+        $this->assertSame($item, $item->tag(array('bar', 'baz')));
+
+        \call_user_func(\Closure::bind(function () use ($item) {
+            $this->assertSame(array('foo' => 'foo', 'bar' => 'bar', 'baz' => 'baz'), $item->tags);
+        }, $this, CacheItem::class));
+    }
+
+    /**
+     * @dataProvider provideInvalidKey
+     * @expectedException \Symfony\Component\Cache\Exception\InvalidArgumentException
+     * @expectedExceptionMessage Cache tag
+     */
+    public function testInvalidTag($tag)
+    {
+        $item = new CacheItem();
+        $item->tag($tag);
+    }
+}

vendor/symfony/cache/Tests/DoctrineProviderTest.php

@@ -0,0 +1,45 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Tests;
+
+use Doctrine\Common\Cache\CacheProvider;
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Cache\Adapter\ArrayAdapter;
+use Symfony\Component\Cache\DoctrineProvider;
+
+class DoctrineProviderTest extends TestCase
+{
+    public function testProvider()
+    {
+        $pool = new ArrayAdapter();
+        $cache = new DoctrineProvider($pool);
+
+        $this->assertInstanceOf(CacheProvider::class, $cache);
+
+        $key = '{}()/\@:';
+
+        $this->assertTrue($cache->delete($key));
+        $this->assertFalse($cache->contains($key));
+
+        $this->assertTrue($cache->save($key, 'bar'));
+        $this->assertTrue($cache->contains($key));
+        $this->assertSame('bar', $cache->fetch($key));
+
+        $this->assertTrue($cache->delete($key));
+        $this->assertFalse($cache->fetch($key));
+        $this->assertTrue($cache->save($key, 'bar'));
+
+        $cache->flushAll();
+        $this->assertFalse($cache->fetch($key));
+        $this->assertFalse($cache->contains($key));
+    }
+}

vendor/symfony/cache/Tests/Fixtures/ArrayCache.php

@@ -0,0 +1,52 @@
+<?php
+
+namespace Symfony\Component\Cache\Tests\Fixtures;
+
+use Doctrine\Common\Cache\CacheProvider;
+
+class ArrayCache extends CacheProvider
+{
+    private $data = array();
+
+    protected function doFetch($id)
+    {
+        return $this->doContains($id) ? $this->data[$id][0] : false;
+    }
+
+    protected function doContains($id)
+    {
+        if (!isset($this->data[$id])) {
+            return false;
+        }
+
+        $expiry = $this->data[$id][1];
+
+        return !$expiry || time() < $expiry || !$this->doDelete($id);
+    }
+
+    protected function doSave($id, $data, $lifeTime = 0)
+    {
+        $this->data[$id] = array($data, $lifeTime ? time() + $lifeTime : false);
+
+        return true;
+    }
+
+    protected function doDelete($id)
+    {
+        unset($this->data[$id]);
+
+        return true;
+    }
+
+    protected function doFlush()
+    {
+        $this->data = array();
+
+        return true;
+    }
+
+    protected function doGetStats()
+    {
+        return null;
+    }
+}

vendor/symfony/cache/Tests/Fixtures/ExternalAdapter.php

@@ -0,0 +1,76 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Tests\Fixtures;
+
+use Psr\Cache\CacheItemInterface;
+use Psr\Cache\CacheItemPoolInterface;
+use Symfony\Component\Cache\Adapter\ArrayAdapter;
+
+/**
+ * Adapter not implementing the {@see \Symfony\Component\Cache\Adapter\AdapterInterface}.
+ *
+ * @author Kévin Dunglas <dunglas@gmail.com>
+ */
+class ExternalAdapter implements CacheItemPoolInterface
+{
+    private $cache;
+
+    public function __construct()
+    {
+        $this->cache = new ArrayAdapter();
+    }
+
+    public function getItem($key)
+    {
+        return $this->cache->getItem($key);
+    }
+
+    public function getItems(array $keys = array())
+    {
+        return $this->cache->getItems($keys);
+    }
+
+    public function hasItem($key)
+    {
+        return $this->cache->hasItem($key);
+    }
+
+    public function clear()
+    {
+        return $this->cache->clear();
+    }
+
+    public function deleteItem($key)
+    {
+        return $this->cache->deleteItem($key);
+    }
+
+    public function deleteItems(array $keys)
+    {
+        return $this->cache->deleteItems($keys);
+    }
+
+    public function save(CacheItemInterface $item)
+    {
+        return $this->cache->save($item);
+    }
+
+    public function saveDeferred(CacheItemInterface $item)
+    {
+        return $this->cache->saveDeferred($item);
+    }
+
+    public function commit()
+    {
+        return $this->cache->commit();
+    }
+}

vendor/symfony/cache/Tests/Simple/AbstractRedisCacheTest.php

@@ -0,0 +1,46 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Tests\Simple;
+
+use Symfony\Component\Cache\Simple\RedisCache;
+
+abstract class AbstractRedisCacheTest extends CacheTestCase
+{
+    protected $skippedTests = array(
+        'testSetTtl' => 'Testing expiration slows down the test suite',
+        'testSetMultipleTtl' => 'Testing expiration slows down the test suite',
+        'testDefaultLifeTime' => 'Testing expiration slows down the test suite',
+    );
+
+    protected static $redis;
+
+    public function createSimpleCache($defaultLifetime = 0)
+    {
+        return new RedisCache(self::$redis, str_replace('\\', '.', __CLASS__), $defaultLifetime);
+    }
+
+    public static function setupBeforeClass()
+    {
+        if (!\extension_loaded('redis')) {
+            self::markTestSkipped('Extension redis required.');
+        }
+        if (!@((new \Redis())->connect(getenv('REDIS_HOST')))) {
+            $e = error_get_last();
+            self::markTestSkipped($e['message']);
+        }
+    }
+
+    public static function tearDownAfterClass()
+    {
+        self::$redis = null;
+    }
+}

vendor/symfony/cache/Tests/Simple/ApcuCacheTest.php

@@ -0,0 +1,35 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Tests\Simple;
+
+use Symfony\Component\Cache\Simple\ApcuCache;
+
+class ApcuCacheTest extends CacheTestCase
+{
+    protected $skippedTests = array(
+        'testSetTtl' => 'Testing expiration slows down the test suite',
+        'testSetMultipleTtl' => 'Testing expiration slows down the test suite',
+        'testDefaultLifeTime' => 'Testing expiration slows down the test suite',
+    );
+
+    public function createSimpleCache($defaultLifetime = 0)
+    {
+        if (!\function_exists('apcu_fetch') || !ini_get('apc.enabled') || ('cli' === \PHP_SAPI && !ini_get('apc.enable_cli'))) {
+            $this->markTestSkipped('APCu extension is required.');
+        }
+        if ('\\' === \DIRECTORY_SEPARATOR) {
+            $this->markTestSkipped('Fails transiently on Windows.');
+        }
+
+        return new ApcuCache(str_replace('\\', '.', __CLASS__), $defaultLifetime);
+    }
+}

vendor/symfony/cache/Tests/Simple/ArrayCacheTest.php

@@ -0,0 +1,25 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Tests\Simple;
+
+use Symfony\Component\Cache\Simple\ArrayCache;
+
+/**
+ * @group time-sensitive
+ */
+class ArrayCacheTest extends CacheTestCase
+{
+    public function createSimpleCache($defaultLifetime = 0)
+    {
+        return new ArrayCache($defaultLifetime);
+    }
+}

vendor/symfony/cache/Tests/Simple/CacheTestCase.php

@@ -0,0 +1,146 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Tests\Simple;
+
+use Cache\IntegrationTests\SimpleCacheTest;
+use Psr\SimpleCache\CacheInterface;
+use Symfony\Component\Cache\PruneableInterface;
+
+abstract class CacheTestCase extends SimpleCacheTest
+{
+    protected function setUp()
+    {
+        parent::setUp();
+
+        if (!array_key_exists('testPrune', $this->skippedTests) && !$this->createSimpleCache() instanceof PruneableInterface) {
+            $this->skippedTests['testPrune'] = 'Not a pruneable cache pool.';
+        }
+    }
+
+    public static function validKeys()
+    {
+        return array_merge(parent::validKeys(), array(array("a\0b")));
+    }
+
+    public function testDefaultLifeTime()
+    {
+        if (isset($this->skippedTests[__FUNCTION__])) {
+            $this->markTestSkipped($this->skippedTests[__FUNCTION__]);
+        }
+
+        $cache = $this->createSimpleCache(2);
+        $cache->clear();
+
+        $cache->set('key.dlt', 'value');
+        sleep(1);
+
+        $this->assertSame('value', $cache->get('key.dlt'));
+
+        sleep(2);
+        $this->assertNull($cache->get('key.dlt'));
+
+        $cache->clear();
+    }
+
+    public function testNotUnserializable()
+    {
+        if (isset($this->skippedTests[__FUNCTION__])) {
+            $this->markTestSkipped($this->skippedTests[__FUNCTION__]);
+        }
+
+        $cache = $this->createSimpleCache();
+        $cache->clear();
+
+        $cache->set('foo', new NotUnserializable());
+
+        $this->assertNull($cache->get('foo'));
+
+        $cache->setMultiple(array('foo' => new NotUnserializable()));
+
+        foreach ($cache->getMultiple(array('foo')) as $value) {
+        }
+        $this->assertNull($value);
+
+        $cache->clear();
+    }
+
+    public function testPrune()
+    {
+        if (isset($this->skippedTests[__FUNCTION__])) {
+            $this->markTestSkipped($this->skippedTests[__FUNCTION__]);
+        }
+
+        if (!method_exists($this, 'isPruned')) {
+            $this->fail('Test classes for pruneable caches must implement `isPruned($cache, $name)` method.');
+        }
+
+        /** @var PruneableInterface|CacheInterface $cache */
+        $cache = $this->createSimpleCache();
+        $cache->clear();
+
+        $cache->set('foo', 'foo-val', new \DateInterval('PT05S'));
+        $cache->set('bar', 'bar-val', new \DateInterval('PT10S'));
+        $cache->set('baz', 'baz-val', new \DateInterval('PT15S'));
+        $cache->set('qux', 'qux-val', new \DateInterval('PT20S'));
+
+        sleep(30);
+        $cache->prune();
+        $this->assertTrue($this->isPruned($cache, 'foo'));
+        $this->assertTrue($this->isPruned($cache, 'bar'));
+        $this->assertTrue($this->isPruned($cache, 'baz'));
+        $this->assertTrue($this->isPruned($cache, 'qux'));
+
+        $cache->set('foo', 'foo-val');
+        $cache->set('bar', 'bar-val', new \DateInterval('PT20S'));
+        $cache->set('baz', 'baz-val', new \DateInterval('PT40S'));
+        $cache->set('qux', 'qux-val', new \DateInterval('PT80S'));
+
+        $cache->prune();
+        $this->assertFalse($this->isPruned($cache, 'foo'));
+        $this->assertFalse($this->isPruned($cache, 'bar'));
+        $this->assertFalse($this->isPruned($cache, 'baz'));
+        $this->assertFalse($this->isPruned($cache, 'qux'));
+
+        sleep(30);
+        $cache->prune();
+        $this->assertFalse($this->isPruned($cache, 'foo'));
+        $this->assertTrue($this->isPruned($cache, 'bar'));
+        $this->assertFalse($this->isPruned($cache, 'baz'));
+        $this->assertFalse($this->isPruned($cache, 'qux'));
+
+        sleep(30);
+        $cache->prune();
+        $this->assertFalse($this->isPruned($cache, 'foo'));
+        $this->assertTrue($this->isPruned($cache, 'baz'));
+        $this->assertFalse($this->isPruned($cache, 'qux'));
+
+        sleep(30);
+        $cache->prune();
+        $this->assertFalse($this->isPruned($cache, 'foo'));
+        $this->assertTrue($this->isPruned($cache, 'qux'));
+
+        $cache->clear();
+    }
+}
+
+class NotUnserializable implements \Serializable
+{
+    public function serialize()
+    {
+        return serialize(123);
+    }
+
+    public function unserialize($ser)
+    {
+        throw new \Exception(__CLASS__);
+    }
+}

vendor/symfony/cache/Tests/Simple/ChainCacheTest.php

@@ -0,0 +1,116 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Tests\Simple;
+
+use Psr\SimpleCache\CacheInterface;
+use Symfony\Component\Cache\PruneableInterface;
+use Symfony\Component\Cache\Simple\ArrayCache;
+use Symfony\Component\Cache\Simple\ChainCache;
+use Symfony\Component\Cache\Simple\FilesystemCache;
+
+/**
+ * @group time-sensitive
+ */
+class ChainCacheTest extends CacheTestCase
+{
+    public function createSimpleCache($defaultLifetime = 0)
+    {
+        return new ChainCache(array(new ArrayCache($defaultLifetime), new FilesystemCache('', $defaultLifetime)), $defaultLifetime);
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Cache\Exception\InvalidArgumentException
+     * @expectedExceptionMessage At least one cache must be specified.
+     */
+    public function testEmptyCachesException()
+    {
+        new ChainCache(array());
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Cache\Exception\InvalidArgumentException
+     * @expectedExceptionMessage The class "stdClass" does not implement
+     */
+    public function testInvalidCacheException()
+    {
+        new ChainCache(array(new \stdClass()));
+    }
+
+    public function testPrune()
+    {
+        if (isset($this->skippedTests[__FUNCTION__])) {
+            $this->markTestSkipped($this->skippedTests[__FUNCTION__]);
+        }
+
+        $cache = new ChainCache(array(
+            $this->getPruneableMock(),
+            $this->getNonPruneableMock(),
+            $this->getPruneableMock(),
+        ));
+        $this->assertTrue($cache->prune());
+
+        $cache = new ChainCache(array(
+            $this->getPruneableMock(),
+            $this->getFailingPruneableMock(),
+            $this->getPruneableMock(),
+        ));
+        $this->assertFalse($cache->prune());
+    }
+
+    /**
+     * @return \PHPUnit_Framework_MockObject_MockObject|PruneableCacheInterface
+     */
+    private function getPruneableMock()
+    {
+        $pruneable = $this
+            ->getMockBuilder(PruneableCacheInterface::class)
+            ->getMock();
+
+        $pruneable
+            ->expects($this->atLeastOnce())
+            ->method('prune')
+            ->will($this->returnValue(true));
+
+        return $pruneable;
+    }
+
+    /**
+     * @return \PHPUnit_Framework_MockObject_MockObject|PruneableCacheInterface
+     */
+    private function getFailingPruneableMock()
+    {
+        $pruneable = $this
+            ->getMockBuilder(PruneableCacheInterface::class)
+            ->getMock();
+
+        $pruneable
+            ->expects($this->atLeastOnce())
+            ->method('prune')
+            ->will($this->returnValue(false));
+
+        return $pruneable;
+    }
+
+    /**
+     * @return \PHPUnit_Framework_MockObject_MockObject|CacheInterface
+     */
+    private function getNonPruneableMock()
+    {
+        return $this
+            ->getMockBuilder(CacheInterface::class)
+            ->getMock();
+    }
+}
+
+interface PruneableCacheInterface extends PruneableInterface, CacheInterface
+{
+}

vendor/symfony/cache/Tests/Simple/DoctrineCacheTest.php

@@ -0,0 +1,31 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Tests\Simple;
+
+use Symfony\Component\Cache\Simple\DoctrineCache;
+use Symfony\Component\Cache\Tests\Fixtures\ArrayCache;
+
+/**
+ * @group time-sensitive
+ */
+class DoctrineCacheTest extends CacheTestCase
+{
+    protected $skippedTests = array(
+        'testObjectDoesNotChangeInCache' => 'ArrayCache does not use serialize/unserialize',
+        'testNotUnserializable' => 'ArrayCache does not use serialize/unserialize',
+    );
+
+    public function createSimpleCache($defaultLifetime = 0)
+    {
+        return new DoctrineCache(new ArrayCache($defaultLifetime), '', $defaultLifetime);
+    }
+}

vendor/symfony/cache/Tests/Simple/FilesystemCacheTest.php

@@ -0,0 +1,34 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Tests\Simple;
+
+use Psr\SimpleCache\CacheInterface;
+use Symfony\Component\Cache\Simple\FilesystemCache;
+
+/**
+ * @group time-sensitive
+ */
+class FilesystemCacheTest extends CacheTestCase
+{
+    public function createSimpleCache($defaultLifetime = 0)
+    {
+        return new FilesystemCache('', $defaultLifetime);
+    }
+
+    protected function isPruned(CacheInterface $cache, $name)
+    {
+        $getFileMethod = (new \ReflectionObject($cache))->getMethod('getFile');
+        $getFileMethod->setAccessible(true);
+
+        return !file_exists($getFileMethod->invoke($cache, $name));
+    }
+}

vendor/symfony/cache/Tests/Simple/MemcachedCacheTest.php

@@ -0,0 +1,174 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Tests\Simple;
+
+use Symfony\Component\Cache\Adapter\AbstractAdapter;
+use Symfony\Component\Cache\Simple\MemcachedCache;
+
+class MemcachedCacheTest extends CacheTestCase
+{
+    protected $skippedTests = array(
+        'testSetTtl' => 'Testing expiration slows down the test suite',
+        'testSetMultipleTtl' => 'Testing expiration slows down the test suite',
+        'testDefaultLifeTime' => 'Testing expiration slows down the test suite',
+    );
+
+    protected static $client;
+
+    public static function setupBeforeClass()
+    {
+        if (!MemcachedCache::isSupported()) {
+            self::markTestSkipped('Extension memcached >=2.2.0 required.');
+        }
+        self::$client = AbstractAdapter::createConnection('memcached://'.getenv('MEMCACHED_HOST'));
+        self::$client->get('foo');
+        $code = self::$client->getResultCode();
+
+        if (\Memcached::RES_SUCCESS !== $code && \Memcached::RES_NOTFOUND !== $code) {
+            self::markTestSkipped('Memcached error: '.strtolower(self::$client->getResultMessage()));
+        }
+    }
+
+    public function createSimpleCache($defaultLifetime = 0)
+    {
+        $client = $defaultLifetime ? AbstractAdapter::createConnection('memcached://'.getenv('MEMCACHED_HOST'), array('binary_protocol' => false)) : self::$client;
+
+        return new MemcachedCache($client, str_replace('\\', '.', __CLASS__), $defaultLifetime);
+    }
+
+    public function testCreatePersistentConnectionShouldNotDupServerList()
+    {
+        $instance = MemcachedCache::createConnection('memcached://'.getenv('MEMCACHED_HOST'), array('persistent_id' => 'persistent'));
+        $this->assertCount(1, $instance->getServerList());
+
+        $instance = MemcachedCache::createConnection('memcached://'.getenv('MEMCACHED_HOST'), array('persistent_id' => 'persistent'));
+        $this->assertCount(1, $instance->getServerList());
+    }
+
+    public function testOptions()
+    {
+        $client = MemcachedCache::createConnection(array(), array(
+            'libketama_compatible' => false,
+            'distribution' => 'modula',
+            'compression' => true,
+            'serializer' => 'php',
+            'hash' => 'md5',
+        ));
+
+        $this->assertSame(\Memcached::SERIALIZER_PHP, $client->getOption(\Memcached::OPT_SERIALIZER));
+        $this->assertSame(\Memcached::HASH_MD5, $client->getOption(\Memcached::OPT_HASH));
+        $this->assertTrue($client->getOption(\Memcached::OPT_COMPRESSION));
+        $this->assertSame(0, $client->getOption(\Memcached::OPT_LIBKETAMA_COMPATIBLE));
+        $this->assertSame(\Memcached::DISTRIBUTION_MODULA, $client->getOption(\Memcached::OPT_DISTRIBUTION));
+    }
+
+    /**
+     * @dataProvider provideBadOptions
+     * @expectedException \ErrorException
+     * @expectedExceptionMessage constant(): Couldn't find constant Memcached::
+     */
+    public function testBadOptions($name, $value)
+    {
+        MemcachedCache::createConnection(array(), array($name => $value));
+    }
+
+    public function provideBadOptions()
+    {
+        return array(
+            array('foo', 'bar'),
+            array('hash', 'zyx'),
+            array('serializer', 'zyx'),
+            array('distribution', 'zyx'),
+        );
+    }
+
+    public function testDefaultOptions()
+    {
+        $this->assertTrue(MemcachedCache::isSupported());
+
+        $client = MemcachedCache::createConnection(array());
+
+        $this->assertTrue($client->getOption(\Memcached::OPT_COMPRESSION));
+        $this->assertSame(1, $client->getOption(\Memcached::OPT_BINARY_PROTOCOL));
+        $this->assertSame(1, $client->getOption(\Memcached::OPT_LIBKETAMA_COMPATIBLE));
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Cache\Exception\CacheException
+     * @expectedExceptionMessage MemcachedAdapter: "serializer" option must be "php" or "igbinary".
+     */
+    public function testOptionSerializer()
+    {
+        if (!\Memcached::HAVE_JSON) {
+            $this->markTestSkipped('Memcached::HAVE_JSON required');
+        }
+
+        new MemcachedCache(MemcachedCache::createConnection(array(), array('serializer' => 'json')));
+    }
+
+    /**
+     * @dataProvider provideServersSetting
+     */
+    public function testServersSetting($dsn, $host, $port)
+    {
+        $client1 = MemcachedCache::createConnection($dsn);
+        $client2 = MemcachedCache::createConnection(array($dsn));
+        $client3 = MemcachedCache::createConnection(array(array($host, $port)));
+        $expect = array(
+            'host' => $host,
+            'port' => $port,
+        );
+
+        $f = function ($s) { return array('host' => $s['host'], 'port' => $s['port']); };
+        $this->assertSame(array($expect), array_map($f, $client1->getServerList()));
+        $this->assertSame(array($expect), array_map($f, $client2->getServerList()));
+        $this->assertSame(array($expect), array_map($f, $client3->getServerList()));
+    }
+
+    public function provideServersSetting()
+    {
+        yield array(
+            'memcached://127.0.0.1/50',
+            '127.0.0.1',
+            11211,
+        );
+        yield array(
+            'memcached://localhost:11222?weight=25',
+            'localhost',
+            11222,
+        );
+        if (ini_get('memcached.use_sasl')) {
+            yield array(
+                'memcached://user:password@127.0.0.1?weight=50',
+                '127.0.0.1',
+                11211,
+            );
+        }
+        yield array(
+            'memcached:///var/run/memcached.sock?weight=25',
+            '/var/run/memcached.sock',
+            0,
+        );
+        yield array(
+            'memcached:///var/local/run/memcached.socket?weight=25',
+            '/var/local/run/memcached.socket',
+            0,
+        );
+        if (ini_get('memcached.use_sasl')) {
+            yield array(
+                'memcached://user:password@/var/local/run/memcached.socket?weight=25',
+                '/var/local/run/memcached.socket',
+                0,
+            );
+        }
+    }
+}

vendor/symfony/cache/Tests/Simple/MemcachedCacheTextModeTest.php

@@ -0,0 +1,25 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Tests\Simple;
+
+use Symfony\Component\Cache\Adapter\AbstractAdapter;
+use Symfony\Component\Cache\Simple\MemcachedCache;
+
+class MemcachedCacheTextModeTest extends MemcachedCacheTest
+{
+    public function createSimpleCache($defaultLifetime = 0)
+    {
+        $client = AbstractAdapter::createConnection('memcached://'.getenv('MEMCACHED_HOST'), array('binary_protocol' => false));
+
+        return new MemcachedCache($client, str_replace('\\', '.', __CLASS__), $defaultLifetime);
+    }
+}

vendor/symfony/cache/Tests/Simple/NullCacheTest.php

@@ -0,0 +1,96 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Tests\Simple;
+
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Cache\Simple\NullCache;
+
+/**
+ * @group time-sensitive
+ */
+class NullCacheTest extends TestCase
+{
+    public function createCachePool()
+    {
+        return new NullCache();
+    }
+
+    public function testGetItem()
+    {
+        $cache = $this->createCachePool();
+
+        $this->assertNull($cache->get('key'));
+    }
+
+    public function testHas()
+    {
+        $this->assertFalse($this->createCachePool()->has('key'));
+    }
+
+    public function testGetMultiple()
+    {
+        $cache = $this->createCachePool();
+
+        $keys = array('foo', 'bar', 'baz', 'biz');
+
+        $default = new \stdClass();
+        $items = $cache->getMultiple($keys, $default);
+        $count = 0;
+
+        foreach ($items as $key => $item) {
+            $this->assertContains($key, $keys, 'Cache key can not change.');
+            $this->assertSame($default, $item);
+
+            // Remove $key for $keys
+            foreach ($keys as $k => $v) {
+                if ($v === $key) {
+                    unset($keys[$k]);
+                }
+            }
+
+            ++$count;
+        }
+
+        $this->assertSame(4, $count);
+    }
+
+    public function testClear()
+    {
+        $this->assertTrue($this->createCachePool()->clear());
+    }
+
+    public function testDelete()
+    {
+        $this->assertTrue($this->createCachePool()->delete('key'));
+    }
+
+    public function testDeleteMultiple()
+    {
+        $this->assertTrue($this->createCachePool()->deleteMultiple(array('key', 'foo', 'bar')));
+    }
+
+    public function testSet()
+    {
+        $cache = $this->createCachePool();
+
+        $this->assertFalse($cache->set('key', 'val'));
+        $this->assertNull($cache->get('key'));
+    }
+
+    public function testSetMultiple()
+    {
+        $cache = $this->createCachePool();
+
+        $this->assertFalse($cache->setMultiple(array('key' => 'val')));
+        $this->assertNull($cache->get('key'));
+    }
+}

vendor/symfony/cache/Tests/Simple/PdoCacheTest.php

@@ -0,0 +1,47 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Tests\Simple;
+
+use Symfony\Component\Cache\Simple\PdoCache;
+use Symfony\Component\Cache\Tests\Traits\PdoPruneableTrait;
+
+/**
+ * @group time-sensitive
+ */
+class PdoCacheTest extends CacheTestCase
+{
+    use PdoPruneableTrait;
+
+    protected static $dbFile;
+
+    public static function setupBeforeClass()
+    {
+        if (!\extension_loaded('pdo_sqlite')) {
+            self::markTestSkipped('Extension pdo_sqlite required.');
+        }
+
+        self::$dbFile = tempnam(sys_get_temp_dir(), 'sf_sqlite_cache');
+
+        $pool = new PdoCache('sqlite:'.self::$dbFile);
+        $pool->createTable();
+    }
+
+    public static function tearDownAfterClass()
+    {
+        @unlink(self::$dbFile);
+    }
+
+    public function createSimpleCache($defaultLifetime = 0)
+    {
+        return new PdoCache('sqlite:'.self::$dbFile, 'ns', $defaultLifetime);
+    }
+}

vendor/symfony/cache/Tests/Simple/PdoDbalCacheTest.php

@@ -0,0 +1,48 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Tests\Simple;
+
+use Doctrine\DBAL\DriverManager;
+use Symfony\Component\Cache\Simple\PdoCache;
+use Symfony\Component\Cache\Tests\Traits\PdoPruneableTrait;
+
+/**
+ * @group time-sensitive
+ */
+class PdoDbalCacheTest extends CacheTestCase
+{
+    use PdoPruneableTrait;
+
+    protected static $dbFile;
+
+    public static function setupBeforeClass()
+    {
+        if (!\extension_loaded('pdo_sqlite')) {
+            self::markTestSkipped('Extension pdo_sqlite required.');
+        }
+
+        self::$dbFile = tempnam(sys_get_temp_dir(), 'sf_sqlite_cache');
+
+        $pool = new PdoCache(DriverManager::getConnection(array('driver' => 'pdo_sqlite', 'path' => self::$dbFile)));
+        $pool->createTable();
+    }
+
+    public static function tearDownAfterClass()
+    {
+        @unlink(self::$dbFile);
+    }
+
+    public function createSimpleCache($defaultLifetime = 0)
+    {
+        return new PdoCache(DriverManager::getConnection(array('driver' => 'pdo_sqlite', 'path' => self::$dbFile)), '', $defaultLifetime);
+    }
+}

vendor/symfony/cache/Tests/Simple/PhpArrayCacheTest.php

@@ -0,0 +1,143 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Tests\Simple;
+
+use Symfony\Component\Cache\Simple\NullCache;
+use Symfony\Component\Cache\Simple\PhpArrayCache;
+use Symfony\Component\Cache\Tests\Adapter\FilesystemAdapterTest;
+
+/**
+ * @group time-sensitive
+ */
+class PhpArrayCacheTest extends CacheTestCase
+{
+    protected $skippedTests = array(
+        'testBasicUsageWithLongKey' => 'PhpArrayCache does no writes',
+
+        'testDelete' => 'PhpArrayCache does no writes',
+        'testDeleteMultiple' => 'PhpArrayCache does no writes',
+        'testDeleteMultipleGenerator' => 'PhpArrayCache does no writes',
+
+        'testSetTtl' => 'PhpArrayCache does no expiration',
+        'testSetMultipleTtl' => 'PhpArrayCache does no expiration',
+        'testSetExpiredTtl' => 'PhpArrayCache does no expiration',
+        'testSetMultipleExpiredTtl' => 'PhpArrayCache does no expiration',
+
+        'testGetInvalidKeys' => 'PhpArrayCache does no validation',
+        'testGetMultipleInvalidKeys' => 'PhpArrayCache does no validation',
+        'testSetInvalidKeys' => 'PhpArrayCache does no validation',
+        'testDeleteInvalidKeys' => 'PhpArrayCache does no validation',
+        'testDeleteMultipleInvalidKeys' => 'PhpArrayCache does no validation',
+        'testSetInvalidTtl' => 'PhpArrayCache does no validation',
+        'testSetMultipleInvalidKeys' => 'PhpArrayCache does no validation',
+        'testSetMultipleInvalidTtl' => 'PhpArrayCache does no validation',
+        'testHasInvalidKeys' => 'PhpArrayCache does no validation',
+        'testSetValidData' => 'PhpArrayCache does no validation',
+
+        'testDefaultLifeTime' => 'PhpArrayCache does not allow configuring a default lifetime.',
+        'testPrune' => 'PhpArrayCache just proxies',
+    );
+
+    protected static $file;
+
+    public static function setupBeforeClass()
+    {
+        self::$file = sys_get_temp_dir().'/symfony-cache/php-array-adapter-test.php';
+    }
+
+    protected function tearDown()
+    {
+        if (file_exists(sys_get_temp_dir().'/symfony-cache')) {
+            FilesystemAdapterTest::rmdir(sys_get_temp_dir().'/symfony-cache');
+        }
+    }
+
+    public function createSimpleCache()
+    {
+        return new PhpArrayCacheWrapper(self::$file, new NullCache());
+    }
+
+    public function testStore()
+    {
+        $arrayWithRefs = array();
+        $arrayWithRefs[0] = 123;
+        $arrayWithRefs[1] = &$arrayWithRefs[0];
+
+        $object = (object) array(
+            'foo' => 'bar',
+            'foo2' => 'bar2',
+        );
+
+        $expected = array(
+            'null' => null,
+            'serializedString' => serialize($object),
+            'arrayWithRefs' => $arrayWithRefs,
+            'object' => $object,
+            'arrayWithObject' => array('bar' => $object),
+        );
+
+        $cache = new PhpArrayCache(self::$file, new NullCache());
+        $cache->warmUp($expected);
+
+        foreach ($expected as $key => $value) {
+            $this->assertSame(serialize($value), serialize($cache->get($key)), 'Warm up should create a PHP file that OPCache can load in memory');
+        }
+    }
+
+    public function testStoredFile()
+    {
+        $expected = array(
+            'integer' => 42,
+            'float' => 42.42,
+            'boolean' => true,
+            'array_simple' => array('foo', 'bar'),
+            'array_associative' => array('foo' => 'bar', 'foo2' => 'bar2'),
+        );
+
+        $cache = new PhpArrayCache(self::$file, new NullCache());
+        $cache->warmUp($expected);
+
+        $values = eval(substr(file_get_contents(self::$file), 6));
+
+        $this->assertSame($expected, $values, 'Warm up should create a PHP file that OPCache can load in memory');
+    }
+}
+
+class PhpArrayCacheWrapper extends PhpArrayCache
+{
+    public function set($key, $value, $ttl = null)
+    {
+        \call_user_func(\Closure::bind(function () use ($key, $value) {
+            $this->values[$key] = $value;
+            $this->warmUp($this->values);
+            $this->values = eval(substr(file_get_contents($this->file), 6));
+        }, $this, PhpArrayCache::class));
+
+        return true;
+    }
+
+    public function setMultiple($values, $ttl = null)
+    {
+        if (!\is_array($values) && !$values instanceof \Traversable) {
+            return parent::setMultiple($values, $ttl);
+        }
+        \call_user_func(\Closure::bind(function () use ($values) {
+            foreach ($values as $key => $value) {
+                $this->values[$key] = $value;
+            }
+            $this->warmUp($this->values);
+            $this->values = eval(substr(file_get_contents($this->file), 6));
+        }, $this, PhpArrayCache::class));
+
+        return true;
+    }
+}

vendor/symfony/cache/Tests/Simple/PhpArrayCacheWithFallbackTest.php

@@ -0,0 +1,55 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Tests\Simple;
+
+use Symfony\Component\Cache\Simple\FilesystemCache;
+use Symfony\Component\Cache\Simple\PhpArrayCache;
+use Symfony\Component\Cache\Tests\Adapter\FilesystemAdapterTest;
+
+/**
+ * @group time-sensitive
+ */
+class PhpArrayCacheWithFallbackTest extends CacheTestCase
+{
+    protected $skippedTests = array(
+        'testGetInvalidKeys' => 'PhpArrayCache does no validation',
+        'testGetMultipleInvalidKeys' => 'PhpArrayCache does no validation',
+        'testDeleteInvalidKeys' => 'PhpArrayCache does no validation',
+        'testDeleteMultipleInvalidKeys' => 'PhpArrayCache does no validation',
+        //'testSetValidData' => 'PhpArrayCache does no validation',
+        'testSetInvalidKeys' => 'PhpArrayCache does no validation',
+        'testSetInvalidTtl' => 'PhpArrayCache does no validation',
+        'testSetMultipleInvalidKeys' => 'PhpArrayCache does no validation',
+        'testSetMultipleInvalidTtl' => 'PhpArrayCache does no validation',
+        'testHasInvalidKeys' => 'PhpArrayCache does no validation',
+        'testPrune' => 'PhpArrayCache just proxies',
+    );
+
+    protected static $file;
+
+    public static function setupBeforeClass()
+    {
+        self::$file = sys_get_temp_dir().'/symfony-cache/php-array-adapter-test.php';
+    }
+
+    protected function tearDown()
+    {
+        if (file_exists(sys_get_temp_dir().'/symfony-cache')) {
+            FilesystemAdapterTest::rmdir(sys_get_temp_dir().'/symfony-cache');
+        }
+    }
+
+    public function createSimpleCache($defaultLifetime = 0)
+    {
+        return new PhpArrayCache(self::$file, new FilesystemCache('php-array-fallback', $defaultLifetime));
+    }
+}

vendor/symfony/cache/Tests/Simple/PhpFilesCacheTest.php

@@ -0,0 +1,42 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Tests\Simple;
+
+use Psr\SimpleCache\CacheInterface;
+use Symfony\Component\Cache\Simple\PhpFilesCache;
+
+/**
+ * @group time-sensitive
+ */
+class PhpFilesCacheTest extends CacheTestCase
+{
+    protected $skippedTests = array(
+        'testDefaultLifeTime' => 'PhpFilesCache does not allow configuring a default lifetime.',
+    );
+
+    public function createSimpleCache()
+    {
+        if (!PhpFilesCache::isSupported()) {
+            $this->markTestSkipped('OPcache extension is not enabled.');
+        }
+
+        return new PhpFilesCache('sf-cache');
+    }
+
+    protected function isPruned(CacheInterface $cache, $name)
+    {
+        $getFileMethod = (new \ReflectionObject($cache))->getMethod('getFile');
+        $getFileMethod->setAccessible(true);
+
+        return !file_exists($getFileMethod->invoke($cache, $name));
+    }
+}

vendor/symfony/cache/Tests/Simple/Psr6CacheTest.php

@@ -0,0 +1,30 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Tests\Simple;
+
+use Symfony\Component\Cache\Adapter\FilesystemAdapter;
+use Symfony\Component\Cache\Simple\Psr6Cache;
+
+/**
+ * @group time-sensitive
+ */
+class Psr6CacheTest extends CacheTestCase
+{
+    protected $skippedTests = array(
+        'testPrune' => 'Psr6Cache just proxies',
+    );
+
+    public function createSimpleCache($defaultLifetime = 0)
+    {
+        return new Psr6Cache(new FilesystemAdapter('', $defaultLifetime));
+    }
+}

vendor/symfony/cache/Tests/Simple/RedisArrayCacheTest.php

@@ -0,0 +1,24 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Tests\Simple;
+
+class RedisArrayCacheTest extends AbstractRedisCacheTest
+{
+    public static function setupBeforeClass()
+    {
+        parent::setupBeforeClass();
+        if (!class_exists('RedisArray')) {
+            self::markTestSkipped('The RedisArray class is required.');
+        }
+        self::$redis = new \RedisArray(array(getenv('REDIS_HOST')), array('lazy_connect' => true));
+    }
+}

vendor/symfony/cache/Tests/Simple/RedisCacheTest.php

@@ -0,0 +1,82 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Tests\Simple;
+
+use Symfony\Component\Cache\Simple\RedisCache;
+
+class RedisCacheTest extends AbstractRedisCacheTest
+{
+    public static function setupBeforeClass()
+    {
+        parent::setupBeforeClass();
+        self::$redis = RedisCache::createConnection('redis://'.getenv('REDIS_HOST'));
+    }
+
+    public function testCreateConnection()
+    {
+        $redisHost = getenv('REDIS_HOST');
+
+        $redis = RedisCache::createConnection('redis://'.$redisHost);
+        $this->assertInstanceOf(\Redis::class, $redis);
+        $this->assertTrue($redis->isConnected());
+        $this->assertSame(0, $redis->getDbNum());
+
+        $redis = RedisCache::createConnection('redis://'.$redisHost.'/2');
+        $this->assertSame(2, $redis->getDbNum());
+
+        $redis = RedisCache::createConnection('redis://'.$redisHost, array('timeout' => 3));
+        $this->assertEquals(3, $redis->getTimeout());
+
+        $redis = RedisCache::createConnection('redis://'.$redisHost.'?timeout=4');
+        $this->assertEquals(4, $redis->getTimeout());
+
+        $redis = RedisCache::createConnection('redis://'.$redisHost, array('read_timeout' => 5));
+        $this->assertEquals(5, $redis->getReadTimeout());
+    }
+
+    /**
+     * @dataProvider provideFailedCreateConnection
+     * @expectedException \Symfony\Component\Cache\Exception\InvalidArgumentException
+     * @expectedExceptionMessage Redis connection failed
+     */
+    public function testFailedCreateConnection($dsn)
+    {
+        RedisCache::createConnection($dsn);
+    }
+
+    public function provideFailedCreateConnection()
+    {
+        return array(
+            array('redis://localhost:1234'),
+            array('redis://foo@localhost'),
+            array('redis://localhost/123'),
+        );
+    }
+
+    /**
+     * @dataProvider provideInvalidCreateConnection
+     * @expectedException \Symfony\Component\Cache\Exception\InvalidArgumentException
+     * @expectedExceptionMessage Invalid Redis DSN
+     */
+    public function testInvalidCreateConnection($dsn)
+    {
+        RedisCache::createConnection($dsn);
+    }
+
+    public function provideInvalidCreateConnection()
+    {
+        return array(
+            array('foo://localhost'),
+            array('redis://'),
+        );
+    }
+}

vendor/symfony/cache/Tests/Simple/RedisClusterCacheTest.php

@@ -0,0 +1,27 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Tests\Simple;
+
+class RedisClusterCacheTest extends AbstractRedisCacheTest
+{
+    public static function setupBeforeClass()
+    {
+        if (!class_exists('RedisCluster')) {
+            self::markTestSkipped('The RedisCluster class is required.');
+        }
+        if (!$hosts = getenv('REDIS_CLUSTER_HOSTS')) {
+            self::markTestSkipped('REDIS_CLUSTER_HOSTS env var is not defined.');
+        }
+
+        self::$redis = new \RedisCluster(null, explode(' ', $hosts));
+    }
+}

vendor/symfony/cache/Tests/Simple/TraceableCacheTest.php

@@ -0,0 +1,171 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Tests\Simple;
+
+use Symfony\Component\Cache\Simple\FilesystemCache;
+use Symfony\Component\Cache\Simple\TraceableCache;
+
+/**
+ * @group time-sensitive
+ */
+class TraceableCacheTest extends CacheTestCase
+{
+    protected $skippedTests = array(
+        'testPrune' => 'TraceableCache just proxies',
+    );
+
+    public function createSimpleCache($defaultLifetime = 0)
+    {
+        return new TraceableCache(new FilesystemCache('', $defaultLifetime));
+    }
+
+    public function testGetMissTrace()
+    {
+        $pool = $this->createSimpleCache();
+        $pool->get('k');
+        $calls = $pool->getCalls();
+        $this->assertCount(1, $calls);
+
+        $call = $calls[0];
+        $this->assertSame('get', $call->name);
+        $this->assertSame(array('k' => false), $call->result);
+        $this->assertSame(0, $call->hits);
+        $this->assertSame(1, $call->misses);
+        $this->assertNotEmpty($call->start);
+        $this->assertNotEmpty($call->end);
+    }
+
+    public function testGetHitTrace()
+    {
+        $pool = $this->createSimpleCache();
+        $pool->set('k', 'foo');
+        $pool->get('k');
+        $calls = $pool->getCalls();
+        $this->assertCount(2, $calls);
+
+        $call = $calls[1];
+        $this->assertSame(1, $call->hits);
+        $this->assertSame(0, $call->misses);
+    }
+
+    public function testGetMultipleMissTrace()
+    {
+        $pool = $this->createSimpleCache();
+        $pool->set('k1', 123);
+        $values = $pool->getMultiple(array('k0', 'k1'));
+        foreach ($values as $value) {
+        }
+        $calls = $pool->getCalls();
+        $this->assertCount(2, $calls);
+
+        $call = $calls[1];
+        $this->assertSame('getMultiple', $call->name);
+        $this->assertSame(array('k1' => true, 'k0' => false), $call->result);
+        $this->assertSame(1, $call->misses);
+        $this->assertNotEmpty($call->start);
+        $this->assertNotEmpty($call->end);
+    }
+
+    public function testHasMissTrace()
+    {
+        $pool = $this->createSimpleCache();
+        $pool->has('k');
+        $calls = $pool->getCalls();
+        $this->assertCount(1, $calls);
+
+        $call = $calls[0];
+        $this->assertSame('has', $call->name);
+        $this->assertSame(array('k' => false), $call->result);
+        $this->assertNotEmpty($call->start);
+        $this->assertNotEmpty($call->end);
+    }
+
+    public function testHasHitTrace()
+    {
+        $pool = $this->createSimpleCache();
+        $pool->set('k', 'foo');
+        $pool->has('k');
+        $calls = $pool->getCalls();
+        $this->assertCount(2, $calls);
+
+        $call = $calls[1];
+        $this->assertSame('has', $call->name);
+        $this->assertSame(array('k' => true), $call->result);
+        $this->assertNotEmpty($call->start);
+        $this->assertNotEmpty($call->end);
+    }
+
+    public function testDeleteTrace()
+    {
+        $pool = $this->createSimpleCache();
+        $pool->delete('k');
+        $calls = $pool->getCalls();
+        $this->assertCount(1, $calls);
+
+        $call = $calls[0];
+        $this->assertSame('delete', $call->name);
+        $this->assertSame(array('k' => true), $call->result);
+        $this->assertSame(0, $call->hits);
+        $this->assertSame(0, $call->misses);
+        $this->assertNotEmpty($call->start);
+        $this->assertNotEmpty($call->end);
+    }
+
+    public function testDeleteMultipleTrace()
+    {
+        $pool = $this->createSimpleCache();
+        $arg = array('k0', 'k1');
+        $pool->deleteMultiple($arg);
+        $calls = $pool->getCalls();
+        $this->assertCount(1, $calls);
+
+        $call = $calls[0];
+        $this->assertSame('deleteMultiple', $call->name);
+        $this->assertSame(array('keys' => $arg, 'result' => true), $call->result);
+        $this->assertSame(0, $call->hits);
+        $this->assertSame(0, $call->misses);
+        $this->assertNotEmpty($call->start);
+        $this->assertNotEmpty($call->end);
+    }
+
+    public function testTraceSetTrace()
+    {
+        $pool = $this->createSimpleCache();
+        $pool->set('k', 'foo');
+        $calls = $pool->getCalls();
+        $this->assertCount(1, $calls);
+
+        $call = $calls[0];
+        $this->assertSame('set', $call->name);
+        $this->assertSame(array('k' => true), $call->result);
+        $this->assertSame(0, $call->hits);
+        $this->assertSame(0, $call->misses);
+        $this->assertNotEmpty($call->start);
+        $this->assertNotEmpty($call->end);
+    }
+
+    public function testSetMultipleTrace()
+    {
+        $pool = $this->createSimpleCache();
+        $pool->setMultiple(array('k' => 'foo'));
+        $calls = $pool->getCalls();
+        $this->assertCount(1, $calls);
+
+        $call = $calls[0];
+        $this->assertSame('setMultiple', $call->name);
+        $this->assertSame(array('keys' => array('k'), 'result' => true), $call->result);
+        $this->assertSame(0, $call->hits);
+        $this->assertSame(0, $call->misses);
+        $this->assertNotEmpty($call->start);
+        $this->assertNotEmpty($call->end);
+    }
+}

vendor/symfony/cache/Tests/Traits/PdoPruneableTrait.php

@@ -0,0 +1,34 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Tests\Traits;
+
+trait PdoPruneableTrait
+{
+    protected function isPruned($cache, $name)
+    {
+        $o = new \ReflectionObject($cache);
+
+        if (!$o->hasMethod('getConnection')) {
+            self::fail('Cache does not have "getConnection()" method.');
+        }
+
+        $getPdoConn = $o->getMethod('getConnection');
+        $getPdoConn->setAccessible(true);
+
+        /** @var \Doctrine\DBAL\Statement $select */
+        $select = $getPdoConn->invoke($cache)->prepare('SELECT 1 FROM cache_items WHERE item_id LIKE :id');
+        $select->bindValue(':id', sprintf('%%%s', $name));
+        $select->execute();
+
+        return 0 === \count($select->fetchAll(\PDO::FETCH_COLUMN));
+    }
+}