diff --git a/core/includes/bootstrap.inc b/core/includes/bootstrap.inc
index 906c5cc..3a83b5c 100644
--- a/core/includes/bootstrap.inc
+++ b/core/includes/bootstrap.inc
@@ -3198,6 +3198,12 @@ function drupal_classloader($class_loader = NULL) {
     $loader->registerPrefixes($prefixes);
     $loader->registerNamespaces($namespaces);
 
+    // Fallback to symfony SessionHandlerInterface for PHP < 5.4.0. This
+    // should be removed once we switched to composer autoload.
+    if (!interface_exists('SessionHandlerInterface', FALSE)) {
+      $loader->registerPrefix('SessionHandlerInterface', $namespaces['Symfony\Component\HttpFoundation'] . 'Symfony/Component/HttpFoundation/Resources/stubs');
+    }
+
     // Register the loader with PHP.
     $loader->register();
   }
diff --git a/core/lib/Drupal/Core/CoreBundle.php b/core/lib/Drupal/Core/CoreBundle.php
index 035f282..be998fe 100644
--- a/core/lib/Drupal/Core/CoreBundle.php
+++ b/core/lib/Drupal/Core/CoreBundle.php
@@ -112,6 +112,16 @@ public function build(ContainerBuilder $container) {
       ->addMethodCall('addSubscriber', array(new Reference('http_client_simpletest_subscriber')))
       ->addMethodCall('setUserAgent', array('Drupal (+http://drupal.org/)'));
 
+    // Register the session service.
+    $container->register('session.storage.backend', 'Drupal\Core\Session\Handler\DatabaseSessionHandler');
+    $container->register('session.storage.proxy', 'Drupal\Core\Session\Proxy\CookieOverrideProxy')
+      ->addArgument(new Reference('session.storage.backend'));
+    $container->register('session.storage', 'Drupal\Core\Session\Storage\DrupalSessionStorage')
+
+      ->addArgument(new Reference('session.storage.proxy'));
+    $container->register('session', 'Drupal\Core\Session\Session')
+      ->addArgument(new Reference('session.storage'));
+
     // Register the EntityManager.
     $container->register('plugin.manager.entity', 'Drupal\Core\Entity\EntityManager');
 
@@ -257,6 +267,10 @@ public function build(ContainerBuilder $container) {
       ->addArgument(new Reference('language_manager'))
       ->addTag('event_subscriber');
 
+//    $container->register('session_listener', 'Drupal\Core\EventSubscriber\SessionListener')
+//      ->addArgument(new Reference('service_container'))
+//      ->addTag('event_subscriber');
+
     $container->register('exception_controller', 'Drupal\Core\ExceptionController')
       ->addArgument(new Reference('content_negotiation'))
       ->addMethodCall('setContainer', array(new Reference('service_container')));
diff --git a/core/lib/Drupal/Core/EventSubscriber/SessionListener.php b/core/lib/Drupal/Core/EventSubscriber/SessionListener.php
new file mode 100644
index 0000000..08b2386
--- /dev/null
+++ b/core/lib/Drupal/Core/EventSubscriber/SessionListener.php
@@ -0,0 +1,58 @@
+<?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 Drupal\Core\EventSubscriber;
+
+use Symfony\Component\DependencyInjection\ContainerInterface;
+
+use Symfony\Component\HttpKernel\HttpKernelInterface;
+use Symfony\Component\HttpKernel\Event\GetResponseEvent;
+use Symfony\Component\HttpKernel\KernelEvents;
+use Symfony\Component\EventDispatcher\EventSubscriberInterface;
+
+/**
+ * Sets the session in the request.
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+class SessionListener implements EventSubscriberInterface
+{
+  /**
+   * @var ContainerInterface
+   */
+  private $container;
+
+  public function __construct(ContainerInterface $container)
+  {
+    $this->container = $container;
+  }
+
+  public function onKernelRequest(GetResponseEvent $event)
+  {
+    if (HttpKernelInterface::MASTER_REQUEST !== $event->getRequestType()) {
+      return;
+    }
+
+    $request = $event->getRequest();
+    if (!$this->container->has('session') || $request->hasSession()) {
+      return;
+    }
+
+    $request->setSession($this->container->get('session'));
+  }
+
+  public static function getSubscribedEvents()
+  {
+    return array(
+      KernelEvents::REQUEST => array('onKernelRequest', 128),
+    );
+  }
+}
diff --git a/core/lib/Drupal/Core/Session/Handler/DatabaseSessionHandler.php b/core/lib/Drupal/Core/Session/Handler/DatabaseSessionHandler.php
new file mode 100644
index 0000000..14bed98
--- /dev/null
+++ b/core/lib/Drupal/Core/Session/Handler/DatabaseSessionHandler.php
@@ -0,0 +1,89 @@
+<?php
+
+/**
+ * @file
+ * Defines Drupal\Core\Session\Handler\DatabaseSessionHandler.
+ */
+
+namespace Drupal\Core\Session\Handler;
+
+/**
+ * Drupal database session handler, load and save sessions using the {sessions}
+ * table throughout DBTng.
+ */
+use Drupal\Core\Database\DatabaseExceptionWrapper;
+
+class DatabaseSessionHandler implements \SessionHandlerInterface {
+
+  /**
+   * implements SessionHandlerInterface::open().
+   */
+  public function open($savePath, $sessionName) {
+    return TRUE;
+  }
+
+  /**
+   * implements SessionHandlerInterface::close().
+   */
+  public function close() {
+    return TRUE;
+  }
+
+  /**
+   * implements SessionHandlerInterface::destroy().
+   */
+  public function destroy($sessionId) {
+    try {
+      db_delete('sessions')->condition('sid', $sessionId)->execute();
+    }
+    catch (DatabaseExceptionWrapper $e) {
+      throw new \RuntimeException(sprintf('DatabaseException was thrown when trying to manipulate session data: %s', $e->getMessage()), 0, $e);
+    }
+
+    return TRUE;
+  }
+
+  /**
+   * implements SessionHandlerInterface::gc().
+   */
+  public function gc($lifetime) {
+    try {
+      db_delete('sessions')->condition('timestamp', time() - $lifetime, '<')->execute();
+    }
+    catch (DatabaseExceptionWrapper $e) {
+      throw new \RuntimeException(sprintf('DatabaseException was thrown when trying to manipulate session data: %s', $e->getMessage()), 0, $e);
+    }
+
+    return TRUE;
+  }
+
+  /**
+   * implements SessionHandlerInterface::read().
+   */
+  public function read($sessionId) {
+    $data = db_query("SELECT s.* FROM {sessions} s WHERE s.sid = :sid", array(':sid' => $sessionId))->fetchObject();
+    return !empty($data) ? $data->session : '';
+  }
+
+  /**
+   * implements SessionHandlerInterface::write().
+   */
+  public function write($sessionId, $data) {
+    try {
+      db_merge('sessions')
+        ->key(array(
+          'sid' => $sessionId,
+        ))
+        ->fields(array(
+          'session' => $data,
+          'timestamp' => time(),
+        ))
+        ->execute();
+    }
+    catch (DatabaseExceptionWrapper $e) {
+      throw new \RuntimeException(sprintf('DatabaseException was thrown when trying to write session data: %s', $e->getMessage()), 0, $e);
+    }
+
+    return TRUE;
+  }
+}
diff --git a/core/lib/Drupal/Core/Session/Proxy/CookieOverrideProxy.php b/core/lib/Drupal/Core/Session/Proxy/CookieOverrideProxy.php
new file mode 100644
index 0000000..28d7618
--- /dev/null
+++ b/core/lib/Drupal/Core/Session/Proxy/CookieOverrideProxy.php
@@ -0,0 +1,160 @@
+<?php
+
+/**
+ * @file
+ * Defines Drupal\Core\Session\Proxy\CookieOverrideProxy.
+ */
+
+namespace Drupal\Core\Session\Proxy;
+
+use Symfony\Component\HttpFoundation\Session\Storage\SessionStorageInterface;
+use Symfony\Component\HttpFoundation\Session\Storage\Proxy\SessionHandlerProxy;
+
+// @todo Replace this at the correct place.
+// If a session cookie exists, initialize the session. Otherwise the
+// session is only started on demand in drupal_session_commit(), making
+// anonymous users not use a session cookie unless something is stored in
+// $_SESSION. This allows HTTP proxies to cache anonymous page views.
+
+/**
+ * Custom SessionHandlerProxy implementation that allows us to handle the HTTP
+ * and HTTPS session cookies manually, and enforce strong security measures for
+ * the session handling.
+ */
+class CookieOverrideProxy extends SessionHandlerProxy {
+
+  /**
+   * Default Constructor.
+   *
+   * @param \SessionHandlerInterface $handler
+   */
+  public function __construct(SessionStorageInterface $handler) {
+    parent::__construct($handler);
+
+    if ($id = $this->getIdFromCookie()) {
+      $this->setId($id);
+    }
+    else {
+      // Set a session identifier for this request. This is necessary because we
+      // lazily start sessions at the end of this request, and some processes
+      // (like drupal_get_token()) needs to know the future session ID in
+      // advance.
+      $GLOBALS['lazy_session'] = TRUE;
+
+      // Less random sessions (which are much faster to generate) are used for
+      // anonymous users than are generated in drupal_session_regenerate() when
+      // a user becomes authenticated.
+      $this->regenerateId();
+
+      /*
+       * @todo Restore HTTPS cookie
+      if ($is_https && variable_get('https', FALSE)) {
+        $insecure_session_name = substr(session_name(), 1);
+        $session_id = drupal_hash_base64(uniqid(mt_rand(), TRUE));
+        $_COOKIE[$insecure_session_name] = $session_id;
+      }
+       */
+    }
+  }
+
+  /**
+   * overrides \Symfony\Component\HttpFoundation\Session\Storage\Proxy\AbstractProxy::isSessionHandlerInterface().
+   */
+  public function isSessionHandlerInterface()
+  {
+      return TRUE;
+  }
+
+  /**
+   * Get current session identifier from cookie, if any.
+   *
+   * @return string
+   *   Session identifier or NULL if none found.
+   */
+  protected function getIdFromCookie() {
+    $name = $this->getName();
+    if (!empty($_COOKIE[$name])) {
+      // @todo Restore HTTPS cookie
+      //|| ($GLOBALS['is_https'] && variable_get('https', FALSE) && !empty($_COOKIE[substr(session_name(), 1)]))) {
+      return $_COOKIE[$name];
+    }
+  }
+
+  protected function destroyCookies() {
+    if (headers_sent()) {
+      //throw new \RuntimeException('Failed to destroy cookies because headers have already been sent.');
+    }
+
+    $params = session_get_cookie_params();
+    // @todo Restore HTTPS cookie
+    setcookie($this->getName(), '', time() - 3600, $params['path'], $params['domain'], $params['secure'], $params['httponly']);
+  }
+
+  protected function sendCookies($id) {
+    if (headers_sent()) {
+      //throw new \RuntimeException('Failed to set cookies because headers have already been sent.');
+    }
+
+    $params = session_get_cookie_params();
+    $expire = $params['lifetime'] ? time() + $params['lifetime'] : 0;
+    // @todo Restore HTTPS cookie
+    setcookie($this->getName(), $id, $expire, $params['path'], $params['domain'], $params['secure'], $params['httponly']);
+  }
+
+  public function write($id, $data) {
+
+    if (!$this->isActive()) {
+      return FALSE;
+    }
+
+    // Cookie sending must be when we are sure we need to keep the session, this
+    // ensure the lazy session init. Lazy session init is abusive talking we are
+    // not lazy initializing the session, but lazy sending the session cookie
+    // instead. Each anonymous user will intrinsically have a session tied, which
+    // allows to generate tokens for forms and such, but if the session ends up
+    // empty, the cookies will not be sent and the session will not be saved on
+    // disk.
+    $this->sendCookies($id);
+
+    return (bool) $this->handler->write($id, $data);
+  }
+
+  public function destroy($id) {
+    $this->destroyCookies($id);
+
+    return (bool) $this->handler->destroy($id);
+  }
+
+  /**
+   * Generate new session identifier.
+   *
+   * The the session_regenerate_id() is hardcoded into Symfony's
+   * NativeSessionStorage implementation while all other session_*() functions
+   * are used as setters only in the AbstractProxy implementation. This feels
+   * wrong and we need to override it without doing invasive changes.
+   *
+   * @todo See if this implementation can be made apart of Symfony
+   *
+   * @see Drupal\Core\Session\Proxy\Storage\DrupalSessionStorage::regenerate()
+   *
+   * @param bool $destroy
+   *   (optional) If set to TRUE, destroy the old session.
+   *
+   * @return string
+   *   New session identifier.
+   */
+  public function regenerateId($destroy = FALSE) {
+    $id = drupal_hash_base64(uniqid(mt_rand(), TRUE) . drupal_random_bytes(55));
+
+    // Do not call parent::setId() here, else it will throw exceptions because
+    // during session identifier regeneration, this component is considered as
+    // active.
+    session_id($id);
+
+    if ($destroy) {
+      $this->destroyCookies();
+    }
+
+    return TRUE;
+  }
+}
diff --git a/core/lib/Drupal/Core/Session/Session.php b/core/lib/Drupal/Core/Session/Session.php
new file mode 100644
index 0000000..87c74c9
--- /dev/null
+++ b/core/lib/Drupal/Core/Session/Session.php
@@ -0,0 +1,118 @@
+<?php
+
+/**
+ * @file
+ * Defines Drupal\Core\Session\Session.
+ */
+
+namespace Drupal\Core\Session;
+
+use Symfony\Component\HttpFoundation\Session\Session as BaseSession;
+use Symfony\Component\HttpFoundation\Session\Storage\NativeSessionStorage;
+
+/**
+ * Overrides Symfony's Session object in order to implement Drupal specific
+ * session features, such as lazy cookie sending and explicit session save
+ * disabling.
+ */
+class Session extends BaseSession {
+
+  /**
+   * Keep track of the save enabled state.
+   *
+   * @var bool
+   */
+  protected $saveEnabled = TRUE;
+
+  /**
+   * Keep track fo the save handler state when disabling session write.
+   *
+   * @var bool
+   */
+  protected $lastSaveHandlerState;
+
+  /**
+   * Enable session save, at commit time session will be saved by the session
+   * handler and session token will be sent.
+   */
+  public function enableSave() {
+    $this->saveEnabled = TRUE;
+
+    if (null !== $this->lastSaveHandlerState && $this->lastSaveHandlerState) {
+      $this->storage->getSaveHandler()->setActive($this->lastSaveHandlerState);
+    }
+  }
+
+  /**
+   * Disable session save, at commit time session save will be skipped and
+   * session token will not be sent to client.
+   *
+   * This function allows the caller to temporarily disable writing of
+   * session data, should the request end while performing potentially
+   * dangerous operations, such as manipulating the global $user object.
+   * See http://drupal.org/node/218104 for usage.
+   */
+  public function disableSave() {
+    $this->saveEnabled = FALSE;
+
+    // As a side effect, the save handler in some occasions can be reached by
+    // either PHP native session handling either Symfony session handling. By
+    // disabling it manually we ensure it won't save anything behind our back.
+    $saveHandler = $this->storage->getSaveHandler();
+
+    if ($this->lastSaveHandlerState = $saveHandler->isActive()) {
+       $saveHandler->setActive(FALSE);
+    }
+  }
+
+  /**sy
+   * Is the session save enabled.
+   *
+   * @return bool
+   */
+  public function isSaveEnabled() {
+    return $this->saveEnabled;
+  }
+
+  /**
+   * Does this session is empty.
+   *
+   * Note:
+   *   Bags can not be directly accessed via protected attributes, and they
+   *   don't have either a count() or isEmpty() method.
+   *
+   * @return bool
+   *   TRUE if session is empty.
+   */
+  public function isEmpty() {
+    debug($this->getFlashBag()->all());
+    debug($this->all());
+    return !count($this->getFlashBag()->all()) && !count($this->all());
+  }
+
+  public function save() {
+    // Session saving is checked upper, but avoid accidental save() trigger in
+    // case save is disabled.
+    // @todo May be should throw a \LogicException here?
+    if (!$this->isSaveEnabled()) {
+      return;
+    }
+
+    parent::save();
+  }
+
+  /**
+   * Overrides Symfony\Component\HttpFoundation\Session\Session::migrate().
+   *
+   * Prevent regenerate if saving is disabled.
+   */
+  public function migrate($destroy = FALSE, $lifetime = NULL) {
+
+    if (!$this->isSaveEnabled()) {
+      return;
+    }
+
+    return $this->storage->regenerate($destroy, $lifetime);
+  }
+
+}
diff --git a/core/lib/Drupal/Core/Session/StaticSessionFactory.php b/core/lib/Drupal/Core/Session/StaticSessionFactory.php
new file mode 100644
index 0000000..688dfdb
--- /dev/null
+++ b/core/lib/Drupal/Core/Session/StaticSessionFactory.php
@@ -0,0 +1,44 @@
+<?php
+
+/**
+ * @file
+ * Defines Drupal\Core\Session\StaticSessionFactory.
+ */
+
+namespace Drupal\Core\Session;
+
+use Drupal\Core\Session\Handler\DatabaseSessionHandler;
+use Drupal\Core\Session\Proxy\CookieOverrideProxy;
+use Drupal\Core\Session\Storage\DrupalSessionStorage;
+
+/**
+ * Static session factory that will allow us to use the session as a synthetic
+ * service into the DIC and avoid dual instantiation due to bootstrap container
+ * definition.
+ *
+ */
+class StaticSessionFactory {
+
+  /**
+   * @var \Drupal\Core\Session\Session
+   */
+  static protected $session;
+
+  /**
+   * Get global session service.
+   *
+   * @return \Drupal\Core\Session\Session
+   *   Session service.
+   */
+  static public function getSession() {
+    if (null === self::$session) {
+
+      $handler = new CookieOverrideProxy(new DatabaseSessionHandler());
+      $storage = new DrupalSessionStorage(array(), $handler);
+
+      self::$session = new Session($storage);
+    }
+
+    return self::$session;
+  }
+}
diff --git a/core/lib/Drupal/Core/Session/Storage/DrupalSessionStorage.php b/core/lib/Drupal/Core/Session/Storage/DrupalSessionStorage.php
new file mode 100644
index 0000000..4c5e837
--- /dev/null
+++ b/core/lib/Drupal/Core/Session/Storage/DrupalSessionStorage.php
@@ -0,0 +1,63 @@
+<?php
+
+/**
+ * @file
+ * Defines Drupal\Core\Session\Storage\DrupalSessionStorage.
+ */
+
+namespace Drupal\Core\Session\Storage;
+
+use Drupal\Core\Session\Proxy\CookieOverrideProxy;
+
+use Symfony\Component\HttpFoundation\Session\Storage\NativeSessionStorage;
+
+/**
+ * Default session storage.
+ *
+ * This is a proxy class between the $_SESSION super global and the Session
+ * object bags.
+ */
+class DrupalSessionStorage extends NativeSessionStorage {
+
+  public function __construct($handler = null, array $options = array(), MetadataBag $metaBag = null) {
+    // In the parent class, the session_register_shutdown() is called. Because
+    // PHP native session will run the close handler in the PHP shutdown hooks,
+    // most Drupal systems our handler relies on will be destructed before this
+    // call. This is the main reason why we need to extend Symfony's component
+    // in order to avoid the native shutdown to run.
+    $this->setMetadataBag($metaBag);
+    $this->setOptions($options);
+    $this->setSaveHandler($handler);
+  }
+
+  public function clear() {
+    parent::clear();
+
+    // Clearing the session is a signal sent when session is invalidated, this
+    // means we can mark the session handler as inactive so it won't attempt
+    // any empty session write. Our session handler will send session cookie at
+    // write time. This allows lazy cookie sending to the client.
+    $this->saveHandler->setActive(FALSE);
+  }
+
+  public function regenerate($destroy = FALSE, $lifetime = NULL) {
+
+    if (null !== $lifetime) {
+      ini_set('session.cookie_lifetime', $lifetime);
+    }
+
+    if ($destroy) {
+      $this->metadataBag->stampNew();
+    }
+
+    // If the current save handler is our own we must rely its own session
+    // identifier generation method. I hope Symfony will move this call to
+    // this object so we can get rid of this method override.
+    if ($this->saveHandler instanceof CookieOverrideProxy) {
+      return $this->saveHandler->regenerateId($destroy);
+    }
+    else {
+      return session_regenerate_id($destroy);
+    }
+  }
+}
diff --git a/core/modules/system/lib/Drupal/system/Tests/Session/SessionSymfony2Test.php b/core/modules/system/lib/Drupal/system/Tests/Session/SessionSymfony2Test.php
new file mode 100644
index 0000000..712b36a
--- /dev/null
+++ b/core/modules/system/lib/Drupal/system/Tests/Session/SessionSymfony2Test.php
@@ -0,0 +1,141 @@
+<?php
+
+/**
+ * @file
+ * Definition of Drupal\system\Tests\Session\SessionSymfony2Test.
+ */
+
+namespace Drupal\system\Tests\Session;
+
+use Drupal\Core\Session\Proxy\CookieOverrideProxy;
+use Drupal\Core\Session\Session;
+use Drupal\Core\Session\Storage\DrupalSessionStorage;
+use Drupal\simpletest\DrupalUnitTestBase;
+use Drupal\simpletest\UnitTestBase;
+Use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpFoundation\Session\Storage\MockArraySessionStorage;
+use Symfony\Component\HttpFoundation\Session\Storage\MockFileSessionStorage;
+
+class SessionSymfony2Test extends UnitTestBase {
+  public $mockStorage;
+
+  /**
+   * Modules to enable.
+   *
+   * @var array
+   */
+  public static $modules = array('system');
+
+  public static function getInfo() {
+    return array(
+      'name' => 'Symfony2 Session tests',
+      'description' => 'Test our use of Symfony2 Sesion objects',
+      'group' => 'Session'
+    );
+  }
+
+  /**
+   * Stores the session.
+   *
+   * @var \Drupal\Core\Session\Session
+   */
+  protected $session;
+
+  protected function setUp() {
+    parent::setUp();
+
+    $this->mockStorage = new MockArraySessionStorage();
+    $this->session = new Session(new DrupalSessionStorage($this->mockStorage));
+  }
+
+
+  /**
+   * Tests the new session API and handling
+   */
+  function _testSession() {
+    $random_value = $this->randomName();
+    $this->session->set('key', $random_value);
+    $this->assertEqual($this->session->get('key'), $random_value);
+
+    // Disable saving, and ensure that the session is not stored by the storage
+    // controller.
+    $this->session->disableSave();
+    $this->assertFalse($this->session->isSaveEnabled());
+    $random_value = $this->randomName();
+    $random_key = $this->randomName();
+    $this->session->set($random_key, $random_value);
+
+    // Clear the temporary values (the flashbag).
+    $this->session->clear();
+    $this->assertFalse($this->session->get($random_key));
+
+    $drupal_session_storage = new DrupalSessionStorage($this->mockStorage);
+
+    $this->session = new Session($drupal_session_storage);
+    $this->assertFalse($this->session->get($random_key));
+
+    // Now enable saving and make sure the new value could be loaded from the
+    // Storage
+    $this->session->enableSave();
+    $this->assertTrue($this->session->isSaveEnabled());
+    $random_value = $this->randomName();
+    $random_key = $this->randomName();
+    $this->session->set($random_key, $random_value);
+    $this->session = new Session($drupal_session_storage);
+    $this->assertTrue($this->session->get($random_key));
+
+    // Clear the session, and reinitialize the session with the storage.
+    $this->session->clear();
+    $this->session = new Session($drupal_session_storage);
+    $this->assertTrue($this->session->get($random_key));
+
+//    $old_session_id = $this->session->getId();
+//    $this->session->migrate();
+//    $this->assertNotEqual($old_session_id, $this->session->getId());
+
+    // Can I log in?
+
+    // Can I log out?
+
+    // Can I save data in a session?
+
+  }
+
+  protected function testSesssionIsEmpty() {
+    $mock_storage = new MockArraySessionStorage();
+    $drupal_session_storage = new DrupalSessionStorage($mock_storage);
+
+    $this->session = new Session($drupal_session_storage);
+    $this->assertTrue($this->session->isEmpty());
+
+    $this->session = new Session($drupal_session_storage);
+    $this->assertTrue($this->session->isEmpty());
+
+    $this->session->disableSave();
+    $this->session->set('key', $this->randomName());
+    $this->session->save();
+
+    $this->session = new Session($drupal_session_storage);
+    $this->assertTrue($this->session->isEmpty());
+
+    $this->session->enableSave();
+    $this->session->set('key', $this->randomName());
+    $this->session->save();
+
+    $this->session = new Session($drupal_session_storage);
+    $this->assertFalse($this->session->isEmpty());
+  }
+
+  protected function testDrupalSessionStorage() {
+
+  }
+
+  protected function testCookieProxy() {
+
+  }
+
+  protected function testSessionDatabaseStorage() {
+
+  }
+
+}
diff --git a/core/modules/system/lib/Drupal/system/Tests/Session/SessionTest.php b/core/modules/system/lib/Drupal/system/Tests/Session/SessionTest.php
index dadd2f2..399e253 100644
--- a/core/modules/system/lib/Drupal/system/Tests/Session/SessionTest.php
+++ b/core/modules/system/lib/Drupal/system/Tests/Session/SessionTest.php
@@ -27,6 +27,13 @@ public static function getInfo() {
   }
 
   /**
+   * Test that a DIC based session can be created.
+   */
+  function testDICSession() {
+    $session = drupal_container()->get('session');
+  }
+
+  /**
    * Tests for drupal_save_session() and drupal_session_regenerate().
    */
   function testSessionSaveRegenerate() {