the whole shebang

vendor/symfony/http-foundation/Symfony/Component/HttpFoundation/Tests/Session/Attribute/AttributeBagTest.php

@@ -0,0 +1,193 @@
+<?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\HttpFoundation\Tests\Session\Attribute;
+
+use Symfony\Component\HttpFoundation\Session\Attribute\AttributeBag;
+
+/**
+ * Tests AttributeBag
+ *
+ * @author Drak <drak@zikula.org>
+ */
+class AttributeBagTest extends \PHPUnit_Framework_TestCase
+{
+    /**
+     * @var array
+     */
+    private $array;
+
+    /**
+     * @var AttributeBag
+     */
+    private $bag;
+
+    protected function setUp()
+    {
+        $this->array = array(
+            'hello' => 'world',
+            'always' => 'be happy',
+            'user.login' => 'drak',
+            'csrf.token' => array(
+                'a' => '1234',
+                'b' => '4321',
+            ),
+            'category' => array(
+                'fishing' => array(
+                    'first' => 'cod',
+                    'second' => 'sole')
+                ),
+        );
+        $this->bag = new AttributeBag('_sf2');
+        $this->bag->initialize($this->array);
+    }
+
+    protected function tearDown()
+    {
+        $this->bag = null;
+        $this->array = array();
+    }
+
+    public function testInitialize()
+    {
+        $bag = new AttributeBag();
+        $bag->initialize($this->array);
+        $this->assertEquals($this->array, $bag->all());
+        $array = array('should' => 'change');
+        $bag->initialize($array);
+        $this->assertEquals($array, $bag->all());
+    }
+
+    public function testGetStorageKey()
+    {
+        $this->assertEquals('_sf2', $this->bag->getStorageKey());
+        $attributeBag = new AttributeBag('test');
+        $this->assertEquals('test', $attributeBag->getStorageKey());
+    }
+
+    public function testGetSetName()
+    {
+        $this->assertEquals('attributes', $this->bag->getName());
+        $this->bag->setName('foo');
+        $this->assertEquals('foo', $this->bag->getName());
+    }
+
+    /**
+     * @dataProvider attributesProvider
+     */
+    public function testHas($key, $value, $exists)
+    {
+        $this->assertEquals($exists, $this->bag->has($key));
+    }
+
+    /**
+     * @dataProvider attributesProvider
+     */
+    public function testGet($key, $value, $expected)
+    {
+        $this->assertEquals($value, $this->bag->get($key));
+    }
+
+    public function testGetDefaults()
+    {
+        $this->assertNull($this->bag->get('user2.login'));
+        $this->assertEquals('default', $this->bag->get('user2.login', 'default'));
+    }
+
+    /**
+     * @dataProvider attributesProvider
+     */
+    public function testSet($key, $value, $expected)
+    {
+        $this->bag->set($key, $value);
+        $this->assertEquals($value, $this->bag->get($key));
+    }
+
+    public function testAll()
+    {
+        $this->assertEquals($this->array, $this->bag->all());
+
+        $this->bag->set('hello', 'fabien');
+        $array = $this->array;
+        $array['hello'] = 'fabien';
+        $this->assertEquals($array, $this->bag->all());
+    }
+
+    public function testReplace()
+    {
+        $array = array();
+        $array['name'] = 'jack';
+        $array['foo.bar'] = 'beep';
+        $this->bag->replace($array);
+        $this->assertEquals($array, $this->bag->all());
+        $this->assertNull($this->bag->get('hello'));
+        $this->assertNull($this->bag->get('always'));
+        $this->assertNull($this->bag->get('user.login'));
+    }
+
+    public function testRemove()
+    {
+        $this->assertEquals('world', $this->bag->get('hello'));
+        $this->bag->remove('hello');
+        $this->assertNull($this->bag->get('hello'));
+
+        $this->assertEquals('be happy', $this->bag->get('always'));
+        $this->bag->remove('always');
+        $this->assertNull($this->bag->get('always'));
+
+        $this->assertEquals('drak', $this->bag->get('user.login'));
+        $this->bag->remove('user.login');
+        $this->assertNull($this->bag->get('user.login'));
+    }
+
+    public function testClear()
+    {
+        $this->bag->clear();
+        $this->assertEquals(array(), $this->bag->all());
+    }
+
+    public function attributesProvider()
+    {
+        return array(
+            array('hello', 'world', true),
+            array('always', 'be happy', true),
+            array('user.login', 'drak', true),
+            array('csrf.token', array('a' => '1234', 'b' => '4321'), true),
+            array('category', array('fishing' => array('first' => 'cod', 'second' => 'sole')), true),
+            array('user2.login', null, false),
+            array('never', null, false),
+            array('bye', null, false),
+            array('bye/for/now', null, false),
+        );
+    }
+
+    /**
+     * @covers Symfony\Component\HttpFoundation\Session\Attribute\AttributeBag::getIterator
+     */
+    public function testGetIterator()
+    {
+        $i = 0;
+        foreach ($this->bag as $key => $val) {
+            $this->assertEquals($this->array[$key], $val);
+            $i++;
+        }
+
+        $this->assertEquals(count($this->array), $i);
+    }
+
+    /**
+     * @covers Symfony\Component\HttpFoundation\Session\Attribute\AttributeBag::count
+     */
+    public function testCount()
+    {
+        $this->assertEquals(count($this->array), count($this->bag));
+    }
+}

vendor/symfony/http-foundation/Symfony/Component/HttpFoundation/Tests/Session/Attribute/NamespacedAttributeBagTest.php

@@ -0,0 +1,183 @@
+<?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\HttpFoundation\Tests\Session\Attribute;
+
+use Symfony\Component\HttpFoundation\Session\Attribute\NamespacedAttributeBag;
+
+/**
+ * Tests NamespacedAttributeBag
+ *
+ * @author Drak <drak@zikula.org>
+ */
+class NamespacedAttributeBagTest extends \PHPUnit_Framework_TestCase
+{
+    /**
+     * @var array
+     */
+    private $array;
+
+    /**
+     * @var NamespacedAttributeBag
+     */
+    private $bag;
+
+    protected function setUp()
+    {
+        $this->array = array(
+            'hello' => 'world',
+            'always' => 'be happy',
+            'user.login' => 'drak',
+            'csrf.token' => array(
+                'a' => '1234',
+                'b' => '4321',
+            ),
+            'category' => array(
+                'fishing' => array(
+                    'first' => 'cod',
+                    'second' => 'sole')
+                ),
+        );
+        $this->bag = new NamespacedAttributeBag('_sf2', '/');
+        $this->bag->initialize($this->array);
+    }
+
+    protected function tearDown()
+    {
+        $this->bag = null;
+        $this->array = array();
+    }
+
+    public function testInitialize()
+    {
+        $bag = new NamespacedAttributeBag();
+        $bag->initialize($this->array);
+        $this->assertEquals($this->array, $this->bag->all());
+        $array = array('should' => 'not stick');
+        $bag->initialize($array);
+
+        // should have remained the same
+        $this->assertEquals($this->array, $this->bag->all());
+    }
+
+    public function testGetStorageKey()
+    {
+        $this->assertEquals('_sf2', $this->bag->getStorageKey());
+        $attributeBag = new NamespacedAttributeBag('test');
+        $this->assertEquals('test', $attributeBag->getStorageKey());
+    }
+
+    /**
+     * @dataProvider attributesProvider
+     */
+    public function testHas($key, $value, $exists)
+    {
+        $this->assertEquals($exists, $this->bag->has($key));
+    }
+
+    /**
+     * @dataProvider attributesProvider
+     */
+    public function testGet($key, $value, $expected)
+    {
+        $this->assertEquals($value, $this->bag->get($key));
+    }
+
+    public function testGetDefaults()
+    {
+        $this->assertNull($this->bag->get('user2.login'));
+        $this->assertEquals('default', $this->bag->get('user2.login', 'default'));
+    }
+
+    /**
+     * @dataProvider attributesProvider
+     */
+    public function testSet($key, $value, $expected)
+    {
+        $this->bag->set($key, $value);
+        $this->assertEquals($value, $this->bag->get($key));
+    }
+
+    public function testAll()
+    {
+        $this->assertEquals($this->array, $this->bag->all());
+
+        $this->bag->set('hello', 'fabien');
+        $array = $this->array;
+        $array['hello'] = 'fabien';
+        $this->assertEquals($array, $this->bag->all());
+    }
+
+    public function testReplace()
+    {
+        $array = array();
+        $array['name'] = 'jack';
+        $array['foo.bar'] = 'beep';
+        $this->bag->replace($array);
+        $this->assertEquals($array, $this->bag->all());
+        $this->assertNull($this->bag->get('hello'));
+        $this->assertNull($this->bag->get('always'));
+        $this->assertNull($this->bag->get('user.login'));
+    }
+
+    public function testRemove()
+    {
+        $this->assertEquals('world', $this->bag->get('hello'));
+        $this->bag->remove('hello');
+        $this->assertNull($this->bag->get('hello'));
+
+        $this->assertEquals('be happy', $this->bag->get('always'));
+        $this->bag->remove('always');
+        $this->assertNull($this->bag->get('always'));
+
+        $this->assertEquals('drak', $this->bag->get('user.login'));
+        $this->bag->remove('user.login');
+        $this->assertNull($this->bag->get('user.login'));
+    }
+
+    public function testRemoveExistingNamespacedAttribute()
+    {
+        $this->assertSame('cod', $this->bag->remove('category/fishing/first'));
+    }
+
+    public function testRemoveNonexistingNamespacedAttribute()
+    {
+        $this->assertNull($this->bag->remove('foo/bar/baz'));
+    }
+
+    public function testClear()
+    {
+        $this->bag->clear();
+        $this->assertEquals(array(), $this->bag->all());
+    }
+
+    public function attributesProvider()
+    {
+        return array(
+            array('hello', 'world', true),
+            array('always', 'be happy', true),
+            array('user.login', 'drak', true),
+            array('csrf.token', array('a' => '1234', 'b' => '4321'), true),
+            array('csrf.token/a', '1234', true),
+            array('csrf.token/b', '4321', true),
+            array('category', array('fishing' => array('first' => 'cod', 'second' => 'sole')), true),
+            array('category/fishing', array('first' => 'cod', 'second' => 'sole'), true),
+            array('category/fishing/missing/first', null, false),
+            array('category/fishing/first', 'cod', true),
+            array('category/fishing/second', 'sole', true),
+            array('category/fishing/missing/second', null, false),
+            array('user2.login', null, false),
+            array('never', null, false),
+            array('bye', null, false),
+            array('bye/for/now', null, false),
+        );
+    }
+}

