diff --git a/core/includes/bootstrap.inc b/core/includes/bootstrap.inc
index 77458a1..8ce92d1 100644
--- a/core/includes/bootstrap.inc
+++ b/core/includes/bootstrap.inc
@@ -1,6 +1,7 @@
 <?php
 
 use Drupal\Component\Utility\NestedArray;
+use Drupal\Core\Cache\CacheEntryInterface;
 use Drupal\Core\Database\Database;
 use Symfony\Component\ClassLoader\UniversalClassLoader;
 use Symfony\Component\ClassLoader\ApcUniversalClassLoader;
@@ -1322,8 +1323,11 @@ function drupal_page_header() {
  * If the request is conditional (using If-Modified-Since and If-None-Match),
  * and the conditions match those currently in the cache, a 304 Not Modified
  * response is sent.
+ *
+ * @param Drupal\Cache\CacheEntryInterface $cache
+ *   Cache entry object.
  */
-function drupal_serve_page_from_cache(stdClass $cache) {
+function drupal_serve_page_from_cache(CacheEntryInterface $cache) {
   $config = config('system.performance');
 
   // Negotiate whether to use compression.
@@ -1337,14 +1341,16 @@ function drupal_serve_page_from_cache(stdClass $cache) {
   // drupal_add_http_headers(). Keys are mixed-case.
   $default_headers = array();
 
-  foreach ($cache->data['headers'] as $name => $value) {
+  $cache_data = $cache->getData();
+
+  foreach ($cache_data['headers'] as $name => $value) {
     // In the case of a 304 response, certain headers must be sent, and the
     // remaining may not (see RFC 2616, section 10.3.5). Do not override
     // headers set in hook_boot().
     $name_lower = strtolower($name);
     if (in_array($name_lower, array('content-location', 'expires', 'cache-control', 'vary')) && !isset($hook_boot_headers[$name_lower])) {
       drupal_add_http_header($name, $value);
-      unset($cache->data['headers'][$name]);
+      unset($cache_data['headers'][$name]);
     }
   }
 
@@ -1357,7 +1363,7 @@ function drupal_serve_page_from_cache(stdClass $cache) {
   $default_headers['Cache-Control'] = 'public, max-age=' . $max_age;
 
   // Entity tag should change if the output changes.
-  $etag = '"' . $cache->created . '-' . intval($return_compressed) . '"';
+  $etag = '"' . $cache->getCreationTimestamp() . '-' . intval($return_compressed) . '"';
   header('Etag: ' . $etag);
 
   // See if the client has provided the required HTTP headers.
@@ -1366,18 +1372,18 @@ function drupal_serve_page_from_cache(stdClass $cache) {
 
   if ($if_modified_since && $if_none_match
       && $if_none_match == $etag // etag must match
-      && $if_modified_since == $cache->created) {  // if-modified-since must match
+      && $if_modified_since == $cache->getCreationTimestamp()) {  // if-modified-since must match
     header($_SERVER['SERVER_PROTOCOL'] . ' 304 Not Modified');
     drupal_send_headers($default_headers);
     return;
   }
 
   // Send the remaining headers.
-  foreach ($cache->data['headers'] as $name => $value) {
+  foreach ($cache_data['headers'] as $name => $value) {
     drupal_add_http_header($name, $value);
   }
 
-  $default_headers['Last-Modified'] = gmdate(DATE_RFC1123, $cache->created);
+  $default_headers['Last-Modified'] = gmdate(DATE_RFC1123, $cache->getCreationTimestamp());
 
   // HTTP/1.0 proxies does not support the Vary header, so prevent any caching
   // by sending an Expires date in the past. HTTP/1.1 clients ignores the
@@ -1409,12 +1415,12 @@ function drupal_serve_page_from_cache(stdClass $cache) {
     else {
       // The client does not support compression, so unzip the data in the
       // cache. Strip the gzip header and run uncompress.
-      $cache->data['body'] = gzinflate(substr(substr($cache->data['body'], 10), 0, -8));
+      $cache_data['body'] = gzinflate(substr(substr($cache_data['body'], 10), 0, -8));
     }
   }
 
   // Print the page.
-  print $cache->data['body'];
+  print $cache_data['body'];
 }
 
 /**
diff --git a/core/includes/common.inc b/core/includes/common.inc
index 6879def..a8f8b12 100644
--- a/core/includes/common.inc
+++ b/core/includes/common.inc
@@ -5,6 +5,7 @@ use Symfony\Component\HttpKernel\Exception\AccessDeniedHttpException;
 use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
 use Drupal\Component\Utility\NestedArray;
 use Drupal\Core\Cache\CacheBackendInterface;
+use Drupal\Core\Cache\MemoryBackend;
 use Drupal\Core\Database\Database;
 use Drupal\Core\Template\Attribute;
 
@@ -4945,7 +4946,7 @@ function _drupal_bootstrap_full($skip = FALSE) {
  *
  * @param $body
  *   The response body.
- * @return
+ * @return Drupal\Cache\CacheEntryInteface
  *   The cached object or NULL if the page cache was not set.
  *
  * @see drupal_page_header()
@@ -4982,9 +4983,14 @@ function drupal_page_set_cache($body) {
       if (config('system.performance')->get('response.gzip') && extension_loaded('zlib')) {
         $cache->data['body'] = gzencode($cache->data['body'], 9, FORCE_GZIP);
       }
-      cache('page')->set($cache->cid, $cache->data, $cache->expire, $cache->tags);
+      return cache('page')->set($cache->cid, $cache->data, $cache->expire, $cache->tags);
+    }
+    else {
+      // @todo This is a workarround that allows to set the CacheEntryInterface
+      // type hint in the drupal_serve_page_from_cache() function.
+      $backend = new MemoryBackend('foo');
+      return $backend->set($cache->cid, $cache->data, $cache->expire, $cache->tags);
     }
-    return $cache;
   }
 }
 
diff --git a/core/lib/Drupal/Core/Cache/CacheBackendInterface.php b/core/lib/Drupal/Core/Cache/CacheBackendInterface.php
index 2140960..7d79c6d 100644
--- a/core/lib/Drupal/Core/Cache/CacheBackendInterface.php
+++ b/core/lib/Drupal/Core/Cache/CacheBackendInterface.php
@@ -71,8 +71,8 @@ interface CacheBackendInterface {
    * @param $cid
    *   The cache ID of the data to retrieve.
    *
-   * @return
-   *   The cache or FALSE on failure.
+   * @return Drupal\Core\Cache\CacheEntryInterface
+   *   The cache entry or FALSE on failure.
    */
   function get($cid);
 
@@ -85,7 +85,8 @@ interface CacheBackendInterface {
    *   removed.
    *
    * @return
-   *   An array of the items successfully returned from cache indexed by cid.
+   *   An array of Drupal\Core\Cache\CacheEntryInterface instances successfully
+   *   returned from cache indexed by cid.
    */
   function getMultiple(&$cids);
 
@@ -110,6 +111,9 @@ interface CacheBackendInterface {
    *   cache invalidation when updated. For example if a cached item represents
    *   a node, both the node ID and the author's user ID might be passed in as
    *   tags. For example array('node' => array(123), 'user' => array(92)).
+   *
+   * @return Drupal\Cache\CacheEntryInterface
+   *   The new entry just created or FALSE in case of any error.
    */
   function set($cid, $data, $expire = CacheBackendInterface::CACHE_PERMANENT, array $tags = array());
 
diff --git a/core/lib/Drupal/Core/Cache/CacheEntry.php b/core/lib/Drupal/Core/Cache/CacheEntry.php
new file mode 100644
index 0000000..a14c2a9 100644
--- /dev/null
+++ b/core/lib/Drupal/Core/Cache/CacheEntry.php
@@ -0,0 +1,120 @@
+<?php
+
+/**
+ * @file
+ * Definition of Drupal\Core\Cache\CacheEntry.
+ */
+
+namespace Drupal\Core\Cache;
+
+/**
+ * Default implementation of cache entry.
+ *
+ * This is used by core database and memory backends and keeps backward
+ * compatibility with stdClass based cache entries.
+ *
+ * @todo Switch all properties to protected or private once all core code is
+ * converted.
+ */
+class CacheEntry implements CacheEntryInterface {
+
+  /**
+   * Raw data.
+   *
+   * @var mixed
+   */
+  public $data;
+
+  /**
+   * Tags.
+   *
+   * @var array
+   */
+  public $tags = array();
+
+  /**
+   * Unix timestamp the was created at.
+   *
+   * @var int
+   */
+  public $created;
+
+  /**
+   * Unix timestamp when the entry will expire.
+   *
+   * @var int
+   */
+  public $expires;
+
+  /**
+   * Entry identifier.
+   *
+   * @var string
+   */
+  public $cid;
+
+  /**
+   * Current object checksum.
+   *
+   * @todo Pure storage, move this out once this question is figured out.
+   *
+   * @param string
+   */
+  public $checksum;
+
+  public function __construct($cid, $data, $created, $expires = CacheBackendInterface::CACHE_PERMANENT, $tags = array(), $checksum = null) {
+    $this->cid = $cid;
+    $this->data = $data;
+    $this->created = $created;
+    $this->expires = $expires;
+    $this->tags = $tags;
+    $this->checksum = $checksum;
+  }
+
+  /**
+   * Implements Drupal\Core\Cache\CacheEntry\CacheEntryInterface::getData().
+   */
+  public function getData() {
+    return $this->data;
+  }
+
+  /**
+   * Implements Drupal\Core\Cache\CacheEntry\CacheEntryInterface::getTags().
+   */
+  public function getTags() {
+    return $this->tags;
+  }
+
+  /**
+   * Implements Drupal\Core\Cache\CacheEntry\CacheEntryInterface::getCreationTimestamp().
+   */
+  public function getCreationTimestamp() {
+    return $this->created;
+  }
+
+  /**
+   * Implements Drupal\Core\Cache\CacheEntry\CacheEntryInterface::getExpirationTimestamp().
+   */
+  public function getExpirationTimestamp() {
+    return $this->expires;
+  }
+
+  /**
+   * Implements Drupal\Core\Cache\CacheEntry\CacheEntryInterface::getIdentifier().
+   */
+  public function getIdentifier() {
+    return $this->cid;
+  }
+
+  /**
+   * Implements Drupal\Core\Cache\CacheEntry\CacheEntryInterface::isExpired().
+   */
+  public function isExpired() {
+    if (CacheBackendInterface::CACHE_PERMANENT === $this->expires) {
+      return false;
+    }
+    else {
+      return time() >= $this->expires;
+    }
+  }
+}
diff --git a/core/lib/Drupal/Core/Cache/CacheEntryInterface.php b/core/lib/Drupal/Core/Cache/CacheEntryInterface.php
new file mode 100644
index 0000000..c47bdc3 100644
--- /dev/null
+++ b/core/lib/Drupal/Core/Cache/CacheEntryInterface.php
@@ -0,0 +1,71 @@
+<?php
+
+/**
+ * @file
+ * Definition of Drupal\Core\Cache\CacheEntry.
+ */
+
+namespace Drupal\Core\Cache;
+
+/**
+ * Cache entry interface.
+ *
+ * This is a read-only value object returned by the cache backend which
+ * specifies what information this API user can use or rely on.
+ */
+interface CacheEntryInterface {
+
+  /**
+   * Get entry unserialized raw data.
+   *
+   * @return mixed
+   */
+  public function getData();
+
+  /**
+   * Get entry tags.
+   *
+   * @return array
+   *   The entry cache tags. First dimension of the array are key value pairs,
+   *   keys being the business name of tag (e.g. "node") and value is an array
+   *   of tag values (e.g. "1" for node 1).
+   */
+  public function getTags();
+
+  /**
+   * Get cache entry creation Unix timestamp.
+   *
+   * @return int
+   *   The Unix timestamp when the entry was created.
+   */
+  public function getCreationTimestamp();
+
+  /**
+   * Get cache entry expiration Unix timestamp.
+   *
+   * @return int
+   *   The Unix timestamp when the entry expires.
+   */
+  public function getExpirationTimestamp();
+
+  /**
+   * Get cache entry identifier.
+   *
+   * @return string
+   *   The cache identifier (cid).
+   */
+  public function getIdentifier();
+
+  /**
+   * Is this entry expired.
+   *
+   * The computed return is based upon the local site time (depending on the
+   * configured locale) which means that the entry may already have expired
+   * or is still valid in the backend while this tells the opposite.
+   *
+   * @return int
+   *   True if the entry has expired.
+   */
+  public function isExpired();
+
+}
diff --git a/core/lib/Drupal/Core/Cache/DatabaseBackend.php b/core/lib/Drupal/Core/Cache/DatabaseBackend.php
index d4de8bf..baca081 100644
--- a/core/lib/Drupal/Core/Cache/DatabaseBackend.php
+++ b/core/lib/Drupal/Core/Cache/DatabaseBackend.php
@@ -8,7 +8,7 @@
 namespace Drupal\Core\Cache;
 
 use Drupal\Core\Database\Database;
-use Exception;
+use Drupal\Core\Database\DatabaseException;
 
 /**
  * Defines a default cache implementation.
@@ -72,11 +72,13 @@ class DatabaseBackend implements CacheBackendInterface {
       $cids = array_diff($cids, array_keys($cache));
       return $cache;
     }
-    catch (Exception $e) {
-      // If the database is never going to be available, cache requests should
-      // return FALSE in order to allow exception handling to occur.
-      return array();
-    }
+    // The database may not be available, cache is a volatile non essential
+    // system, let it fail silentely.
+    catch (DatabaseException $e) {
+    }
+    catch (PDOException $e) {
+    }
+    return array();
   }
 
   /**
@@ -85,34 +87,33 @@ class DatabaseBackend implements CacheBackendInterface {
    * Checks that items are either permanent or did not expire, and unserializes
    * data as appropriate.
    *
-   * @param stdClass $cache
-   *   An item loaded from cache_get() or cache_get_multiple().
+   * @param stdClass $record
+   *   Cache entry database record.
    *
-   * @return mixed
+   * @return Drupal\Core\Cache\CacheEntry
    *   The item with data unserialized as appropriate or FALSE if there is no
    *   valid item to load.
    */
-  protected function prepareItem($cache) {
+  protected function prepareItem($record) {
     global $user;
 
-    if (!isset($cache->data)) {
-      return FALSE;
-    }
+    if ($record->tags) {
+      // Tags must be exploded as an array per definition of the
+      // Drupal\Core\Cache\CacheEntry::getTags() method.
+      $record->tags = explode(' ', $record->tags);
 
-    // The cache data is invalid if any of its tags have been cleared since.
-    if ($cache->tags) {
-      $cache->tags = explode(' ', $cache->tags);
-      if (!$this->validTags($cache->checksum, $cache->tags)) {
+      // The cache data is invalid if any of its tags have been cleared since.
+      if (!$this->validTags($record->checksum, $record->tags)) {
         return FALSE;
       }
     }
 
-    // Unserialize and return the cached data.
-    if ($cache->serialized) {
-      $cache->data = unserialize($cache->data);
+    if ($record->serialized) {
+      $record->data = unserialize($record->data);
     }
 
-    return $cache;
+    // Database record often contains strings instead of integers.
+    return new CacheEntry($record->cid, $record->data, (int)$record->created, (int)$record->expire, $record->tags);
   }
 
   /**
@@ -122,7 +123,8 @@ class DatabaseBackend implements CacheBackendInterface {
     $fields = array(
       'serialized' => 0,
       'created' => REQUEST_TIME,
-      'expire' => $expire,
+      // User code often gives us strings instead of integers.
+      'expire' => (int)$expire,
       'tags' => implode(' ', $this->flattenTags($tags)),
       'checksum' => $this->checksumTags($tags),
     );
@@ -140,10 +142,16 @@ class DatabaseBackend implements CacheBackendInterface {
         ->key(array('cid' => $cid))
         ->fields($fields)
         ->execute();
+
+      return new CacheEntry($cid, $data, $fields['created'], $expire);
     }
-    catch (Exception $e) {
-      // The database may not be available, so we'll ignore cache_set requests.
+    // The database may not be available, cache is a volatile non essential
+    // system, let it fail silentely.
+    catch (DatabaseException $e) {
     }
+    catch (PDOException $e) {
+    }
+    return FALSE;
   }
 
   /**
@@ -287,8 +295,11 @@ class DatabaseBackend implements CacheBackendInterface {
           $checksum += array_sum($db_tags);
         }
       }
-      catch (Exception $e) {
-        // The database may not be available, so we'll ignore cache_set requests.
+      // The database may not be available, cache is a volatile non essential
+      // system, let it fail silentely.
+      catch (DatabaseException $e) {
+      }
+      catch (PDOException $e) {
       }
     }
     return $checksum;
diff --git a/core/lib/Drupal/Core/Cache/MemoryBackend.php b/core/lib/Drupal/Core/Cache/MemoryBackend.php
index 021b818..de63a20 100644
--- a/core/lib/Drupal/Core/Cache/MemoryBackend.php
+++ b/core/lib/Drupal/Core/Cache/MemoryBackend.php
@@ -39,7 +39,13 @@ class MemoryBackend implements CacheBackendInterface {
    */
   public function get($cid) {
     if (isset($this->cache[$cid])) {
-      return $this->prepareItem($this->cache[$cid]);
+      // The cache data is invalid if any of its tags have been cleared since.
+      if ($this->hasInvalidatedTags($this->cache[$cid])) {
+        return FALSE;
+      }
+      else {
+        return $this->cache[$cid];
+      }
     }
     else {
       return FALSE;
@@ -55,10 +61,12 @@ class MemoryBackend implements CacheBackendInterface {
     $items = array_intersect_key($this->cache, array_flip($cids));
 
     foreach ($items as $item) {
-      $item = $this->prepareItem($item);
-      if ($item) {
-        $ret[$item->cid] = $item;
+      // The cache data is invalid if any of its tags have been cleared since.
+      if ($this->hasInvalidatedTags($item)) {
+        continue;
       }
+
+      $ret[$item->cid] = $item;
     }
 
     $cids = array_diff($cids, array_keys($ret));
@@ -67,51 +75,20 @@ class MemoryBackend implements CacheBackendInterface {
   }
 
   /**
-   * Prepares a cached item.
-   *
-   * Checks that items are either permanent or did not expire, and returns data
-   * as appropriate.
-   *
-   * @param stdClass $cache
-   *   An item loaded from cache_get() or cache_get_multiple().
-   *
-   * @return mixed
-   *   The item with data as appropriate or FALSE if there is no
-   *   valid item to load.
-   */
-  protected function prepareItem($cache) {
-    if (!isset($cache->data)) {
-      return FALSE;
-    }
-
-    // The cache data is invalid if any of its tags have been cleared since.
-    if (count($cache->tags) && $this->hasInvalidatedTags($cache)) {
-      return FALSE;
-    }
-
-    return $cache;
-  }
-
-  /**
    * Implements Drupal\Core\Cache\CacheBackendInterface::set().
    */
   public function set($cid, $data, $expire = CacheBackendInterface::CACHE_PERMANENT, array $tags = array()) {
-    $this->cache[$cid] = (object) array(
-      'cid' => $cid,
-      'data' => $data,
-      'expire' => $expire,
-      'tags' => $tags,
-      'checksum' => $this->checksum($this->flattenTags($tags)),
-    );
+    // User code often gives us strings instead of integers.
+    return $this->cache[$cid] = new CacheEntry($cid, $data, REQUEST_TIME, (int)$expire, $tags, $this->checksum($tags));
   }
 
-  /*
+  /**
    * Calculates a checksum so data can be invalidated using tags.
    */
-  function checksum($tags) {
+  protected function checksum(array $tags) {
     $checksum = "";
 
-    foreach($tags as $tag) {
+    foreach($this->flattenTags($tags) as $tag) {
       // Has the tag already been invalidated.
       if (isset($this->invalidatedTags[$tag])) {
         $checksum = $checksum . $tag . ':' . $this->invalidatedTags[$tag];
@@ -167,17 +144,14 @@ class MemoryBackend implements CacheBackendInterface {
    * Checks to see if any of the tags associated with a cache object have been
    * invalidated.
    *
-   * @param object @cache
-   *   An cache object to calculate and compare it's original checksum for.
+   * @param object $tags
+   *   The entry tags array.
    *
    * @return boolean
    *   TRUE if the a tag has been invalidated, FALSE otherwise.
    */
-  protected function hasInvalidatedTags($cache) {
-    if ($cache->checksum != $this->checksum($this->flattenTags($cache->tags))) {
-      return TRUE;
-    }
-    return FALSE;
+  protected function hasInvalidatedTags(CacheEntry $entry) {
+    return $entry->checksum != $this->checksum($entry->getTags());
   }
 
   /**
diff --git a/core/modules/system/lib/Drupal/system/Tests/Cache/GenericCacheBackendUnitTestBase.php b/core/modules/system/lib/Drupal/system/Tests/Cache/GenericCacheBackendUnitTestBase.php
index 5cc023b..03f53a4 100644
--- a/core/modules/system/lib/Drupal/system/Tests/Cache/GenericCacheBackendUnitTestBase.php
+++ b/core/modules/system/lib/Drupal/system/Tests/Cache/GenericCacheBackendUnitTestBase.php
@@ -8,6 +8,7 @@
 namespace Drupal\system\Tests\Cache;
 
 use Drupal\Core\Cache\CacheBackendInterface;
+use Drupal\Core\Cache\CacheEntryInterface;
 use Drupal\simpletest\UnitTestBase;
 
 use stdClass;
@@ -136,16 +137,23 @@ abstract class GenericCacheBackendUnitTestBase extends UnitTestBase {
 
     $data = 7;
     $this->assertIdentical(FALSE, $backend->get('test1'), "Backend does not contain data for cache id test1.");
-    $backend->set('test1', $data);
+    $returnedEntry = $backend->set('test1', $data);
+    $this->assert($returnedEntry instanceof CacheEntryInterface, "Backend set method returned an object for cache id test1.");
     $cached = $backend->get('test1');
-    $this->assert(is_object($cached), "Backend returned an object for cache id test1.");
+
+    // Ensure that returned item has identical properties.
+    $this->assertIdentical($cached->getCreationTimestamp(), $returnedEntry->getCreationTimestamp(), "Get and set returns the same object data.");
+    $this->assertIdentical($cached->getExpirationTimestamp(), $returnedEntry->getExpirationTimestamp(), "Get and set returns the same object data.");
+    $this->assertIdentical($cached->getIdentifier(), $returnedEntry->getIdentifier(), "Get and set returns the same object data.");
+
+    $this->assert($cached instanceof CacheEntryInterface, "Backend returned an object for cache id test1.");
     $this->assertIdentical($data, $cached->data);
 
     $data = array('value' => 3);
     $this->assertIdentical(FALSE, $backend->get('test2'), "Backend does not contain data for cache id test2.");
     $backend->set('test2', $data);
     $cached = $backend->get('test2');
-    $this->assert(is_object($cached), "Backend returned an object for cache id test2.");
+    $this->assert($cached instanceof CacheEntryInterface, "Backend returned an object for cache id test2.");
     $this->assertIdentical($data, $cached->data);
   }
 
@@ -157,17 +165,17 @@ abstract class GenericCacheBackendUnitTestBase extends UnitTestBase {
 
     $this->assertIdentical(FALSE, $backend->get('test1'), "Backend does not contain data for cache id test1.");
     $backend->set('test1', 7);
-    $this->assert(is_object($backend->get('test1')), "Backend returned an object for cache id test1.");
+    $this->assert($backend->get('test1') instanceof CacheEntryInterface, "Backend returned an object for cache id test1.");
 
     $this->assertIdentical(FALSE, $backend->get('test2'), "Backend does not contain data for cache id test2.");
     $backend->set('test2', 3);
-    $this->assert(is_object($backend->get('test2')), "Backend returned an object for cache id %cid.");
+    $this->assert($backend->get('test2') instanceof CacheEntryInterface, "Backend returned an object for cache id %cid.");
 
     $backend->delete('test1');
     $this->assertIdentical(FALSE, $backend->get('test1'), "Backend does not contain data for cache id test1 after deletion.");
 
     $cached = $backend->get('test2');
-    $this->assert(is_object($backend->get('test2')), "Backend still has an object for cache id test2.");
+    $this->assert($backend->get('test2') instanceof CacheEntryInterface, "Backend still has an object for cache id test2.");
 
     $backend->delete('test2');
     $this->assertIdentical(FALSE, $backend->get('test2'), "Backend does not contain data for cache id test2 after deletion.");
@@ -196,7 +204,7 @@ abstract class GenericCacheBackendUnitTestBase extends UnitTestBase {
     // Retrieve and test cache objects.
     foreach ($variables as $cid => $value) {
       $object = $backend->get($cid);
-      $this->assert(is_object($object), sprintf("Backend returned an object for cache id %s.", $cid));
+      $this->assert($object instanceof CacheEntryInterface, sprintf("Backend returned an object for cache id %s.", $cid));
       $this->assertIdentical($value, $object->data, sprintf("Data of cached id %s kept is identical in type and value", $cid));
     }
   }