vendor/symfony/http-foundation/Symfony/Component/HttpFoundation/Tests/Session/Flash/AutoExpireFlashBagTest.php

@@ -0,0 +1,155 @@
+<?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\HttpFoundation\Tests\Session\Flash;
+
+use Symfony\Component\HttpFoundation\Session\Flash\AutoExpireFlashBag as FlashBag;
+
+/**
+ * AutoExpireFlashBagTest
+ *
+ * @author Drak <drak@zikula.org>
+ */
+class AutoExpireFlashBagTest extends \PHPUnit_Framework_TestCase
+{
+    /**
+     * @var \Symfony\Component\HttpFoundation\Session\Flash\AutoExpireFlashBag
+     */
+    private $bag;
+
+    /**
+     * @var array
+     */
+    protected $array = array();
+
+    protected function setUp()
+    {
+        parent::setUp();
+        $this->bag = new FlashBag();
+        $this->array = array('new' => array('notice' => array('A previous flash message')));
+        $this->bag->initialize($this->array);
+    }
+
+    public function tearDown()
+    {
+        $this->bag = null;
+        parent::tearDown();
+    }
+
+    public function testInitialize()
+    {
+        $bag = new FlashBag();
+        $array = array('new' => array('notice' => array('A previous flash message')));
+        $bag->initialize($array);
+        $this->assertEquals(array('A previous flash message'), $bag->peek('notice'));
+        $array = array('new' => array(
+                'notice' => array('Something else'),
+                'error' => array('a'),
+            ));
+        $bag->initialize($array);
+        $this->assertEquals(array('Something else'), $bag->peek('notice'));
+        $this->assertEquals(array('a'), $bag->peek('error'));
+    }
+
+    public function testGetStorageKey()
+    {
+        $this->assertEquals('_sf2_flashes', $this->bag->getStorageKey());
+        $attributeBag = new FlashBag('test');
+        $this->assertEquals('test', $attributeBag->getStorageKey());
+    }
+
+    public function testGetSetName()
+    {
+        $this->assertEquals('flashes', $this->bag->getName());
+        $this->bag->setName('foo');
+        $this->assertEquals('foo', $this->bag->getName());
+    }
+
+    public function testPeek()
+    {
+        $this->assertEquals(array(), $this->bag->peek('non_existing'));
+        $this->assertEquals(array('default'), $this->bag->peek('non_existing', array('default')));
+        $this->assertEquals(array('A previous flash message'), $this->bag->peek('notice'));
+        $this->assertEquals(array('A previous flash message'), $this->bag->peek('notice'));
+    }
+
+    public function testSet()
+    {
+        $this->bag->set('notice', 'Foo');
+        $this->assertEquals(array('A previous flash message'), $this->bag->peek('notice'));
+    }
+
+    public function testHas()
+    {
+        $this->assertFalse($this->bag->has('nothing'));
+        $this->assertTrue($this->bag->has('notice'));
+    }
+
+    public function testKeys()
+    {
+        $this->assertEquals(array('notice'), $this->bag->keys());
+    }
+
+    public function testPeekAll()
+    {
+        $array = array(
+            'new' => array(
+                'notice' => 'Foo',
+                'error' => 'Bar',
+            ),
+        );
+
+        $this->bag->initialize($array);
+        $this->assertEquals(array(
+            'notice' => 'Foo',
+            'error' => 'Bar',
+            ), $this->bag->peekAll()
+        );
+
+        $this->assertEquals(array(
+            'notice' => 'Foo',
+            'error' => 'Bar',
+            ), $this->bag->peekAll()
+        );
+    }
+
+    public function testGet()
+    {
+        $this->assertEquals(array(), $this->bag->get('non_existing'));
+        $this->assertEquals(array('default'), $this->bag->get('non_existing', array('default')));
+        $this->assertEquals(array('A previous flash message'), $this->bag->get('notice'));
+        $this->assertEquals(array(), $this->bag->get('notice'));
+    }
+
+    public function testSetAll()
+    {
+        $this->bag->setAll(array('a' => 'first', 'b' => 'second'));
+        $this->assertFalse($this->bag->has('a'));
+        $this->assertFalse($this->bag->has('b'));
+    }
+
+    public function testAll()
+    {
+        $this->bag->set('notice', 'Foo');
+        $this->bag->set('error', 'Bar');
+        $this->assertEquals(array(
+            'notice' => array('A previous flash message'),
+            ), $this->bag->all()
+        );
+
+        $this->assertEquals(array(), $this->bag->all());
+    }
+
+    public function testClear()
+    {
+        $this->assertEquals(array('notice' => array('A previous flash message')), $this->bag->clear());
+    }
+}

vendor/symfony/http-foundation/Symfony/Component/HttpFoundation/Tests/Session/Flash/FlashBagTest.php

@@ -0,0 +1,155 @@
+<?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\HttpFoundation\Tests\Session\Flash;
+
+use Symfony\Component\HttpFoundation\Session\Flash\FlashBag;
+use Symfony\Component\HttpFoundation\Session\Flash\FlashBagInterface;
+
+/**
+ * FlashBagTest
+ *
+ * @author Drak <drak@zikula.org>
+ */
+class FlashBagTest extends \PHPUnit_Framework_TestCase
+{
+    /**
+     * @var \Symfony\Component\HttpFoundation\SessionFlash\FlashBagInterface
+     */
+    private $bag;
+
+    /**
+     * @var array
+     */
+    protected $array = array();
+
+    protected function setUp()
+    {
+        parent::setUp();
+        $this->bag = new FlashBag();
+        $this->array = array('notice' => array('A previous flash message'));
+        $this->bag->initialize($this->array);
+    }
+
+    public function tearDown()
+    {
+        $this->bag = null;
+        parent::tearDown();
+    }
+
+    public function testInitialize()
+    {
+        $bag = new FlashBag();
+        $bag->initialize($this->array);
+        $this->assertEquals($this->array, $bag->peekAll());
+        $array = array('should' => array('change'));
+        $bag->initialize($array);
+        $this->assertEquals($array, $bag->peekAll());
+    }
+
+    public function testGetStorageKey()
+    {
+        $this->assertEquals('_sf2_flashes', $this->bag->getStorageKey());
+        $attributeBag = new FlashBag('test');
+        $this->assertEquals('test', $attributeBag->getStorageKey());
+    }
+
+    public function testGetSetName()
+    {
+        $this->assertEquals('flashes', $this->bag->getName());
+        $this->bag->setName('foo');
+        $this->assertEquals('foo', $this->bag->getName());
+    }
+
+    public function testPeek()
+    {
+        $this->assertEquals(array(), $this->bag->peek('non_existing'));
+        $this->assertEquals(array('default'), $this->bag->peek('not_existing', array('default')));
+        $this->assertEquals(array('A previous flash message'), $this->bag->peek('notice'));
+        $this->assertEquals(array('A previous flash message'), $this->bag->peek('notice'));
+    }
+
+    public function testGet()
+    {
+        $this->assertEquals(array(), $this->bag->get('non_existing'));
+        $this->assertEquals(array('default'), $this->bag->get('not_existing', array('default')));
+        $this->assertEquals(array('A previous flash message'), $this->bag->get('notice'));
+        $this->assertEquals(array(), $this->bag->get('notice'));
+    }
+
+    public function testAll()
+    {
+        $this->bag->set('notice', 'Foo');
+        $this->bag->set('error', 'Bar');
+        $this->assertEquals(array(
+            'notice' => array('Foo'),
+            'error' => array('Bar')), $this->bag->all()
+        );
+
+        $this->assertEquals(array(), $this->bag->all());
+    }
+
+    public function testSet()
+    {
+        $this->bag->set('notice', 'Foo');
+        $this->bag->set('notice', 'Bar');
+        $this->assertEquals(array('Bar'), $this->bag->peek('notice'));
+    }
+
+    public function testHas()
+    {
+        $this->assertFalse($this->bag->has('nothing'));
+        $this->assertTrue($this->bag->has('notice'));
+    }
+
+    public function testKeys()
+    {
+        $this->assertEquals(array('notice'), $this->bag->keys());
+    }
+
+    public function testPeekAll()
+    {
+        $this->bag->set('notice', 'Foo');
+        $this->bag->set('error', 'Bar');
+        $this->assertEquals(array(
+            'notice' => array('Foo'),
+            'error' => array('Bar'),
+            ), $this->bag->peekAll()
+        );
+        $this->assertTrue($this->bag->has('notice'));
+        $this->assertTrue($this->bag->has('error'));
+        $this->assertEquals(array(
+            'notice' => array('Foo'),
+            'error' => array('Bar'),
+            ), $this->bag->peekAll()
+        );
+    }
+
+    /**
+     * @covers Symfony\Component\HttpFoundation\Session\Flash\FlashBag::getIterator
+     */
+    public function testGetIterator()
+    {
+        $flashes = array('hello' => 'world', 'beep' => 'boop', 'notice' => 'nope');
+        foreach ($flashes as $key => $val) {
+            $this->bag->set($key, $val);
+        }
+
+        $i = 0;
+        foreach ($this->bag as $key => $val) {
+            $this->assertEquals(array($flashes[$key]), $val);
+            $i++;
+        }
+
+        $this->assertEquals(count($flashes), $i);
+        $this->assertEquals(0, count($this->bag->all()));
+    }
+}

vendor/symfony/http-foundation/Symfony/Component/HttpFoundation/Tests/Session/SessionTest.php

@@ -0,0 +1,227 @@
+<?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\HttpFoundation\Tests\Session;
+
+use Symfony\Component\HttpFoundation\Session\Session;
+use Symfony\Component\HttpFoundation\Session\Flash\FlashBag;
+use Symfony\Component\HttpFoundation\Session\Attribute\AttributeBag;
+use Symfony\Component\HttpFoundation\Session\Storage\MockArraySessionStorage;
+
+/**
+ * SessionTest
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ * @author Robert Schönthal <seroscho@googlemail.com>
+ * @author Drak <drak@zikula.org>
+ */
+class SessionTest extends \PHPUnit_Framework_TestCase
+{
+    /**
+     * @var \Symfony\Component\HttpFoundation\Session\Storage\SessionStorageInterface
+     */
+    protected $storage;
+
+    /**
+     * @var \Symfony\Component\HttpFoundation\Session\SessionInterface
+     */
+    protected $session;
+
+    protected function setUp()
+    {
+        $this->storage = new MockArraySessionStorage();
+        $this->session = new Session($this->storage, new AttributeBag(), new FlashBag());
+    }
+
+    protected function tearDown()
+    {
+        $this->storage = null;
+        $this->session = null;
+    }
+
+    public function testStart()
+    {
+        $this->assertEquals('', $this->session->getId());
+        $this->assertTrue($this->session->start());
+        $this->assertNotEquals('', $this->session->getId());
+    }
+
+    public function testIsStarted()
+    {
+        $this->assertFalse($this->session->isStarted());
+        $this->session->start();
+        $this->assertTrue($this->session->isStarted());
+    }
+
+    public function testSetId()
+    {
+        $this->assertEquals('', $this->session->getId());
+        $this->session->setId('0123456789abcdef');
+        $this->session->start();
+        $this->assertEquals('0123456789abcdef', $this->session->getId());
+    }
+
+    public function testSetName()
+    {
+        $this->assertEquals('MOCKSESSID', $this->session->getName());
+        $this->session->setName('session.test.com');
+        $this->session->start();
+        $this->assertEquals('session.test.com', $this->session->getName());
+    }
+
+    public function testGet()
+    {
+        // tests defaults
+        $this->assertNull($this->session->get('foo'));
+        $this->assertEquals(1, $this->session->get('foo', 1));
+    }
+
+    /**
+     * @dataProvider setProvider
+     */
+    public function testSet($key, $value)
+    {
+        $this->session->set($key, $value);
+        $this->assertEquals($value, $this->session->get($key));
+    }
+
+    /**
+     * @dataProvider setProvider
+     */
+    public function testHas($key, $value)
+    {
+        $this->session->set($key, $value);
+        $this->assertTrue($this->session->has($key));
+        $this->assertFalse($this->session->has($key.'non_value'));
+    }
+
+    public function testReplace()
+    {
+        $this->session->replace(array('happiness' => 'be good', 'symfony' => 'awesome'));
+        $this->assertEquals(array('happiness' => 'be good', 'symfony' => 'awesome'), $this->session->all());
+        $this->session->replace(array());
+        $this->assertEquals(array(), $this->session->all());
+    }
+
+    /**
+     * @dataProvider setProvider
+     */
+    public function testAll($key, $value, $result)
+    {
+        $this->session->set($key, $value);
+        $this->assertEquals($result, $this->session->all());
+    }
+
+    /**
+     * @dataProvider setProvider
+     */
+    public function testClear($key, $value)
+    {
+        $this->session->set('hi', 'fabien');
+        $this->session->set($key, $value);
+        $this->session->clear();
+        $this->assertEquals(array(), $this->session->all());
+    }
+
+    public function setProvider()
+    {
+        return array(
+            array('foo', 'bar', array('foo' => 'bar')),
+            array('foo.bar', 'too much beer', array('foo.bar' => 'too much beer')),
+            array('great', 'symfony2 is great', array('great' => 'symfony2 is great')),
+        );
+    }
+
+    /**
+     * @dataProvider setProvider
+     */
+    public function testRemove($key, $value)
+    {
+        $this->session->set('hi.world', 'have a nice day');
+        $this->session->set($key, $value);
+        $this->session->remove($key);
+        $this->assertEquals(array('hi.world' => 'have a nice day'), $this->session->all());
+    }
+
+    public function testInvalidate()
+    {
+        $this->session->set('invalidate', 123);
+        $this->session->invalidate();
+        $this->assertEquals(array(), $this->session->all());
+    }
+
+    public function testMigrate()
+    {
+        $this->session->set('migrate', 321);
+        $this->session->migrate();
+        $this->assertEquals(321, $this->session->get('migrate'));
+    }
+
+    public function testMigrateDestroy()
+    {
+        $this->session->set('migrate', 333);
+        $this->session->migrate(true);
+        $this->assertEquals(333, $this->session->get('migrate'));
+    }
+
+    public function testSave()
+    {
+        $this->session->start();
+        $this->session->save();
+    }
+
+    public function testGetId()
+    {
+        $this->assertEquals('', $this->session->getId());
+        $this->session->start();
+        $this->assertNotEquals('', $this->session->getId());
+    }
+
+    public function testGetFlashBag()
+    {
+        $this->assertInstanceOf('Symfony\\Component\\HttpFoundation\\Session\\Flash\\FlashBagInterface', $this->session->getFlashBag());
+    }
+
+    /**
+     * @covers Symfony\Component\HttpFoundation\Session\Session::getIterator
+     */
+    public function testGetIterator()
+    {
+        $attributes = array('hello' => 'world', 'symfony2' => 'rocks');
+        foreach ($attributes as $key => $val) {
+            $this->session->set($key, $val);
+        }
+
+        $i = 0;
+        foreach ($this->session as $key => $val) {
+            $this->assertEquals($attributes[$key], $val);
+            $i++;
+        }
+
+        $this->assertEquals(count($attributes), $i);
+    }
+
+    /**
+     * @covers \Symfony\Component\HttpFoundation\Session\Session::count
+     */
+    public function testGetCount()
+    {
+        $this->session->set('hello', 'world');
+        $this->session->set('symfony2', 'rocks');
+
+        $this->assertEquals(2, count($this->session));
+    }
+
+    public function testGetMeta()
+    {
+        $this->assertInstanceOf('Symfony\Component\HttpFoundation\Session\Storage\MetadataBag', $this->session->getMetadataBag());
+    }
+}

vendor/symfony/http-foundation/Symfony/Component/HttpFoundation/Tests/Session/Storage/Handler/MemcacheSessionHandlerTest.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\HttpFoundation\Tests\Session\Storage\Handler;
+
+use Symfony\Component\HttpFoundation\Session\Storage\Handler\MemcacheSessionHandler;
+
+class MemcacheSessionHandlerTest extends \PHPUnit_Framework_TestCase
+{
+    const PREFIX = 'prefix_';
+    const TTL = 1000;
+    /**
+     * @var MemcacheSessionHandler
+     */
+    protected $storage;
+
+    protected $memcache;
+
+    protected function setUp()
+    {
+        if (!class_exists('Memcache')) {
+            $this->markTestSkipped('Skipped tests Memcache class is not present');
+        }
+
+        $this->memcache = $this->getMock('Memcache');
+        $this->storage = new MemcacheSessionHandler(
+            $this->memcache,
+            array('prefix' => self::PREFIX, 'expiretime' => self::TTL)
+        );
+    }
+
+    protected function tearDown()
+    {
+        $this->memcache = null;
+        $this->storage = null;
+    }
+
+    public function testOpenSession()
+    {
+        $this->assertTrue($this->storage->open('', ''));
+    }
+
+    public function testCloseSession()
+    {
+        $this->memcache
+            ->expects($this->once())
+            ->method('close')
+            ->will($this->returnValue(true))
+        ;
+
+        $this->assertTrue($this->storage->close());
+    }
+
+    public function testReadSession()
+    {
+        $this->memcache
+            ->expects($this->once())
+            ->method('get')
+            ->with(self::PREFIX.'id')
+        ;
+
+        $this->assertEquals('', $this->storage->read('id'));
+    }
+
+    public function testWriteSession()
+    {
+        $this->memcache
+            ->expects($this->once())
+            ->method('set')
+            ->with(self::PREFIX.'id', 'data', 0, $this->equalTo(time() + self::TTL, 2))
+            ->will($this->returnValue(true))
+        ;
+
+        $this->assertTrue($this->storage->write('id', 'data'));
+    }
+
+    public function testDestroySession()
+    {
+        $this->memcache
+            ->expects($this->once())
+            ->method('delete')
+            ->with(self::PREFIX.'id')
+            ->will($this->returnValue(true))
+        ;
+
+        $this->assertTrue($this->storage->destroy('id'));
+    }
+
+    public function testGcSession()
+    {
+        $this->assertTrue($this->storage->gc(123));
+    }
+
+    /**
+     * @dataProvider getOptionFixtures
+     */
+    public function testSupportedOptions($options, $supported)
+    {
+        try {
+            new MemcacheSessionHandler($this->memcache, $options);
+            $this->assertTrue($supported);
+        } catch (\InvalidArgumentException $e) {
+            $this->assertFalse($supported);
+        }
+    }
+
+    public function getOptionFixtures()
+    {
+        return array(
+            array(array('prefix' => 'session'), true),
+            array(array('expiretime' => 100), true),
+            array(array('prefix' => 'session', 'expiretime' => 200), true),
+            array(array('expiretime' => 100, 'foo' => 'bar'), false),
+        );
+    }
+}

vendor/symfony/http-foundation/Symfony/Component/HttpFoundation/Tests/Session/Storage/Handler/MemcachedSessionHandlerTest.php

@@ -0,0 +1,119 @@
+<?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\HttpFoundation\Tests\Session\Storage\Handler;
+
+use Symfony\Component\HttpFoundation\Session\Storage\Handler\MemcachedSessionHandler;
+
+class MemcachedSessionHandlerTest extends \PHPUnit_Framework_TestCase
+{
+    const PREFIX = 'prefix_';
+    const TTL = 1000;
+
+    /**
+     * @var MemcachedSessionHandler
+     */
+    protected $storage;
+
+    protected $memcached;
+
+    protected function setUp()
+    {
+        if (!class_exists('Memcached')) {
+            $this->markTestSkipped('Skipped tests Memcached class is not present');
+        }
+
+        $this->memcached = $this->getMock('Memcached');
+        $this->storage = new MemcachedSessionHandler(
+            $this->memcached,
+            array('prefix' => self::PREFIX, 'expiretime' => self::TTL)
+        );
+    }
+
+    protected function tearDown()
+    {
+        $this->memcached = null;
+        $this->storage = null;
+    }
+
+    public function testOpenSession()
+    {
+        $this->assertTrue($this->storage->open('', ''));
+    }
+
+    public function testCloseSession()
+    {
+        $this->assertTrue($this->storage->close());
+    }
+
+    public function testReadSession()
+    {
+        $this->memcached
+            ->expects($this->once())
+            ->method('get')
+            ->with(self::PREFIX.'id')
+        ;
+
+        $this->assertEquals('', $this->storage->read('id'));
+    }
+
+    public function testWriteSession()
+    {
+        $this->memcached
+            ->expects($this->once())
+            ->method('set')
+            ->with(self::PREFIX.'id', 'data', $this->equalTo(time() + self::TTL, 2))
+            ->will($this->returnValue(true))
+        ;
+
+        $this->assertTrue($this->storage->write('id', 'data'));
+    }
+
+    public function testDestroySession()
+    {
+        $this->memcached
+            ->expects($this->once())
+            ->method('delete')
+            ->with(self::PREFIX.'id')
+            ->will($this->returnValue(true))
+        ;
+
+        $this->assertTrue($this->storage->destroy('id'));
+    }
+
+    public function testGcSession()
+    {
+        $this->assertTrue($this->storage->gc(123));
+    }
+
+    /**
+     * @dataProvider getOptionFixtures
+     */
+    public function testSupportedOptions($options, $supported)
+    {
+        try {
+            new MemcachedSessionHandler($this->memcached, $options);
+            $this->assertTrue($supported);
+        } catch (\InvalidArgumentException $e) {
+            $this->assertFalse($supported);
+        }
+    }
+
+    public function getOptionFixtures()
+    {
+        return array(
+            array(array('prefix' => 'session'), true),
+            array(array('expiretime' => 100), true),
+            array(array('prefix' => 'session', 'expiretime' => 200), true),
+            array(array('expiretime' => 100, 'foo' => 'bar'), false),
+        );
+    }
+}

vendor/symfony/http-foundation/Symfony/Component/HttpFoundation/Tests/Session/Storage/Handler/MongoDbSessionHandlerTest.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\HttpFoundation\Tests\Session\Storage\Handler;
+
+use Symfony\Component\HttpFoundation\Session\Storage\Handler\MongoDbSessionHandler;
+
+/**
+ * @author Markus Bachmann <markus.bachmann@bachi.biz>
+ */
+class MongoDbSessionHandlerTest extends \PHPUnit_Framework_TestCase
+{
+    /**
+     * @var \PHPUnit_Framework_MockObject_MockObject
+     */
+    private $mongo;
+    private $storage;
+    public $options;
+
+    protected function setUp()
+    {
+        if (!extension_loaded('mongo')) {
+            $this->markTestSkipped('MongoDbSessionHandler requires the PHP "mongo" extension.');
+        }
+
+        $mongoClass = (version_compare(phpversion('mongo'), '1.3.0', '<')) ? 'Mongo' : 'MongoClient';
+
+        $this->mongo = $this->getMockBuilder($mongoClass)
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        $this->options = array(
+            'id_field'   => '_id',
+            'data_field' => 'data',
+            'time_field' => 'time',
+            'database' => 'sf2-test',
+            'collection' => 'session-test'
+        );
+
+        $this->storage = new MongoDbSessionHandler($this->mongo, $this->options);
+    }
+
+    /**
+     * @expectedException InvalidArgumentException
+     */
+    public function testConstructorShouldThrowExceptionForInvalidMongo()
+    {
+        new MongoDbSessionHandler(new \stdClass(), $this->options);
+    }
+
+    /**
+     * @expectedException InvalidArgumentException
+     */
+    public function testConstructorShouldThrowExceptionForMissingOptions()
+    {
+        new MongoDbSessionHandler($this->mongo, array());
+    }
+
+    public function testOpenMethodAlwaysReturnTrue()
+    {
+        $this->assertTrue($this->storage->open('test', 'test'), 'The "open" method should always return true');
+    }
+
+    public function testCloseMethodAlwaysReturnTrue()
+    {
+        $this->assertTrue($this->storage->close(), 'The "close" method should always return true');
+    }
+
+    public function testWrite()
+    {
+        $collection = $this->getMockBuilder('MongoCollection')
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        $this->mongo->expects($this->once())
+            ->method('selectCollection')
+            ->with($this->options['database'], $this->options['collection'])
+            ->will($this->returnValue($collection));
+
+        $that = $this;
+        $data = array();
+
+        $collection->expects($this->once())
+            ->method('update')
+            ->will($this->returnCallback(function($criteria, $updateData, $options) use ($that, &$data) {
+                $that->assertEquals(array($that->options['id_field'] => 'foo'), $criteria);
+                $that->assertEquals(array('upsert' => true, 'multiple' => false), $options);
+
+                $data = $updateData['$set'];
+            }));
+
+        $this->assertTrue($this->storage->write('foo', 'bar'));
+
+        $this->assertEquals('bar', $data[$this->options['data_field']]->bin);
+        $that->assertInstanceOf('MongoDate', $data[$this->options['time_field']]);
+    }
+
+    public function testReplaceSessionData()
+    {
+        $collection = $this->getMockBuilder('MongoCollection')
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        $this->mongo->expects($this->once())
+            ->method('selectCollection')
+            ->with($this->options['database'], $this->options['collection'])
+            ->will($this->returnValue($collection));
+
+        $data = array();
+
+        $collection->expects($this->exactly(2))
+            ->method('update')
+            ->will($this->returnCallback(function($criteria, $updateData, $options) use (&$data) {
+                $data = $updateData;
+            }));
+
+        $this->storage->write('foo', 'bar');
+        $this->storage->write('foo', 'foobar');
+
+        $this->assertEquals('foobar', $data['$set'][$this->options['data_field']]->bin);
+    }
+
+    public function testDestroy()
+    {
+        $collection = $this->getMockBuilder('MongoCollection')
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        $this->mongo->expects($this->once())
+            ->method('selectCollection')
+            ->with($this->options['database'], $this->options['collection'])
+            ->will($this->returnValue($collection));
+
+        $collection->expects($this->once())
+            ->method('remove')
+            ->with(array($this->options['id_field'] => 'foo'));
+
+        $this->assertTrue($this->storage->destroy('foo'));
+    }
+
+    public function testGc()
+    {
+        $collection = $this->getMockBuilder('MongoCollection')
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        $this->mongo->expects($this->once())
+            ->method('selectCollection')
+            ->with($this->options['database'], $this->options['collection'])
+            ->will($this->returnValue($collection));
+
+        $that = $this;
+
+        $collection->expects($this->once())
+            ->method('remove')
+            ->will($this->returnCallback(function($criteria) use ($that) {
+                $that->assertInstanceOf('MongoDate', $criteria[$that->options['time_field']]['$lt']);
+                $that->assertGreaterThanOrEqual(time() - -1, $criteria[$that->options['time_field']]['$lt']->sec);
+            }));
+
+        $this->assertTrue($this->storage->gc(-1));
+    }
+}

vendor/symfony/http-foundation/Symfony/Component/HttpFoundation/Tests/Session/Storage/Handler/NativeFileSessionHandlerTest.php

@@ -0,0 +1,80 @@
+<?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\HttpFoundation\Tests\Session\Storage\Handler;
+
+use Symfony\Component\HttpFoundation\Session\Storage\Handler\NativeFileSessionHandler;
+use Symfony\Component\HttpFoundation\Session\Storage\NativeSessionStorage;
+
+/**
+ * Test class for NativeFileSessionHandler.
+ *
+ * @author Drak <drak@zikula.org>
+ *
+ * @runTestsInSeparateProcesses
+ */
+class NativeFileSessionHandlerTest extends \PHPUnit_Framework_TestCase
+{
+    public function testConstruct()
+    {
+        $storage = new NativeSessionStorage(array('name' => 'TESTING'), new NativeFileSessionHandler(sys_get_temp_dir()));
+
+        if (version_compare(phpversion(), '5.4.0', '<')) {
+            $this->assertEquals('files', $storage->getSaveHandler()->getSaveHandlerName());
+            $this->assertEquals('files', ini_get('session.save_handler'));
+        } else {
+            $this->assertEquals('files', $storage->getSaveHandler()->getSaveHandlerName());
+            $this->assertEquals('user', ini_get('session.save_handler'));
+        }
+
+        $this->assertEquals(sys_get_temp_dir(), ini_get('session.save_path'));
+        $this->assertEquals('TESTING', ini_get('session.name'));
+    }
+
+    /**
+     * @dataProvider savePathDataProvider
+     */
+    public function testConstructSavePath($savePath, $expectedSavePath, $path)
+    {
+        $handler = new NativeFileSessionHandler($savePath);
+        $this->assertEquals($expectedSavePath, ini_get('session.save_path'));
+        $this->assertTrue(is_dir(realpath($path)));
+
+        rmdir($path);
+    }
+
+    public function savePathDataProvider()
+    {
+        $base = sys_get_temp_dir();
+
+        return array(
+            array("$base/foo", "$base/foo", "$base/foo"),
+            array("5;$base/foo", "5;$base/foo", "$base/foo"),
+            array("5;0600;$base/foo", "5;0600;$base/foo", "$base/foo"),
+        );
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     */
+    public function testConstructException()
+    {
+        $handler = new NativeFileSessionHandler('something;invalid;with;too-many-args');
+    }
+
+    public function testConstructDefault()
+    {
+        $path = ini_get('session.save_path');
+        $storage = new NativeSessionStorage(array('name' => 'TESTING'), new NativeFileSessionHandler());
+
+        $this->assertEquals($path, ini_get('session.save_path'));
+    }
+}

vendor/symfony/http-foundation/Symfony/Component/HttpFoundation/Tests/Session/Storage/Handler/NativeSessionHandlerTest.php

@@ -0,0 +1,39 @@
+<?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\HttpFoundation\Tests\Session\Storage\Handler;
+
+use Symfony\Component\HttpFoundation\Session\Storage\Handler\NativeSessionHandler;
+
+/**
+ * Test class for NativeSessionHandler.
+ *
+ * @author Drak <drak@zikula.org>
+ *
+ * @runTestsInSeparateProcesses
+ */
+class NativeSessionHandlerTest extends \PHPUnit_Framework_TestCase
+{
+    public function testConstruct()
+    {
+        $handler = new NativeSessionHandler();
+
+        // note for PHPUnit optimisers - the use of assertTrue/False
+        // here is deliberate since the tests do not require the classes to exist - drak
+        if (version_compare(phpversion(), '5.4.0', '<')) {
+            $this->assertFalse($handler instanceof \SessionHandler);
+            $this->assertTrue($handler instanceof NativeSessionHandler);
+        } else {
+            $this->assertTrue($handler instanceof \SessionHandler);
+            $this->assertTrue($handler instanceof NativeSessionHandler);
+        }
+    }
+}

vendor/symfony/http-foundation/Symfony/Component/HttpFoundation/Tests/Session/Storage/Handler/NullSessionHandlerTest.php

@@ -0,0 +1,57 @@
+<?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\HttpFoundation\Tests\Session\Storage\Handler;
+
+use Symfony\Component\HttpFoundation\Session\Storage\Handler\NullSessionHandler;
+use Symfony\Component\HttpFoundation\Session\Storage\NativeSessionStorage;
+use Symfony\Component\HttpFoundation\Session\Session;
+
+/**
+ * Test class for NullSessionHandler.
+ *
+ * @author Drak <drak@zikula.org>
+ *
+ * @runTestsInSeparateProcesses
+ */
+class NullSessionStorageTest extends \PHPUnit_Framework_TestCase
+{
+    public function testSaveHandlers()
+    {
+        $storage = $this->getStorage();
+        $this->assertEquals('user', ini_get('session.save_handler'));
+    }
+
+    public function testSession()
+    {
+        session_id('nullsessionstorage');
+        $storage = $this->getStorage();
+        $session = new Session($storage);
+        $this->assertNull($session->get('something'));
+        $session->set('something', 'unique');
+        $this->assertEquals('unique', $session->get('something'));
+    }
+
+    public function testNothingIsPersisted()
+    {
+        session_id('nullsessionstorage');
+        $storage = $this->getStorage();
+        $session = new Session($storage);
+        $session->start();
+        $this->assertEquals('nullsessionstorage', $session->getId());
+        $this->assertNull($session->get('something'));
+    }
+
+    public function getStorage()
+    {
+        return new NativeSessionStorage(array(), new NullSessionHandler());
+    }
+}

vendor/symfony/http-foundation/Symfony/Component/HttpFoundation/Tests/Session/Storage/Handler/PdoSessionHandlerTest.php

@@ -0,0 +1,101 @@
+<?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\HttpFoundation\Tests\Session\Storage\Handler;
+
+use Symfony\Component\HttpFoundation\Session\Storage\Handler\PdoSessionHandler;
+
+class PdoSessionHandlerTest extends \PHPUnit_Framework_TestCase
+{
+    private $pdo;
+
+    protected function setUp()
+    {
+        if (!class_exists('PDO') || !in_array('sqlite', \PDO::getAvailableDrivers())) {
+            $this->markTestSkipped('This test requires SQLite support in your environment');
+        }
+
+        $this->pdo = new \PDO("sqlite::memory:");
+        $this->pdo->setAttribute(\PDO::ATTR_ERRMODE, \PDO::ERRMODE_EXCEPTION);
+        $sql = "CREATE TABLE sessions (sess_id VARCHAR(255) PRIMARY KEY, sess_data TEXT, sess_time INTEGER)";
+        $this->pdo->exec($sql);
+    }
+
+    public function testIncompleteOptions()
+    {
+        $this->setExpectedException('InvalidArgumentException');
+        $storage = new PdoSessionHandler($this->pdo, array(), array());
+    }
+
+    public function testWrongPdoErrMode()
+    {
+        $pdo = new \PDO("sqlite::memory:");
+        $pdo->setAttribute(\PDO::ATTR_ERRMODE, \PDO::ERRMODE_SILENT);
+        $pdo->exec("CREATE TABLE sessions (sess_id VARCHAR(255) PRIMARY KEY, sess_data TEXT, sess_time INTEGER)");
+
+        $this->setExpectedException('InvalidArgumentException');
+        $storage = new PdoSessionHandler($pdo, array('db_table' => 'sessions'), array());
+    }
+
+    public function testWrongTableOptionsWrite()
+    {
+        $storage = new PdoSessionHandler($this->pdo, array('db_table' => 'bad_name'), array());
+        $this->setExpectedException('RuntimeException');
+        $storage->write('foo', 'bar');
+    }
+
+    public function testWrongTableOptionsRead()
+    {
+        $storage = new PdoSessionHandler($this->pdo, array('db_table' => 'bad_name'), array());
+        $this->setExpectedException('RuntimeException');
+        $storage->read('foo', 'bar');
+    }
+
+    public function testWriteRead()
+    {
+        $storage = new PdoSessionHandler($this->pdo, array('db_table' => 'sessions'), array());
+        $storage->write('foo', 'bar');
+        $this->assertEquals('bar', $storage->read('foo'), 'written value can be read back correctly');
+    }
+
+    public function testMultipleInstances()
+    {
+        $storage1 = new PdoSessionHandler($this->pdo, array('db_table' => 'sessions'), array());
+        $storage1->write('foo', 'bar');
+
+        $storage2 = new PdoSessionHandler($this->pdo, array('db_table' => 'sessions'), array());
+        $this->assertEquals('bar', $storage2->read('foo'), 'values persist between instances');
+    }
+
+    public function testSessionDestroy()
+    {
+        $storage = new PdoSessionHandler($this->pdo, array('db_table' => 'sessions'), array());
+        $storage->write('foo', 'bar');
+        $this->assertEquals(1, count($this->pdo->query('SELECT * FROM sessions')->fetchAll()));
+
+        $storage->destroy('foo');
+
+        $this->assertEquals(0, count($this->pdo->query('SELECT * FROM sessions')->fetchAll()));
+    }
+
+    public function testSessionGC()
+    {
+        $storage = new PdoSessionHandler($this->pdo, array('db_table' => 'sessions'), array());
+
+        $storage->write('foo', 'bar');
+        $storage->write('baz', 'bar');
+
+        $this->assertEquals(2, count($this->pdo->query('SELECT * FROM sessions')->fetchAll()));
+
+        $storage->gc(-1);
+        $this->assertEquals(0, count($this->pdo->query('SELECT * FROM sessions')->fetchAll()));
+    }
+}

vendor/symfony/http-foundation/Symfony/Component/HttpFoundation/Tests/Session/Storage/MetadataBagTest.php

@@ -0,0 +1,107 @@
+<?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\HttpFoundation\Tests\Session\Storage;
+
+use Symfony\Component\HttpFoundation\Session\Storage\MetadataBag;
+
+/**
+ * Test class for MetadataBag.
+ */
+class MetadataBagTest extends \PHPUnit_Framework_TestCase
+{
+    /**
+     * @var MetadataBag
+     */
+    protected $bag;
+
+    /**
+     * @var array
+     */
+    protected $array = array();
+
+    protected function setUp()
+    {
+        $this->bag = new MetadataBag();
+        $this->array = array(MetadataBag::CREATED => 1234567, MetadataBag::UPDATED => 12345678, MetadataBag::LIFETIME => 0);
+        $this->bag->initialize($this->array);
+    }
+
+    protected function tearDown()
+    {
+        $this->array = array();
+        $this->bag = null;
+    }
+
+    public function testInitialize()
+    {
+        $p = new \ReflectionProperty('Symfony\Component\HttpFoundation\Session\Storage\MetadataBag', 'meta');
+        $p->setAccessible(true);
+
+        $bag1 = new MetadataBag();
+        $array = array();
+        $bag1->initialize($array);
+        $this->assertGreaterThanOrEqual(time(), $bag1->getCreated());
+        $this->assertEquals($bag1->getCreated(), $bag1->getLastUsed());
+
+        sleep(1);
+        $bag2 = new MetadataBag();
+        $array2 = $p->getValue($bag1);
+        $bag2->initialize($array2);
+        $this->assertEquals($bag1->getCreated(), $bag2->getCreated());
+        $this->assertEquals($bag1->getLastUsed(), $bag2->getLastUsed());
+        $this->assertEquals($bag2->getCreated(), $bag2->getLastUsed());
+
+        sleep(1);
+        $bag3 = new MetadataBag();
+        $array3 = $p->getValue($bag2);
+        $bag3->initialize($array3);
+        $this->assertEquals($bag1->getCreated(), $bag3->getCreated());
+        $this->assertGreaterThan($bag2->getLastUsed(), $bag3->getLastUsed());
+        $this->assertNotEquals($bag3->getCreated(), $bag3->getLastUsed());
+    }
+
+    public function testGetSetName()
+    {
+        $this->assertEquals('__metadata', $this->bag->getName());
+        $this->bag->setName('foo');
+        $this->assertEquals('foo', $this->bag->getName());
+
+    }
+
+    public function testGetStorageKey()
+    {
+        $this->assertEquals('_sf2_meta', $this->bag->getStorageKey());
+    }
+
+    public function testGetLifetime()
+    {
+        $bag = new MetadataBag();
+        $array = array(MetadataBag::CREATED => 1234567, MetadataBag::UPDATED => 12345678, MetadataBag::LIFETIME => 1000);
+        $bag->initialize($array);
+        $this->assertEquals(1000, $bag->getLifetime());
+    }
+
+    public function testGetCreated()
+    {
+        $this->assertEquals(1234567, $this->bag->getCreated());
+    }
+
+    public function testGetLastUsed()
+    {
+        $this->assertLessThanOrEqual(time(), $this->bag->getLastUsed());
+    }
+
+    public function testClear()
+    {
+        $this->bag->clear();
+    }
+}

vendor/symfony/http-foundation/Symfony/Component/HttpFoundation/Tests/Session/Storage/MockArraySessionStorageTest.php

@@ -0,0 +1,106 @@
+<?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\HttpFoundation\Tests\Session\Storage;
+
+use Symfony\Component\HttpFoundation\Session\Storage\MockArraySessionStorage;
+use Symfony\Component\HttpFoundation\Session\Attribute\AttributeBag;
+use Symfony\Component\HttpFoundation\Session\Flash\FlashBag;
+
+/**
+ * Test class for MockArraySessionStorage.
+ *
+ * @author Drak <drak@zikula.org>
+ */
+class MockArraySessionStorageTest extends \PHPUnit_Framework_TestCase
+{
+    /**
+     * @var MockArraySessionStorage
+     */
+    private $storage;
+
+    /**
+     * @var AttributeBag
+     */
+    private $attributes;
+
+    /**
+     * @var FlashBag
+     */
+    private $flashes;
+
+    private $data;
+
+    protected function setUp()
+    {
+        $this->attributes = new AttributeBag();
+        $this->flashes = new FlashBag();
+
+        $this->data = array(
+            $this->attributes->getStorageKey() => array('foo' => 'bar'),
+            $this->flashes->getStorageKey() => array('notice' => 'hello'),
+            );
+
+        $this->storage = new MockArraySessionStorage();
+        $this->storage->registerBag($this->flashes);
+        $this->storage->registerBag($this->attributes);
+        $this->storage->setSessionData($this->data);
+    }
+
+    protected function tearDown()
+    {
+        $this->data = null;
+        $this->flashes = null;
+        $this->attributes = null;
+        $this->storage = null;
+    }
+
+    public function testStart()
+    {
+        $this->assertEquals('', $this->storage->getId());
+        $this->storage->start();
+        $id = $this->storage->getId();
+        $this->assertNotEquals('', $id);
+        $this->storage->start();
+        $this->assertEquals($id, $this->storage->getId());
+    }
+
+    public function testRegenerate()
+    {
+        $this->storage->start();
+        $id = $this->storage->getId();
+        $this->storage->regenerate();
+        $this->assertNotEquals($id, $this->storage->getId());
+        $this->assertEquals(array('foo' => 'bar'), $this->storage->getBag('attributes')->all());
+        $this->assertEquals(array('notice' => 'hello'), $this->storage->getBag('flashes')->peekAll());
+
+        $id = $this->storage->getId();
+        $this->storage->regenerate(true);
+        $this->assertNotEquals($id, $this->storage->getId());
+        $this->assertEquals(array('foo' => 'bar'), $this->storage->getBag('attributes')->all());
+        $this->assertEquals(array('notice' => 'hello'), $this->storage->getBag('flashes')->peekAll());
+    }
+
+    public function testGetId()
+    {
+        $this->assertEquals('', $this->storage->getId());
+        $this->storage->start();
+        $this->assertNotEquals('', $this->storage->getId());
+    }
+
+    /**
+     * @expectedException RuntimeException
+     */
+    public function testUnstartedSave()
+    {
+        $this->storage->save();
+    }
+}

vendor/symfony/http-foundation/Symfony/Component/HttpFoundation/Tests/Session/Storage/MockFileSessionStorageTest.php

@@ -0,0 +1,126 @@
+<?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\HttpFoundation\Tests\Session\Storage;
+
+use Symfony\Component\HttpFoundation\Session\Storage\MockFileSessionStorage;
+use Symfony\Component\HttpFoundation\Session\Flash\FlashBag;
+use Symfony\Component\HttpFoundation\Session\Attribute\AttributeBag;
+
+/**
+ * Test class for MockFileSessionStorage.
+ *
+ * @author Drak <drak@zikula.org>
+ */
+class MockFileSessionStorageTest extends \PHPUnit_Framework_TestCase
+{
+    /**
+     * @var string
+     */
+    private $sessionDir;
+
+    /**
+     * @var FileMockSessionStorage
+     */
+    protected $storage;
+
+    protected function setUp()
+    {
+        $this->sessionDir = sys_get_temp_dir().'/sf2test';
+        $this->storage = $this->getStorage();
+    }
+
+    protected function tearDown()
+    {
+        $this->sessionDir = null;
+        $this->storage = null;
+        array_map('unlink', glob($this->sessionDir.'/*.session'));
+        if (is_dir($this->sessionDir)) {
+            rmdir($this->sessionDir);
+        }
+    }
+
+    public function testStart()
+    {
+        $this->assertEquals('', $this->storage->getId());
+        $this->assertTrue($this->storage->start());
+        $id = $this->storage->getId();
+        $this->assertNotEquals('', $this->storage->getId());
+        $this->assertTrue($this->storage->start());
+        $this->assertEquals($id, $this->storage->getId());
+    }
+
+    public function testRegenerate()
+    {
+        $this->storage->start();
+        $this->storage->getBag('attributes')->set('regenerate', 1234);
+        $this->storage->regenerate();
+        $this->assertEquals(1234, $this->storage->getBag('attributes')->get('regenerate'));
+        $this->storage->regenerate(true);
+        $this->assertEquals(1234, $this->storage->getBag('attributes')->get('regenerate'));
+    }
+
+    public function testGetId()
+    {
+        $this->assertEquals('', $this->storage->getId());
+        $this->storage->start();
+        $this->assertNotEquals('', $this->storage->getId());
+    }
+
+    public function testSave()
+    {
+        $this->storage->start();
+        $id = $this->storage->getId();
+        $this->assertNotEquals('108', $this->storage->getBag('attributes')->get('new'));
+        $this->assertFalse($this->storage->getBag('flashes')->has('newkey'));
+        $this->storage->getBag('attributes')->set('new', '108');
+        $this->storage->getBag('flashes')->set('newkey', 'test');
+        $this->storage->save();
+
+        $storage = $this->getStorage();
+        $storage->setId($id);
+        $storage->start();
+        $this->assertEquals('108', $storage->getBag('attributes')->get('new'));
+        $this->assertTrue($storage->getBag('flashes')->has('newkey'));
+        $this->assertEquals(array('test'), $storage->getBag('flashes')->peek('newkey'));
+    }
+
+    public function testMultipleInstances()
+    {
+        $storage1 = $this->getStorage();
+        $storage1->start();
+        $storage1->getBag('attributes')->set('foo', 'bar');
+        $storage1->save();
+
+        $storage2 = $this->getStorage();
+        $storage2->setId($storage1->getId());
+        $storage2->start();
+        $this->assertEquals('bar', $storage2->getBag('attributes')->get('foo'), 'values persist between instances');
+    }
+
+    /**
+     * @expectedException RuntimeException
+     */
+    public function testSaveWithoutStart()
+    {
+        $storage1 = $this->getStorage();
+        $storage1->save();
+    }
+
+    private function getStorage()
+    {
+        $storage = new MockFileSessionStorage($this->sessionDir);
+        $storage->registerBag(new FlashBag());
+        $storage->registerBag(new AttributeBag());
+
+        return $storage;
+    }
+}

vendor/symfony/http-foundation/Symfony/Component/HttpFoundation/Tests/Session/Storage/NativeSessionStorageTest.php

@@ -0,0 +1,279 @@
+<?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\HttpFoundation\Tests\Session\Storage;
+
+use Symfony\Component\HttpFoundation\Session\Storage\Handler\NativeSessionHandler;
+use Symfony\Component\HttpFoundation\Session\Storage\NativeSessionStorage;
+use Symfony\Component\HttpFoundation\Session\Flash\FlashBag;
+use Symfony\Component\HttpFoundation\Session\Attribute\AttributeBag;
+use Symfony\Component\HttpFoundation\Session\Storage\Proxy\NativeProxy;
+use Symfony\Component\HttpFoundation\Session\Storage\Proxy\SessionHandlerProxy;
+
+/**
+ * Test class for NativeSessionStorage.
+ *
+ * @author Drak <drak@zikula.org>
+ *
+ * These tests require separate processes.
+ *
+ * @runTestsInSeparateProcesses
+ */
+class NativeSessionStorageTest extends \PHPUnit_Framework_TestCase
+{
+    private $savePath;
+
+    protected function setUp()
+    {
+        ini_set('session.save_handler', 'files');
+        ini_set('session.save_path', $this->savePath = sys_get_temp_dir().'/sf2test');
+        if (!is_dir($this->savePath)) {
+            mkdir($this->savePath);
+        }
+    }
+
+    protected function tearDown()
+    {
+        session_write_close();
+        array_map('unlink', glob($this->savePath.'/*'));
+        if (is_dir($this->savePath)) {
+            rmdir($this->savePath);
+        }
+
+        $this->savePath = null;
+    }
+
+    /**
+     * @param array $options
+     *
+     * @return NativeSessionStorage
+     */
+    protected function getStorage(array $options = array())
+    {
+        $storage = new NativeSessionStorage($options);
+        $storage->registerBag(new AttributeBag);
+
+        return $storage;
+    }
+
+    public function testBag()
+    {
+        $storage = $this->getStorage();
+        $bag = new FlashBag();
+        $storage->registerBag($bag);
+        $this->assertSame($bag, $storage->getBag($bag->getName()));
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     */
+    public function testRegisterBagException()
+    {
+        $storage = $this->getStorage();
+        $storage->getBag('non_existing');
+    }
+
+    public function testGetId()
+    {
+        $storage = $this->getStorage();
+        $this->assertEquals('', $storage->getId());
+        $storage->start();
+        $this->assertNotEquals('', $storage->getId());
+    }
+
+    public function testRegenerate()
+    {
+        $storage = $this->getStorage();
+        $storage->start();
+        $id = $storage->getId();
+        $storage->getBag('attributes')->set('lucky', 7);
+        $storage->regenerate();
+        $this->assertNotEquals($id, $storage->getId());
+        $this->assertEquals(7, $storage->getBag('attributes')->get('lucky'));
+    }
+
+    public function testRegenerateDestroy()
+    {
+        $storage = $this->getStorage();
+        $storage->start();
+        $id = $storage->getId();
+        $storage->getBag('attributes')->set('legs', 11);
+        $storage->regenerate(true);
+        $this->assertNotEquals($id, $storage->getId());
+        $this->assertEquals(11, $storage->getBag('attributes')->get('legs'));
+    }
+
+    public function testDefaultSessionCacheLimiter()
+    {
+        ini_set('session.cache_limiter', 'nocache');
+
+        $storage = new NativeSessionStorage();
+        $this->assertEquals('', ini_get('session.cache_limiter'));
+    }
+
+    public function testExplicitSessionCacheLimiter()
+    {
+        ini_set('session.cache_limiter', 'nocache');
+
+        $storage = new NativeSessionStorage(array('cache_limiter' => 'public'));
+        $this->assertEquals('public', ini_get('session.cache_limiter'));
+    }
+
+    public function testCookieOptions()
+    {
+        $options = array(
+            'cookie_lifetime' => 123456,
+            'cookie_path' => '/my/cookie/path',
+            'cookie_domain' => 'symfony2.example.com',
+            'cookie_secure' => true,
+            'cookie_httponly' => false,
+        );
+
+        $this->getStorage($options);
+        $temp = session_get_cookie_params();
+        $gco = array();
+
+        foreach ($temp as $key => $value) {
+            $gco['cookie_'.$key] = $value;
+        }
+
+        $this->assertEquals($options, $gco);
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     */
+    public function testSetSaveHandlerException()
+    {
+        $storage = $this->getStorage();
+        $storage->setSaveHandler(new \StdClass);
+    }
+
+    public function testSetSaveHandler53()
+    {
+        if (version_compare(phpversion(), '5.4.0', '>=')) {
+            $this->markTestSkipped('Test skipped, for PHP 5.3 only.');
+        }
+
+        ini_set('session.save_handler', 'files');
+        $storage = $this->getStorage();
+        $storage->setSaveHandler();
+        $this->assertInstanceOf('Symfony\Component\HttpFoundation\Session\Storage\Proxy\NativeProxy', $storage->getSaveHandler());
+        $storage->setSaveHandler(null);
+        $this->assertInstanceOf('Symfony\Component\HttpFoundation\Session\Storage\Proxy\NativeProxy', $storage->getSaveHandler());
+        $storage->setSaveHandler(new NativeSessionHandler());
+        $this->assertInstanceOf('Symfony\Component\HttpFoundation\Session\Storage\Proxy\NativeProxy', $storage->getSaveHandler());
+        $storage->setSaveHandler(new SessionHandlerProxy(new SessionHandler()));
+        $this->assertInstanceOf('Symfony\Component\HttpFoundation\Session\Storage\Proxy\SessionHandlerProxy', $storage->getSaveHandler());
+        $storage->setSaveHandler(new SessionHandler());
+        $this->assertInstanceOf('Symfony\Component\HttpFoundation\Session\Storage\Proxy\SessionHandlerProxy', $storage->getSaveHandler());
+        $storage->setSaveHandler(new NativeProxy());
+        $this->assertInstanceOf('Symfony\Component\HttpFoundation\Session\Storage\Proxy\NativeProxy', $storage->getSaveHandler());
+    }
+
+    public function testSetSaveHandler54()
+    {
+        if (version_compare(phpversion(), '5.4.0', '<')) {
+            $this->markTestSkipped('Test skipped, for PHP 5.4 only.');
+        }
+
+        ini_set('session.save_handler', 'files');
+        $storage = $this->getStorage();
+        $storage->setSaveHandler();
+        $this->assertInstanceOf('Symfony\Component\HttpFoundation\Session\Storage\Proxy\SessionHandlerProxy', $storage->getSaveHandler());
+        $storage->setSaveHandler(null);
+        $this->assertInstanceOf('Symfony\Component\HttpFoundation\Session\Storage\Proxy\SessionHandlerProxy', $storage->getSaveHandler());
+        $storage->setSaveHandler(new SessionHandlerProxy(new NativeSessionHandler()));
+        $this->assertInstanceOf('Symfony\Component\HttpFoundation\Session\Storage\Proxy\SessionHandlerProxy', $storage->getSaveHandler());
+        $storage->setSaveHandler(new NativeSessionHandler());
+        $this->assertInstanceOf('Symfony\Component\HttpFoundation\Session\Storage\Proxy\SessionHandlerProxy', $storage->getSaveHandler());
+        $storage->setSaveHandler(new SessionHandlerProxy(new SessionHandler()));
+        $this->assertInstanceOf('Symfony\Component\HttpFoundation\Session\Storage\Proxy\SessionHandlerProxy', $storage->getSaveHandler());
+        $storage->setSaveHandler(new SessionHandler());
+        $this->assertInstanceOf('Symfony\Component\HttpFoundation\Session\Storage\Proxy\SessionHandlerProxy', $storage->getSaveHandler());
+    }
+
+    /**
+     * @expectedException \RuntimeException
+     */
+    public function testStartedOutside53()
+    {
+        if (version_compare(phpversion(), '5.4.0', '>=')) {
+            $this->markTestSkipped('Test skipped, for PHP 5.3 only.');
+        }
+
+        $storage = $this->getStorage();
+
+        $this->assertFalse(isset($_SESSION));
+
+        session_start();
+        $this->assertTrue(isset($_SESSION));
+        // PHP session might have started, but the storage driver has not, so false is correct here
+        $this->assertFalse($storage->isStarted());
+
+        $key = $storage->getMetadataBag()->getStorageKey();
+        $this->assertFalse(isset($_SESSION[$key]));
+        $storage->start();
+    }
+
+    /**
+     * @expectedException \RuntimeException
+     */
+    public function testCanStartOutside54()
+    {
+        if (version_compare(phpversion(), '5.4.0', '<')) {
+            $this->markTestSkipped('Test skipped, for PHP 5.4 only.');
+        }
+
+        $storage = $this->getStorage();
+
+        $this->assertFalse(isset($_SESSION));
+        $this->assertFalse($storage->getSaveHandler()->isActive());
+        $this->assertFalse($storage->isStarted());
+
+        session_start();
+        $this->assertTrue(isset($_SESSION));
+        $this->assertTrue($storage->getSaveHandler()->isActive());
+        // PHP session might have started, but the storage driver has not, so false is correct here
+        $this->assertFalse($storage->isStarted());
+
+        $key = $storage->getMetadataBag()->getStorageKey();
+        $this->assertFalse(isset($_SESSION[$key]));
+        $storage->start();
+    }
+}
+
+class SessionHandler implements \SessionHandlerInterface
+{
+    public function open($savePath, $sessionName)
+    {
+    }
+
+    public function close()
+    {
+    }
+
+    public function read($id)
+    {
+    }
+
+    public function write($id, $data)
+    {
+    }
+
+    public function destroy($id)
+    {
+    }
+
+    public function gc($maxlifetime)
+    {
+    }
+}

vendor/symfony/http-foundation/Symfony/Component/HttpFoundation/Tests/Session/Storage/PhpBridgeSessionStorageTest.php

@@ -0,0 +1,123 @@
+<?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\HttpFoundation\Tests\Session\Storage;
+
+use Symfony\Component\HttpFoundation\Session\Storage\PhpBridgeSessionStorage;
+use Symfony\Component\HttpFoundation\Session\Attribute\AttributeBag;
+
+/**
+ * Test class for PhpSessionStorage.
+ *
+ * @author Drak <drak@zikula.org>
+ *
+ * These tests require separate processes.
+ *
+ * @runTestsInSeparateProcesses
+ */
+class PhpSessionStorageTest extends \PHPUnit_Framework_TestCase
+{
+    private $savePath;
+
+    protected function setUp()
+    {
+        ini_set('session.save_handler', 'files');
+        ini_set('session.save_path', $this->savePath = sys_get_temp_dir().'/sf2test');
+        if (!is_dir($this->savePath)) {
+            mkdir($this->savePath);
+        }
+    }
+
+    protected function tearDown()
+    {
+        session_write_close();
+        array_map('unlink', glob($this->savePath.'/*'));
+        if (is_dir($this->savePath)) {
+            rmdir($this->savePath);
+        }
+
+        $this->savePath = null;
+    }
+
+    /**
+     * @return PhpBridgeSessionStorage
+     */
+    protected function getStorage()
+    {
+        $storage = new PhpBridgeSessionStorage();
+        $storage->registerBag(new AttributeBag);
+
+        return $storage;
+    }
+
+    public function testPhpSession53()
+    {
+        if (version_compare(phpversion(), '5.4.0', '>=')) {
+            $this->markTestSkipped('Test skipped, for PHP 5.3 only.');
+        }
+
+        $storage = $this->getStorage();
+
+        $this->assertFalse(isset($_SESSION));
+        $this->assertFalse($storage->getSaveHandler()->isActive());
+
+        session_start();
+        $this->assertTrue(isset($_SESSION));
+        // in PHP 5.3 we cannot reliably tell if a session has started
+        $this->assertFalse($storage->getSaveHandler()->isActive());
+        // PHP session might have started, but the storage driver has not, so false is correct here
+        $this->assertFalse($storage->isStarted());
+
+        $key = $storage->getMetadataBag()->getStorageKey();
+        $this->assertFalse(isset($_SESSION[$key]));
+        $storage->start();
+        $this->assertTrue(isset($_SESSION[$key]));
+    }
+
+    public function testPhpSession54()
+    {
+        if (version_compare(phpversion(), '5.4.0', '<')) {
+            $this->markTestSkipped('Test skipped, for PHP 5.4 only.');
+        }
+
+        $storage = $this->getStorage();
+
+        $this->assertFalse(isset($_SESSION));
+        $this->assertFalse($storage->getSaveHandler()->isActive());
+        $this->assertFalse($storage->isStarted());
+
+        session_start();
+        $this->assertTrue(isset($_SESSION));
+        // in PHP 5.4 we can reliably detect a session started
+        $this->assertTrue($storage->getSaveHandler()->isActive());
+        // PHP session might have started, but the storage driver has not, so false is correct here
+        $this->assertFalse($storage->isStarted());
+
+        $key = $storage->getMetadataBag()->getStorageKey();
+        $this->assertFalse(isset($_SESSION[$key]));
+        $storage->start();
+        $this->assertTrue(isset($_SESSION[$key]));
+    }
+
+    public function testClear()
+    {
+        $storage = $this->getStorage();
+        session_start();
+        $_SESSION['drak'] = 'loves symfony';
+        $storage->getBag('attributes')->set('symfony', 'greatness');
+        $key = $storage->getBag('attributes')->getStorageKey();
+        $this->assertEquals($_SESSION[$key], array('symfony' => 'greatness'));
+        $this->assertEquals($_SESSION['drak'], 'loves symfony');
+        $storage->clear();
+        $this->assertEquals($_SESSION[$key], array());
+        $this->assertEquals($_SESSION['drak'], 'loves symfony');
+    }
+}

vendor/symfony/http-foundation/Symfony/Component/HttpFoundation/Tests/Session/Storage/Proxy/AbstractProxyTest.php

@@ -0,0 +1,212 @@
+<?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\HttpFoundation\Tests\Session\Storage\Proxy;
+
+use Symfony\Component\HttpFoundation\Session\Storage\Proxy\AbstractProxy;
+
+// Note until PHPUnit_Mock_Objects 1.2 is released you cannot mock abstracts due to
+// https://github.com/sebastianbergmann/phpunit-mock-objects/issues/73
+class ConcreteProxy extends AbstractProxy
+{
+
+}
+
+class ConcreteSessionHandlerInterfaceProxy extends AbstractProxy implements \SessionHandlerInterface
+{
+   public function open($savePath, $sessionName)
+    {
+    }
+
+    public function close()
+    {
+    }
+
+    public function read($id)
+    {
+    }
+
+    public function write($id, $data)
+    {
+    }
+
+    public function destroy($id)
+    {
+    }
+
+    public function gc($maxlifetime)
+    {
+    }
+}
+
+/**
+ * Test class for AbstractProxy.
+ *
+ * @author Drak <drak@zikula.org>
+ */
+class AbstractProxyTest extends \PHPUnit_Framework_TestCase
+{
+    /**
+     * @var AbstractProxy
+     */
+    protected $proxy;
+
+    protected function setUp()
+    {
+        $this->proxy = new ConcreteProxy();
+    }
+
+    protected function tearDown()
+    {
+        $this->proxy = null;
+    }
+
+    public function testGetSaveHandlerName()
+    {
+        $this->assertNull($this->proxy->getSaveHandlerName());
+    }
+
+    public function testIsSessionHandlerInterface()
+    {
+        $this->assertFalse($this->proxy->isSessionHandlerInterface());
+        $sh = new ConcreteSessionHandlerInterfaceProxy();
+        $this->assertTrue($sh->isSessionHandlerInterface());
+    }
+
+    public function testIsWrapper()
+    {
+        $this->assertFalse($this->proxy->isWrapper());
+    }
+
+    public function testIsActivePhp53()
+    {
+        if (version_compare(phpversion(), '5.4.0', '>=')) {
+            $this->markTestSkipped('Test skipped, for PHP 5.3 only.');
+        }
+
+        $this->assertFalse($this->proxy->isActive());
+    }
+
+    /**
+     * @runInSeparateProcess
+     */
+    public function testIsActivePhp54()
+    {
+        if (version_compare(phpversion(), '5.4.0', '<')) {
+            $this->markTestSkipped('Test skipped, for PHP 5.4 only.');
+        }
+
+        $this->assertFalse($this->proxy->isActive());
+        session_start();
+        $this->assertTrue($this->proxy->isActive());
+    }
+
+    public function testSetActivePhp53()
+    {
+        if (version_compare(phpversion(), '5.4.0', '>=')) {
+            $this->markTestSkipped('Test skipped, for PHP 5.3 only.');
+        }
+
+        $this->proxy->setActive(true);
+        $this->assertTrue($this->proxy->isActive());
+        $this->proxy->setActive(false);
+        $this->assertFalse($this->proxy->isActive());
+    }
+
+    /**
+     * @runInSeparateProcess
+     * @expectedException \LogicException
+     */
+    public function testSetActivePhp54()
+    {
+        if (version_compare(phpversion(), '5.4.0', '<')) {
+            $this->markTestSkipped('Test skipped, for PHP 5.4 only.');
+        }
+
+        $this->proxy->setActive(true);
+    }
+
+    /**
+     * @runInSeparateProcess
+     */
+    public function testName()
+    {
+        $this->assertEquals(session_name(), $this->proxy->getName());
+        $this->proxy->setName('foo');
+        $this->assertEquals('foo', $this->proxy->getName());
+        $this->assertEquals(session_name(), $this->proxy->getName());
+    }
+
+    /**
+     * @expectedException \LogicException
+     */
+    public function testNameExceptionPhp53()
+    {
+        if (version_compare(phpversion(), '5.4.0', '>=')) {
+            $this->markTestSkipped('Test skipped, for PHP 5.3 only.');
+        }
+
+        $this->proxy->setActive(true);
+        $this->proxy->setName('foo');
+    }
+
+    /**
+     * @runInSeparateProcess
+     * @expectedException \LogicException
+     */
+    public function testNameExceptionPhp54()
+    {
+        if (version_compare(phpversion(), '5.4.0', '<')) {
+            $this->markTestSkipped('Test skipped, for PHP 5.4 only.');
+        }
+
+        session_start();
+        $this->proxy->setName('foo');
+    }
+
+    /**
+     * @runInSeparateProcess
+     */
+    public function testId()
+    {
+        $this->assertEquals(session_id(), $this->proxy->getId());
+        $this->proxy->setId('foo');
+        $this->assertEquals('foo', $this->proxy->getId());
+        $this->assertEquals(session_id(), $this->proxy->getId());
+    }
+
+    /**
+     * @expectedException \LogicException
+     */
+    public function testIdExceptionPhp53()
+    {
+        if (version_compare(phpversion(), '5.4.0', '>=')) {
+            $this->markTestSkipped('Test skipped, for PHP 5.3 only.');
+        }
+
+        $this->proxy->setActive(true);
+        $this->proxy->setId('foo');
+    }
+
+    /**
+     * @runInSeparateProcess
+     * @expectedException \LogicException
+     */
+    public function testIdExceptionPhp54()
+    {
+        if (version_compare(phpversion(), '5.4.0', '<')) {
+            $this->markTestSkipped('Test skipped, for PHP 5.4 only.');
+        }
+
+        session_start();
+        $this->proxy->setId('foo');
+    }
+}

vendor/symfony/http-foundation/Symfony/Component/HttpFoundation/Tests/Session/Storage/Proxy/NativeProxyTest.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\HttpFoundation\Tests\Session\Storage\Proxy;
+
+use Symfony\Component\HttpFoundation\Session\Storage\Proxy\NativeProxy;
+
+/**
+ * Test class for NativeProxy.
+ *
+ * @author Drak <drak@zikula.org>
+ */
+class NativeProxyTest extends \PHPUnit_Framework_TestCase
+{
+    public function testIsWrapper()
+    {
+        $proxy = new NativeProxy();
+        $this->assertFalse($proxy->isWrapper());
+    }
+
+    public function testGetSaveHandlerName()
+    {
+        $name = ini_get('session.save_handler');
+        $proxy = new NativeProxy();
+        $this->assertEquals($name, $proxy->getSaveHandlerName());
+    }
+}

vendor/symfony/http-foundation/Symfony/Component/HttpFoundation/Tests/Session/Storage/Proxy/SessionHandlerProxyTest.php

@@ -0,0 +1,126 @@
+<?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\HttpFoundation\Tests\Session\Storage\Proxy;
+
+use Symfony\Component\HttpFoundation\Session\Storage\Proxy\SessionHandlerProxy;
+
+/**
+ * Tests for SessionHandlerProxy class.
+ *
+ * @author Drak <drak@zikula.org>
+ *
+ * @runTestsInSeparateProcesses
+ */
+class SessionHandlerProxyTest extends \PHPUnit_Framework_TestCase
+{
+    /**
+     * @var \PHPUnit_Framework_MockObject_Matcher
+     */
+    private $mock;
+
+    /**
+     * @var SessionHandlerProxy
+     */
+    private $proxy;
+
+    protected function setUp()
+    {
+        $this->mock = $this->getMock('SessionHandlerInterface');
+        $this->proxy = new SessionHandlerProxy($this->mock);
+    }
+
+    protected function tearDown()
+    {
+        $this->mock = null;
+        $this->proxy = null;
+    }
+
+    public function testOpen()
+    {
+        $this->mock->expects($this->once())
+            ->method('open')
+            ->will($this->returnValue(true));
+
+        $this->assertFalse($this->proxy->isActive());
+        $this->proxy->open('name', 'id');
+        if (version_compare(phpversion(), '5.4.0', '<')) {
+            $this->assertTrue($this->proxy->isActive());
+        } else {
+            $this->assertFalse($this->proxy->isActive());
+        }
+    }
+
+    public function testOpenFalse()
+    {
+        $this->mock->expects($this->once())
+            ->method('open')
+            ->will($this->returnValue(false));
+
+        $this->assertFalse($this->proxy->isActive());
+        $this->proxy->open('name', 'id');
+        $this->assertFalse($this->proxy->isActive());
+    }
+
+    public function testClose()
+    {
+        $this->mock->expects($this->once())
+            ->method('close')
+            ->will($this->returnValue(true));
+
+        $this->assertFalse($this->proxy->isActive());
+        $this->proxy->close();
+        $this->assertFalse($this->proxy->isActive());
+    }
+
+    public function testCloseFalse()
+    {
+        $this->mock->expects($this->once())
+            ->method('close')
+            ->will($this->returnValue(false));
+
+        $this->assertFalse($this->proxy->isActive());
+        $this->proxy->close();
+        $this->assertFalse($this->proxy->isActive());
+    }
+
+    public function testRead()
+    {
+        $this->mock->expects($this->once())
+            ->method('read');
+
+        $this->proxy->read('id');
+    }
+
+    public function testWrite()
+    {
+        $this->mock->expects($this->once())
+            ->method('write');
+
+        $this->proxy->write('id', 'data');
+    }
+
+    public function testDestroy()
+    {
+        $this->mock->expects($this->once())
+            ->method('destroy');
+
+        $this->proxy->destroy('id');
+    }
+
+    public function testGc()
+    {
+        $this->mock->expects($this->once())
+            ->method('gc');
+
+        $this->proxy->gc(86400);
+    }
+}