moneta 0.6.0 → 0.7.0

data/spec/moneta/transformer_msgpack_spec.rb

@@ -0,0 +1,30 @@
+# Generated by generate.rb
+require 'helper'
+
+describe_moneta "transformer_msgpack" do
+  def new_store
+    Moneta.build do
+      use :Transformer, :key => :msgpack, :value => :msgpack
+      adapter :Memory
+    end
+  end
+
+  def load_value(value)
+    ::MessagePack.unpack(value)
+  end
+
+  include_context 'setup_store'
+  it_should_behave_like 'null_hashkey_hashvalue'
+  it_should_behave_like 'null_hashkey_stringvalue'
+  it_should_behave_like 'null_stringkey_hashvalue'
+  it_should_behave_like 'null_stringkey_stringvalue'
+  it_should_behave_like 'store_hashkey_hashvalue'
+  it_should_behave_like 'store_hashkey_stringvalue'
+  it_should_behave_like 'store_stringkey_hashvalue'
+  it_should_behave_like 'store_stringkey_stringvalue'
+  it_should_behave_like 'returndifferent_hashkey_hashvalue'
+  it_should_behave_like 'returndifferent_hashkey_stringvalue'
+  it_should_behave_like 'returndifferent_stringkey_hashvalue'
+  it_should_behave_like 'returndifferent_stringkey_stringvalue'
+  it_should_behave_like 'transform_value'
+end

data/spec/moneta/transformer_ox_spec.rb

@@ -0,0 +1,51 @@
+# Generated by generate.rb
+require 'helper'
+
+describe_moneta "transformer_ox" do
+  def new_store
+    Moneta.build do
+      use :Transformer, :key => :ox, :value => :ox
+      adapter :Memory
+    end
+  end
+
+  def load_value(value)
+    ::Ox.parse_obj(value)
+  end
+
+  include_context 'setup_store'
+  it_should_behave_like 'null_objectkey_objectvalue'
+  it_should_behave_like 'null_objectkey_stringvalue'
+  it_should_behave_like 'null_objectkey_hashvalue'
+  it_should_behave_like 'null_objectkey_booleanvalue'
+  it_should_behave_like 'null_stringkey_objectvalue'
+  it_should_behave_like 'null_stringkey_stringvalue'
+  it_should_behave_like 'null_stringkey_hashvalue'
+  it_should_behave_like 'null_stringkey_booleanvalue'
+  it_should_behave_like 'null_hashkey_objectvalue'
+  it_should_behave_like 'null_hashkey_stringvalue'
+  it_should_behave_like 'null_hashkey_hashvalue'
+  it_should_behave_like 'null_hashkey_booleanvalue'
+  it_should_behave_like 'store_objectkey_objectvalue'
+  it_should_behave_like 'store_objectkey_stringvalue'
+  it_should_behave_like 'store_objectkey_hashvalue'
+  it_should_behave_like 'store_objectkey_booleanvalue'
+  it_should_behave_like 'store_stringkey_objectvalue'
+  it_should_behave_like 'store_stringkey_stringvalue'
+  it_should_behave_like 'store_stringkey_hashvalue'
+  it_should_behave_like 'store_stringkey_booleanvalue'
+  it_should_behave_like 'store_hashkey_objectvalue'
+  it_should_behave_like 'store_hashkey_stringvalue'
+  it_should_behave_like 'store_hashkey_hashvalue'
+  it_should_behave_like 'store_hashkey_booleanvalue'
+  it_should_behave_like 'returndifferent_objectkey_objectvalue'
+  it_should_behave_like 'returndifferent_objectkey_stringvalue'
+  it_should_behave_like 'returndifferent_objectkey_hashvalue'
+  it_should_behave_like 'returndifferent_stringkey_objectvalue'
+  it_should_behave_like 'returndifferent_stringkey_stringvalue'
+  it_should_behave_like 'returndifferent_stringkey_hashvalue'
+  it_should_behave_like 'returndifferent_hashkey_objectvalue'
+  it_should_behave_like 'returndifferent_hashkey_stringvalue'
+  it_should_behave_like 'returndifferent_hashkey_hashvalue'
+  it_should_behave_like 'transform_value'
+end

data/spec/moneta/transformer_quicklz_spec.rb

@@ -0,0 +1,27 @@
+# Generated by generate.rb
+require 'helper'
+
+describe_moneta "transformer_quicklz" do
+  def new_store
+    Moneta.build do
+      use :Transformer, :value => :quicklz
+      adapter :Memory
+    end
+  end
+
+  def load_value(value)
+    ::QuickLZ.decompress(value)
+  end
+
+  include_context 'setup_store'
+  it_should_behave_like 'null_objectkey_stringvalue'
+  it_should_behave_like 'null_stringkey_stringvalue'
+  it_should_behave_like 'null_hashkey_stringvalue'
+  it_should_behave_like 'store_objectkey_stringvalue'
+  it_should_behave_like 'store_stringkey_stringvalue'
+  it_should_behave_like 'store_hashkey_stringvalue'
+  it_should_behave_like 'returndifferent_objectkey_stringvalue'
+  it_should_behave_like 'returndifferent_stringkey_stringvalue'
+  it_should_behave_like 'returndifferent_hashkey_stringvalue'
+  it_should_behave_like 'transform_value'
+end

data/spec/moneta/transformer_snappy_spec.rb

@@ -0,0 +1,27 @@
+# Generated by generate.rb
+require 'helper'
+
+describe_moneta "transformer_snappy" do
+  def new_store
+    Moneta.build do
+      use :Transformer, :value => :snappy
+      adapter :Memory
+    end
+  end
+
+  def load_value(value)
+    ::Snappy.inflate(value)
+  end
+
+  include_context 'setup_store'
+  it_should_behave_like 'null_objectkey_stringvalue'
+  it_should_behave_like 'null_stringkey_stringvalue'
+  it_should_behave_like 'null_hashkey_stringvalue'
+  it_should_behave_like 'store_objectkey_stringvalue'
+  it_should_behave_like 'store_stringkey_stringvalue'
+  it_should_behave_like 'store_hashkey_stringvalue'
+  it_should_behave_like 'returndifferent_objectkey_stringvalue'
+  it_should_behave_like 'returndifferent_stringkey_stringvalue'
+  it_should_behave_like 'returndifferent_hashkey_stringvalue'
+  it_should_behave_like 'transform_value'
+end

data/spec/moneta/transformer_tnet_spec.rb

@@ -0,0 +1,30 @@
+# Generated by generate.rb
+require 'helper'
+
+describe_moneta "transformer_tnet" do
+  def new_store
+    Moneta.build do
+     use :Transformer, :key => :tnet, :value => :tnet
+     adapter :Memory
+    end
+  end
+
+  def load_value(value)
+    ::TNetstring.parse(value).first
+  end
+
+  include_context 'setup_store'
+  it_should_behave_like 'null_hashkey_hashvalue'
+  it_should_behave_like 'null_hashkey_stringvalue'
+  it_should_behave_like 'null_stringkey_hashvalue'
+  it_should_behave_like 'null_stringkey_stringvalue'
+  it_should_behave_like 'store_hashkey_hashvalue'
+  it_should_behave_like 'store_hashkey_stringvalue'
+  it_should_behave_like 'store_stringkey_hashvalue'
+  it_should_behave_like 'store_stringkey_stringvalue'
+  it_should_behave_like 'returndifferent_hashkey_hashvalue'
+  it_should_behave_like 'returndifferent_hashkey_stringvalue'
+  it_should_behave_like 'returndifferent_stringkey_hashvalue'
+  it_should_behave_like 'returndifferent_stringkey_stringvalue'
+  it_should_behave_like 'transform_value'
+end

data/spec/moneta/transformer_yaml_spec.rb

@@ -0,0 +1,51 @@
+# Generated by generate.rb
+require 'helper'
+
+describe_moneta "transformer_yaml" do
+  def new_store
+    Moneta.build do
+      use :Transformer, :key => :yaml, :value => :yaml
+      adapter :Memory
+    end
+  end
+
+  def load_value(value)
+    ::YAML.load(value)
+  end
+
+  include_context 'setup_store'
+  it_should_behave_like 'null_objectkey_objectvalue'
+  it_should_behave_like 'null_objectkey_stringvalue'
+  it_should_behave_like 'null_objectkey_hashvalue'
+  it_should_behave_like 'null_objectkey_booleanvalue'
+  it_should_behave_like 'null_stringkey_objectvalue'
+  it_should_behave_like 'null_stringkey_stringvalue'
+  it_should_behave_like 'null_stringkey_hashvalue'
+  it_should_behave_like 'null_stringkey_booleanvalue'
+  it_should_behave_like 'null_hashkey_objectvalue'
+  it_should_behave_like 'null_hashkey_stringvalue'
+  it_should_behave_like 'null_hashkey_hashvalue'
+  it_should_behave_like 'null_hashkey_booleanvalue'
+  it_should_behave_like 'store_objectkey_objectvalue'
+  it_should_behave_like 'store_objectkey_stringvalue'
+  it_should_behave_like 'store_objectkey_hashvalue'
+  it_should_behave_like 'store_objectkey_booleanvalue'
+  it_should_behave_like 'store_stringkey_objectvalue'
+  it_should_behave_like 'store_stringkey_stringvalue'
+  it_should_behave_like 'store_stringkey_hashvalue'
+  it_should_behave_like 'store_stringkey_booleanvalue'
+  it_should_behave_like 'store_hashkey_objectvalue'
+  it_should_behave_like 'store_hashkey_stringvalue'
+  it_should_behave_like 'store_hashkey_hashvalue'
+  it_should_behave_like 'store_hashkey_booleanvalue'
+  it_should_behave_like 'returndifferent_objectkey_objectvalue'
+  it_should_behave_like 'returndifferent_objectkey_stringvalue'
+  it_should_behave_like 'returndifferent_objectkey_hashvalue'
+  it_should_behave_like 'returndifferent_stringkey_objectvalue'
+  it_should_behave_like 'returndifferent_stringkey_stringvalue'
+  it_should_behave_like 'returndifferent_stringkey_hashvalue'
+  it_should_behave_like 'returndifferent_hashkey_objectvalue'
+  it_should_behave_like 'returndifferent_hashkey_stringvalue'
+  it_should_behave_like 'returndifferent_hashkey_hashvalue'
+  it_should_behave_like 'transform_value'
+end

data/spec/moneta/transformer_zlib_spec.rb

@@ -0,0 +1,27 @@
+# Generated by generate.rb
+require 'helper'
+
+describe_moneta "transformer_zlib" do
+  def new_store
+    Moneta.build do
+      use :Transformer, :value => :zlib
+      adapter :Memory
+    end
+  end
+
+  def load_value(value)
+    ::Zlib::Inflate.inflate(value)
+  end
+
+  include_context 'setup_store'
+  it_should_behave_like 'null_objectkey_stringvalue'
+  it_should_behave_like 'null_stringkey_stringvalue'
+  it_should_behave_like 'null_hashkey_stringvalue'
+  it_should_behave_like 'store_objectkey_stringvalue'
+  it_should_behave_like 'store_stringkey_stringvalue'
+  it_should_behave_like 'store_hashkey_stringvalue'
+  it_should_behave_like 'returndifferent_objectkey_stringvalue'
+  it_should_behave_like 'returndifferent_stringkey_stringvalue'
+  it_should_behave_like 'returndifferent_hashkey_stringvalue'
+  it_should_behave_like 'transform_value'
+end

data/spec/monetaspecs.rb

@@ -0,0 +1,2663 @@
+# Generated by generate.rb
+
+#################### null_stringkey_booleanvalue ####################
+
+shared_examples_for 'null_stringkey_booleanvalue' do
+  it "reads from keys that are Strings like a Hash" do
+    store["strkey1"].should == nil
+    store.load("strkey1").should == nil
+  end
+
+  it "guarantees that the same Boolean value is returned when setting a String key" do
+    value = true
+    (store["strkey1"] = value).should equal(value)
+  end
+
+  it "returns false from key? if a String key is not available" do
+    store.key?("strkey1").should == false
+  end
+
+  it "returns nil from delete if an element for a String key does not exist" do
+    store.delete("strkey1").should == nil
+  end
+
+  it "removes all String keys from the store with clear" do
+    store["strkey1"] = true
+    store["strkey2"] = false
+    store.clear.should equal(store)
+    store.key?("strkey1").should_not ==  true
+    store.key?("strkey2").should_not == true
+  end
+
+  it "fetches a String key with a default value with fetch, if the key is not available" do
+    store.fetch("strkey1", true).should == true
+  end
+
+  it "fetches a String key with a block with fetch, if the key is not available" do
+    key = "strkey1"
+    value = true
+    store.fetch(key) do |k|
+      k.should equal(key)
+      value
+    end.should equal(value)
+  end
+
+  it 'should accept options' do
+    store.key?("strkey1", :option1 => 1).should == false
+    store.load("strkey1", :option2 => 2).should == nil
+    store.fetch("strkey1", 42, :option3 => 3).should == 42
+    store.fetch("strkey1", :option3 => 3) { 42 }.should == 42
+    store.delete("strkey1", :option4 => 4).should == nil
+    store.clear(:option5 => 5).should equal(store)
+    store.store("strkey1", true, :option6 => 6).should == true
+  end
+end
+
+#################### store_stringkey_booleanvalue ####################
+
+shared_examples_for 'store_stringkey_booleanvalue' do
+  it "writes Boolean values to keys that are Strings like a Hash" do
+    store["strkey1"] = true
+    store["strkey1"].should == true
+    store.load("strkey1").should == true
+  end
+
+  it "returns true from key? if a String key is available" do
+    store["strkey1"] = true
+    store.key?("strkey1").should == true
+    store["strkey2"] = false
+    store.key?("strkey2").should == true
+  end
+
+  it "stores Boolean values with String keys with #store" do
+    value = true
+    store.store("strkey1", value).should equal(value)
+    store["strkey1"].should == true
+    store.load("strkey1").should == true
+  end
+
+  it "stores String after clear" do
+    store["strkey1"] = true
+    store["strkey2"] = false
+    store.clear.should equal(store)
+    store["strkey1"] = true
+    store["strkey1"].should == true
+    store["strkey2"].should be_nil
+  end
+
+  it "removes and returns a Boolean element with a String key from the backing store via delete if it exists" do
+    store["strkey1"] = true
+    store.delete("strkey1").should == true
+    store.key?("strkey1").should == false
+  end
+
+  it "overwrites existing Boolean values with String" do
+    store["strkey1"] = true
+    store["strkey1"].should == true
+    store["strkey1"] = false
+    store["strkey1"].should == false
+  end
+
+  it "does not run the block if the String key is available" do
+    store["strkey1"] = true
+    unaltered = "unaltered"
+    store.fetch("strkey1") { unaltered = "altered" }
+    unaltered.should == "unaltered"
+  end
+
+  it "fetches a String key with a default value with fetch, if the key is available" do
+    store["strkey1"] = true
+    store.fetch("strkey1", false).should == true
+  end
+end
+
+#################### expires_stringkey_booleanvalue ####################
+
+shared_examples_for 'expires_stringkey_booleanvalue' do
+  it 'should support expires on store and #[]' do
+    store.store("strkey1", true, :expires => 2)
+    store["strkey1"].should == true
+    sleep 1
+    store["strkey1"].should == true
+    sleep 2
+    store["strkey1"].should == nil
+  end
+
+  it 'should support expires on store and load' do
+    store.store("strkey1", true, :expires => 2)
+    store.load("strkey1").should == true
+    sleep 1
+    store.load("strkey1").should == true
+    sleep 2
+    store.load("strkey1").should == nil
+  end
+
+  it 'should support expires on store and key?' do
+    store.store("strkey1", true, :expires => 2)
+    store.key?("strkey1").should == true
+    sleep 1
+    store.key?("strkey1").should == true
+    sleep 2
+    store.key?("strkey1").should == false
+  end
+
+  it 'should support updating the expiration time in load' do
+    store.store("strkey2", false, :expires => 2)
+    store["strkey2"].should == false
+    sleep 1
+    store.load("strkey2", :expires => 3).should == false
+    store["strkey2"].should == false
+    sleep 1
+    store["strkey2"].should == false
+    sleep 3
+    store["strkey2"].should == nil
+  end
+
+  it 'should support updating the expiration time in key?' do
+    store.store("strkey2", false, :expires => 2)
+    store["strkey2"].should == false
+    sleep 1
+    store.key?("strkey2", :expires => 3).should be_true
+    store["strkey2"].should == false
+    sleep 1
+    store["strkey2"].should == false
+    sleep 3
+    store["strkey2"].should == nil
+  end
+
+  it 'should support updating the expiration time in fetch' do
+    store.store("strkey1", true, :expires => 2)
+    store["strkey1"].should == true
+    sleep 1
+    store.fetch("strkey1", nil, :expires => 3).should == true
+    store["strkey1"].should == true
+    sleep 1
+    store["strkey1"].should == true
+    sleep 3
+    store["strkey1"].should == nil
+  end
+
+  it 'should respect expires in delete' do
+    store.store("strkey2", false, :expires => 2)
+    store["strkey2"].should == false
+    sleep 1
+    store["strkey2"].should == false
+    sleep 2
+    store.delete("strkey2").should == nil
+  end
+
+  it 'should support the #expires syntactic sugar' do
+    store['longlive_key'] = 'longlive_value'
+    store.expires(2).store("strkey2", false)
+    store["strkey2"].should == false
+    sleep 1
+    store["strkey2"].should == false
+    sleep 2
+    store.delete("strkey2").should == nil
+    store['longlive_key'].should == 'longlive_value'
+  end
+end
+
+#################### null_stringkey_stringvalue ####################
+
+shared_examples_for 'null_stringkey_stringvalue' do
+  it "reads from keys that are Strings like a Hash" do
+    store["strkey1"].should == nil
+    store.load("strkey1").should == nil
+  end
+
+  it "guarantees that the same String value is returned when setting a String key" do
+    value = "strval1"
+    (store["strkey1"] = value).should equal(value)
+  end
+
+  it "returns false from key? if a String key is not available" do
+    store.key?("strkey1").should == false
+  end
+
+  it "returns nil from delete if an element for a String key does not exist" do
+    store.delete("strkey1").should == nil
+  end
+
+  it "removes all String keys from the store with clear" do
+    store["strkey1"] = "strval1"
+    store["strkey2"] = "strval2"
+    store.clear.should equal(store)
+    store.key?("strkey1").should_not ==  true
+    store.key?("strkey2").should_not == true
+  end
+
+  it "fetches a String key with a default value with fetch, if the key is not available" do
+    store.fetch("strkey1", "strval1").should == "strval1"
+  end
+
+  it "fetches a String key with a block with fetch, if the key is not available" do
+    key = "strkey1"
+    value = "strval1"
+    store.fetch(key) do |k|
+      k.should equal(key)
+      value
+    end.should equal(value)
+  end
+
+  it 'should accept options' do
+    store.key?("strkey1", :option1 => 1).should == false
+    store.load("strkey1", :option2 => 2).should == nil
+    store.fetch("strkey1", 42, :option3 => 3).should == 42
+    store.fetch("strkey1", :option3 => 3) { 42 }.should == 42
+    store.delete("strkey1", :option4 => 4).should == nil
+    store.clear(:option5 => 5).should equal(store)
+    store.store("strkey1", "strval1", :option6 => 6).should == "strval1"
+  end
+end
+
+#################### store_stringkey_stringvalue ####################
+
+shared_examples_for 'store_stringkey_stringvalue' do
+  it "writes String values to keys that are Strings like a Hash" do
+    store["strkey1"] = "strval1"
+    store["strkey1"].should == "strval1"
+    store.load("strkey1").should == "strval1"
+  end
+
+  it "returns true from key? if a String key is available" do
+    store["strkey1"] = "strval1"
+    store.key?("strkey1").should == true
+    store["strkey2"] = "strval2"
+    store.key?("strkey2").should == true
+  end
+
+  it "stores String values with String keys with #store" do
+    value = "strval1"
+    store.store("strkey1", value).should equal(value)
+    store["strkey1"].should == "strval1"
+    store.load("strkey1").should == "strval1"
+  end
+
+  it "stores String after clear" do
+    store["strkey1"] = "strval1"
+    store["strkey2"] = "strval2"
+    store.clear.should equal(store)
+    store["strkey1"] = "strval1"
+    store["strkey1"].should == "strval1"
+    store["strkey2"].should be_nil
+  end
+
+  it "removes and returns a String element with a String key from the backing store via delete if it exists" do
+    store["strkey1"] = "strval1"
+    store.delete("strkey1").should == "strval1"
+    store.key?("strkey1").should == false
+  end
+
+  it "overwrites existing String values with String" do
+    store["strkey1"] = "strval1"
+    store["strkey1"].should == "strval1"
+    store["strkey1"] = "strval2"
+    store["strkey1"].should == "strval2"
+  end
+
+  it "does not run the block if the String key is available" do
+    store["strkey1"] = "strval1"
+    unaltered = "unaltered"
+    store.fetch("strkey1") { unaltered = "altered" }
+    unaltered.should == "unaltered"
+  end
+
+  it "fetches a String key with a default value with fetch, if the key is available" do
+    store["strkey1"] = "strval1"
+    store.fetch("strkey1", "strval2").should == "strval1"
+  end
+end
+
+#################### returndifferent_stringkey_stringvalue ####################
+
+shared_examples_for 'returndifferent_stringkey_stringvalue' do
+  it "guarantees that a different String value is retrieved from the String key" do
+    value = "strval1"
+    store["strkey1"] = "strval1"
+    store["strkey1"].should_not be_equal("strval1")
+  end
+end
+
+#################### expires_stringkey_stringvalue ####################
+
+shared_examples_for 'expires_stringkey_stringvalue' do
+  it 'should support expires on store and #[]' do
+    store.store("strkey1", "strval1", :expires => 2)
+    store["strkey1"].should == "strval1"
+    sleep 1
+    store["strkey1"].should == "strval1"
+    sleep 2
+    store["strkey1"].should == nil
+  end
+
+  it 'should support expires on store and load' do
+    store.store("strkey1", "strval1", :expires => 2)
+    store.load("strkey1").should == "strval1"
+    sleep 1
+    store.load("strkey1").should == "strval1"
+    sleep 2
+    store.load("strkey1").should == nil
+  end
+
+  it 'should support expires on store and key?' do
+    store.store("strkey1", "strval1", :expires => 2)
+    store.key?("strkey1").should == true
+    sleep 1
+    store.key?("strkey1").should == true
+    sleep 2
+    store.key?("strkey1").should == false
+  end
+
+  it 'should support updating the expiration time in load' do
+    store.store("strkey2", "strval2", :expires => 2)
+    store["strkey2"].should == "strval2"
+    sleep 1
+    store.load("strkey2", :expires => 3).should == "strval2"
+    store["strkey2"].should == "strval2"
+    sleep 1
+    store["strkey2"].should == "strval2"
+    sleep 3
+    store["strkey2"].should == nil
+  end
+
+  it 'should support updating the expiration time in key?' do
+    store.store("strkey2", "strval2", :expires => 2)
+    store["strkey2"].should == "strval2"
+    sleep 1
+    store.key?("strkey2", :expires => 3).should be_true
+    store["strkey2"].should == "strval2"
+    sleep 1
+    store["strkey2"].should == "strval2"
+    sleep 3
+    store["strkey2"].should == nil
+  end
+
+  it 'should support updating the expiration time in fetch' do
+    store.store("strkey1", "strval1", :expires => 2)
+    store["strkey1"].should == "strval1"
+    sleep 1
+    store.fetch("strkey1", nil, :expires => 3).should == "strval1"
+    store["strkey1"].should == "strval1"
+    sleep 1
+    store["strkey1"].should == "strval1"
+    sleep 3
+    store["strkey1"].should == nil
+  end
+
+  it 'should respect expires in delete' do
+    store.store("strkey2", "strval2", :expires => 2)
+    store["strkey2"].should == "strval2"
+    sleep 1
+    store["strkey2"].should == "strval2"
+    sleep 2
+    store.delete("strkey2").should == nil
+  end
+
+  it 'should support the #expires syntactic sugar' do
+    store['longlive_key'] = 'longlive_value'
+    store.expires(2).store("strkey2", "strval2")
+    store["strkey2"].should == "strval2"
+    sleep 1
+    store["strkey2"].should == "strval2"
+    sleep 2
+    store.delete("strkey2").should == nil
+    store['longlive_key'].should == 'longlive_value'
+  end
+end
+
+#################### null_stringkey_hashvalue ####################
+
+shared_examples_for 'null_stringkey_hashvalue' do
+  it "reads from keys that are Strings like a Hash" do
+    store["strkey1"].should == nil
+    store.load("strkey1").should == nil
+  end
+
+  it "guarantees that the same Hash value is returned when setting a String key" do
+    value = {"hashval1"=>["array1", 1]}
+    (store["strkey1"] = value).should equal(value)
+  end
+
+  it "returns false from key? if a String key is not available" do
+    store.key?("strkey1").should == false
+  end
+
+  it "returns nil from delete if an element for a String key does not exist" do
+    store.delete("strkey1").should == nil
+  end
+
+  it "removes all String keys from the store with clear" do
+    store["strkey1"] = {"hashval1"=>["array1", 1]}
+    store["strkey2"] = {"hashval3"=>["array2", {"hashval4"=>42}]}
+    store.clear.should equal(store)
+    store.key?("strkey1").should_not ==  true
+    store.key?("strkey2").should_not == true
+  end
+
+  it "fetches a String key with a default value with fetch, if the key is not available" do
+    store.fetch("strkey1", {"hashval1"=>["array1", 1]}).should == {"hashval1"=>["array1", 1]}
+  end
+
+  it "fetches a String key with a block with fetch, if the key is not available" do
+    key = "strkey1"
+    value = {"hashval1"=>["array1", 1]}
+    store.fetch(key) do |k|
+      k.should equal(key)
+      value
+    end.should equal(value)
+  end
+
+  it 'should accept options' do
+    store.key?("strkey1", :option1 => 1).should == false
+    store.load("strkey1", :option2 => 2).should == nil
+    store.fetch("strkey1", 42, :option3 => 3).should == 42
+    store.fetch("strkey1", :option3 => 3) { 42 }.should == 42
+    store.delete("strkey1", :option4 => 4).should == nil
+    store.clear(:option5 => 5).should equal(store)
+    store.store("strkey1", {"hashval1"=>["array1", 1]}, :option6 => 6).should == {"hashval1"=>["array1", 1]}
+  end
+end
+
+#################### store_stringkey_hashvalue ####################
+
+shared_examples_for 'store_stringkey_hashvalue' do
+  it "writes Hash values to keys that are Strings like a Hash" do
+    store["strkey1"] = {"hashval1"=>["array1", 1]}
+    store["strkey1"].should == {"hashval1"=>["array1", 1]}
+    store.load("strkey1").should == {"hashval1"=>["array1", 1]}
+  end
+
+  it "returns true from key? if a String key is available" do
+    store["strkey1"] = {"hashval1"=>["array1", 1]}
+    store.key?("strkey1").should == true
+    store["strkey2"] = {"hashval3"=>["array2", {"hashval4"=>42}]}
+    store.key?("strkey2").should == true
+  end
+
+  it "stores Hash values with String keys with #store" do
+    value = {"hashval1"=>["array1", 1]}
+    store.store("strkey1", value).should equal(value)
+    store["strkey1"].should == {"hashval1"=>["array1", 1]}
+    store.load("strkey1").should == {"hashval1"=>["array1", 1]}
+  end
+
+  it "stores String after clear" do
+    store["strkey1"] = {"hashval1"=>["array1", 1]}
+    store["strkey2"] = {"hashval3"=>["array2", {"hashval4"=>42}]}
+    store.clear.should equal(store)
+    store["strkey1"] = {"hashval1"=>["array1", 1]}
+    store["strkey1"].should == {"hashval1"=>["array1", 1]}
+    store["strkey2"].should be_nil
+  end
+
+  it "removes and returns a Hash element with a String key from the backing store via delete if it exists" do
+    store["strkey1"] = {"hashval1"=>["array1", 1]}
+    store.delete("strkey1").should == {"hashval1"=>["array1", 1]}
+    store.key?("strkey1").should == false
+  end
+
+  it "overwrites existing Hash values with String" do
+    store["strkey1"] = {"hashval1"=>["array1", 1]}
+    store["strkey1"].should == {"hashval1"=>["array1", 1]}
+    store["strkey1"] = {"hashval3"=>["array2", {"hashval4"=>42}]}
+    store["strkey1"].should == {"hashval3"=>["array2", {"hashval4"=>42}]}
+  end
+
+  it "does not run the block if the String key is available" do
+    store["strkey1"] = {"hashval1"=>["array1", 1]}
+    unaltered = "unaltered"
+    store.fetch("strkey1") { unaltered = "altered" }
+    unaltered.should == "unaltered"
+  end
+
+  it "fetches a String key with a default value with fetch, if the key is available" do
+    store["strkey1"] = {"hashval1"=>["array1", 1]}
+    store.fetch("strkey1", {"hashval3"=>["array2", {"hashval4"=>42}]}).should == {"hashval1"=>["array1", 1]}
+  end
+end
+
+#################### returndifferent_stringkey_hashvalue ####################
+
+shared_examples_for 'returndifferent_stringkey_hashvalue' do
+  it "guarantees that a different Hash value is retrieved from the String key" do
+    value = {"hashval1"=>["array1", 1]}
+    store["strkey1"] = {"hashval1"=>["array1", 1]}
+    store["strkey1"].should_not be_equal({"hashval1"=>["array1", 1]})
+  end
+end
+
+#################### expires_stringkey_hashvalue ####################
+
+shared_examples_for 'expires_stringkey_hashvalue' do
+  it 'should support expires on store and #[]' do
+    store.store("strkey1", {"hashval1"=>["array1", 1]}, :expires => 2)
+    store["strkey1"].should == {"hashval1"=>["array1", 1]}
+    sleep 1
+    store["strkey1"].should == {"hashval1"=>["array1", 1]}
+    sleep 2
+    store["strkey1"].should == nil
+  end
+
+  it 'should support expires on store and load' do
+    store.store("strkey1", {"hashval1"=>["array1", 1]}, :expires => 2)
+    store.load("strkey1").should == {"hashval1"=>["array1", 1]}
+    sleep 1
+    store.load("strkey1").should == {"hashval1"=>["array1", 1]}
+    sleep 2
+    store.load("strkey1").should == nil
+  end
+
+  it 'should support expires on store and key?' do
+    store.store("strkey1", {"hashval1"=>["array1", 1]}, :expires => 2)
+    store.key?("strkey1").should == true
+    sleep 1
+    store.key?("strkey1").should == true
+    sleep 2
+    store.key?("strkey1").should == false
+  end
+
+  it 'should support updating the expiration time in load' do
+    store.store("strkey2", {"hashval3"=>["array2", {"hashval4"=>42}]}, :expires => 2)
+    store["strkey2"].should == {"hashval3"=>["array2", {"hashval4"=>42}]}
+    sleep 1
+    store.load("strkey2", :expires => 3).should == {"hashval3"=>["array2", {"hashval4"=>42}]}
+    store["strkey2"].should == {"hashval3"=>["array2", {"hashval4"=>42}]}
+    sleep 1
+    store["strkey2"].should == {"hashval3"=>["array2", {"hashval4"=>42}]}
+    sleep 3
+    store["strkey2"].should == nil
+  end
+
+  it 'should support updating the expiration time in key?' do
+    store.store("strkey2", {"hashval3"=>["array2", {"hashval4"=>42}]}, :expires => 2)
+    store["strkey2"].should == {"hashval3"=>["array2", {"hashval4"=>42}]}
+    sleep 1
+    store.key?("strkey2", :expires => 3).should be_true
+    store["strkey2"].should == {"hashval3"=>["array2", {"hashval4"=>42}]}
+    sleep 1
+    store["strkey2"].should == {"hashval3"=>["array2", {"hashval4"=>42}]}
+    sleep 3
+    store["strkey2"].should == nil
+  end
+
+  it 'should support updating the expiration time in fetch' do
+    store.store("strkey1", {"hashval1"=>["array1", 1]}, :expires => 2)
+    store["strkey1"].should == {"hashval1"=>["array1", 1]}
+    sleep 1
+    store.fetch("strkey1", nil, :expires => 3).should == {"hashval1"=>["array1", 1]}
+    store["strkey1"].should == {"hashval1"=>["array1", 1]}
+    sleep 1
+    store["strkey1"].should == {"hashval1"=>["array1", 1]}
+    sleep 3
+    store["strkey1"].should == nil
+  end
+
+  it 'should respect expires in delete' do
+    store.store("strkey2", {"hashval3"=>["array2", {"hashval4"=>42}]}, :expires => 2)
+    store["strkey2"].should == {"hashval3"=>["array2", {"hashval4"=>42}]}
+    sleep 1
+    store["strkey2"].should == {"hashval3"=>["array2", {"hashval4"=>42}]}
+    sleep 2
+    store.delete("strkey2").should == nil
+  end
+
+  it 'should support the #expires syntactic sugar' do
+    store['longlive_key'] = 'longlive_value'
+    store.expires(2).store("strkey2", {"hashval3"=>["array2", {"hashval4"=>42}]})
+    store["strkey2"].should == {"hashval3"=>["array2", {"hashval4"=>42}]}
+    sleep 1
+    store["strkey2"].should == {"hashval3"=>["array2", {"hashval4"=>42}]}
+    sleep 2
+    store.delete("strkey2").should == nil
+    store['longlive_key'].should == 'longlive_value'
+  end
+end
+
+#################### null_stringkey_objectvalue ####################
+
+shared_examples_for 'null_stringkey_objectvalue' do
+  it "reads from keys that are Strings like a Hash" do
+    store["strkey1"].should == nil
+    store.load("strkey1").should == nil
+  end
+
+  it "guarantees that the same Object value is returned when setting a String key" do
+    value = Value.new(:objval1)
+    (store["strkey1"] = value).should equal(value)
+  end
+
+  it "returns false from key? if a String key is not available" do
+    store.key?("strkey1").should == false
+  end
+
+  it "returns nil from delete if an element for a String key does not exist" do
+    store.delete("strkey1").should == nil
+  end
+
+  it "removes all String keys from the store with clear" do
+    store["strkey1"] = Value.new(:objval1)
+    store["strkey2"] = Value.new(:objval2)
+    store.clear.should equal(store)
+    store.key?("strkey1").should_not ==  true
+    store.key?("strkey2").should_not == true
+  end
+
+  it "fetches a String key with a default value with fetch, if the key is not available" do
+    store.fetch("strkey1", Value.new(:objval1)).should == Value.new(:objval1)
+  end
+
+  it "fetches a String key with a block with fetch, if the key is not available" do
+    key = "strkey1"
+    value = Value.new(:objval1)
+    store.fetch(key) do |k|
+      k.should equal(key)
+      value
+    end.should equal(value)
+  end
+
+  it 'should accept options' do
+    store.key?("strkey1", :option1 => 1).should == false
+    store.load("strkey1", :option2 => 2).should == nil
+    store.fetch("strkey1", 42, :option3 => 3).should == 42
+    store.fetch("strkey1", :option3 => 3) { 42 }.should == 42
+    store.delete("strkey1", :option4 => 4).should == nil
+    store.clear(:option5 => 5).should equal(store)
+    store.store("strkey1", Value.new(:objval1), :option6 => 6).should == Value.new(:objval1)
+  end
+end
+
+#################### store_stringkey_objectvalue ####################
+
+shared_examples_for 'store_stringkey_objectvalue' do
+  it "writes Object values to keys that are Strings like a Hash" do
+    store["strkey1"] = Value.new(:objval1)
+    store["strkey1"].should == Value.new(:objval1)
+    store.load("strkey1").should == Value.new(:objval1)
+  end
+
+  it "returns true from key? if a String key is available" do
+    store["strkey1"] = Value.new(:objval1)
+    store.key?("strkey1").should == true
+    store["strkey2"] = Value.new(:objval2)
+    store.key?("strkey2").should == true
+  end
+
+  it "stores Object values with String keys with #store" do
+    value = Value.new(:objval1)
+    store.store("strkey1", value).should equal(value)
+    store["strkey1"].should == Value.new(:objval1)
+    store.load("strkey1").should == Value.new(:objval1)
+  end
+
+  it "stores String after clear" do
+    store["strkey1"] = Value.new(:objval1)
+    store["strkey2"] = Value.new(:objval2)
+    store.clear.should equal(store)
+    store["strkey1"] = Value.new(:objval1)
+    store["strkey1"].should == Value.new(:objval1)
+    store["strkey2"].should be_nil
+  end
+
+  it "removes and returns a Object element with a String key from the backing store via delete if it exists" do
+    store["strkey1"] = Value.new(:objval1)
+    store.delete("strkey1").should == Value.new(:objval1)
+    store.key?("strkey1").should == false
+  end
+
+  it "overwrites existing Object values with String" do
+    store["strkey1"] = Value.new(:objval1)
+    store["strkey1"].should == Value.new(:objval1)
+    store["strkey1"] = Value.new(:objval2)
+    store["strkey1"].should == Value.new(:objval2)
+  end
+
+  it "does not run the block if the String key is available" do
+    store["strkey1"] = Value.new(:objval1)
+    unaltered = "unaltered"
+    store.fetch("strkey1") { unaltered = "altered" }
+    unaltered.should == "unaltered"
+  end
+
+  it "fetches a String key with a default value with fetch, if the key is available" do
+    store["strkey1"] = Value.new(:objval1)
+    store.fetch("strkey1", Value.new(:objval2)).should == Value.new(:objval1)
+  end
+end
+
+#################### returndifferent_stringkey_objectvalue ####################
+
+shared_examples_for 'returndifferent_stringkey_objectvalue' do
+  it "guarantees that a different Object value is retrieved from the String key" do
+    value = Value.new(:objval1)
+    store["strkey1"] = Value.new(:objval1)
+    store["strkey1"].should_not be_equal(Value.new(:objval1))
+  end
+end
+
+#################### expires_stringkey_objectvalue ####################
+
+shared_examples_for 'expires_stringkey_objectvalue' do
+  it 'should support expires on store and #[]' do
+    store.store("strkey1", Value.new(:objval1), :expires => 2)
+    store["strkey1"].should == Value.new(:objval1)
+    sleep 1
+    store["strkey1"].should == Value.new(:objval1)
+    sleep 2
+    store["strkey1"].should == nil
+  end
+
+  it 'should support expires on store and load' do
+    store.store("strkey1", Value.new(:objval1), :expires => 2)
+    store.load("strkey1").should == Value.new(:objval1)
+    sleep 1
+    store.load("strkey1").should == Value.new(:objval1)
+    sleep 2
+    store.load("strkey1").should == nil
+  end
+
+  it 'should support expires on store and key?' do
+    store.store("strkey1", Value.new(:objval1), :expires => 2)
+    store.key?("strkey1").should == true
+    sleep 1
+    store.key?("strkey1").should == true
+    sleep 2
+    store.key?("strkey1").should == false
+  end
+
+  it 'should support updating the expiration time in load' do
+    store.store("strkey2", Value.new(:objval2), :expires => 2)
+    store["strkey2"].should == Value.new(:objval2)
+    sleep 1
+    store.load("strkey2", :expires => 3).should == Value.new(:objval2)
+    store["strkey2"].should == Value.new(:objval2)
+    sleep 1
+    store["strkey2"].should == Value.new(:objval2)
+    sleep 3
+    store["strkey2"].should == nil
+  end
+
+  it 'should support updating the expiration time in key?' do
+    store.store("strkey2", Value.new(:objval2), :expires => 2)
+    store["strkey2"].should == Value.new(:objval2)
+    sleep 1
+    store.key?("strkey2", :expires => 3).should be_true
+    store["strkey2"].should == Value.new(:objval2)
+    sleep 1
+    store["strkey2"].should == Value.new(:objval2)
+    sleep 3
+    store["strkey2"].should == nil
+  end
+
+  it 'should support updating the expiration time in fetch' do
+    store.store("strkey1", Value.new(:objval1), :expires => 2)
+    store["strkey1"].should == Value.new(:objval1)
+    sleep 1
+    store.fetch("strkey1", nil, :expires => 3).should == Value.new(:objval1)
+    store["strkey1"].should == Value.new(:objval1)
+    sleep 1
+    store["strkey1"].should == Value.new(:objval1)
+    sleep 3
+    store["strkey1"].should == nil
+  end
+
+  it 'should respect expires in delete' do
+    store.store("strkey2", Value.new(:objval2), :expires => 2)
+    store["strkey2"].should == Value.new(:objval2)
+    sleep 1
+    store["strkey2"].should == Value.new(:objval2)
+    sleep 2
+    store.delete("strkey2").should == nil
+  end
+
+  it 'should support the #expires syntactic sugar' do
+    store['longlive_key'] = 'longlive_value'
+    store.expires(2).store("strkey2", Value.new(:objval2))
+    store["strkey2"].should == Value.new(:objval2)
+    sleep 1
+    store["strkey2"].should == Value.new(:objval2)
+    sleep 2
+    store.delete("strkey2").should == nil
+    store['longlive_key'].should == 'longlive_value'
+  end
+end
+
+#################### null_objectkey_booleanvalue ####################
+
+shared_examples_for 'null_objectkey_booleanvalue' do
+  it "reads from keys that are Objects like a Hash" do
+    store[Value.new(:objkey1)].should == nil
+    store.load(Value.new(:objkey1)).should == nil
+  end
+
+  it "guarantees that the same Boolean value is returned when setting a Object key" do
+    value = true
+    (store[Value.new(:objkey1)] = value).should equal(value)
+  end
+
+  it "returns false from key? if a Object key is not available" do
+    store.key?(Value.new(:objkey1)).should == false
+  end
+
+  it "returns nil from delete if an element for a Object key does not exist" do
+    store.delete(Value.new(:objkey1)).should == nil
+  end
+
+  it "removes all Object keys from the store with clear" do
+    store[Value.new(:objkey1)] = true
+    store[Value.new(:objkey2)] = false
+    store.clear.should equal(store)
+    store.key?(Value.new(:objkey1)).should_not ==  true
+    store.key?(Value.new(:objkey2)).should_not == true
+  end
+
+  it "fetches a Object key with a default value with fetch, if the key is not available" do
+    store.fetch(Value.new(:objkey1), true).should == true
+  end
+
+  it "fetches a Object key with a block with fetch, if the key is not available" do
+    key = Value.new(:objkey1)
+    value = true
+    store.fetch(key) do |k|
+      k.should equal(key)
+      value
+    end.should equal(value)
+  end
+
+  it 'should accept options' do
+    store.key?(Value.new(:objkey1), :option1 => 1).should == false
+    store.load(Value.new(:objkey1), :option2 => 2).should == nil
+    store.fetch(Value.new(:objkey1), 42, :option3 => 3).should == 42
+    store.fetch(Value.new(:objkey1), :option3 => 3) { 42 }.should == 42
+    store.delete(Value.new(:objkey1), :option4 => 4).should == nil
+    store.clear(:option5 => 5).should equal(store)
+    store.store(Value.new(:objkey1), true, :option6 => 6).should == true
+  end
+end
+
+#################### store_objectkey_booleanvalue ####################
+
+shared_examples_for 'store_objectkey_booleanvalue' do
+  it "writes Boolean values to keys that are Objects like a Hash" do
+    store[Value.new(:objkey1)] = true
+    store[Value.new(:objkey1)].should == true
+    store.load(Value.new(:objkey1)).should == true
+  end
+
+  it "returns true from key? if a Object key is available" do
+    store[Value.new(:objkey1)] = true
+    store.key?(Value.new(:objkey1)).should == true
+    store[Value.new(:objkey2)] = false
+    store.key?(Value.new(:objkey2)).should == true
+  end
+
+  it "stores Boolean values with Object keys with #store" do
+    value = true
+    store.store(Value.new(:objkey1), value).should equal(value)
+    store[Value.new(:objkey1)].should == true
+    store.load(Value.new(:objkey1)).should == true
+  end
+
+  it "stores Object after clear" do
+    store[Value.new(:objkey1)] = true
+    store[Value.new(:objkey2)] = false
+    store.clear.should equal(store)
+    store[Value.new(:objkey1)] = true
+    store[Value.new(:objkey1)].should == true
+    store[Value.new(:objkey2)].should be_nil
+  end
+
+  it "removes and returns a Boolean element with a Object key from the backing store via delete if it exists" do
+    store[Value.new(:objkey1)] = true
+    store.delete(Value.new(:objkey1)).should == true
+    store.key?(Value.new(:objkey1)).should == false
+  end
+
+  it "overwrites existing Boolean values with Object" do
+    store[Value.new(:objkey1)] = true
+    store[Value.new(:objkey1)].should == true
+    store[Value.new(:objkey1)] = false
+    store[Value.new(:objkey1)].should == false
+  end
+
+  it "does not run the block if the Object key is available" do
+    store[Value.new(:objkey1)] = true
+    unaltered = "unaltered"
+    store.fetch(Value.new(:objkey1)) { unaltered = "altered" }
+    unaltered.should == "unaltered"
+  end
+
+  it "fetches a Object key with a default value with fetch, if the key is available" do
+    store[Value.new(:objkey1)] = true
+    store.fetch(Value.new(:objkey1), false).should == true
+  end
+end
+
+#################### expires_objectkey_booleanvalue ####################
+
+shared_examples_for 'expires_objectkey_booleanvalue' do
+  it 'should support expires on store and #[]' do
+    store.store(Value.new(:objkey1), true, :expires => 2)
+    store[Value.new(:objkey1)].should == true
+    sleep 1
+    store[Value.new(:objkey1)].should == true
+    sleep 2
+    store[Value.new(:objkey1)].should == nil
+  end
+
+  it 'should support expires on store and load' do
+    store.store(Value.new(:objkey1), true, :expires => 2)
+    store.load(Value.new(:objkey1)).should == true
+    sleep 1
+    store.load(Value.new(:objkey1)).should == true
+    sleep 2
+    store.load(Value.new(:objkey1)).should == nil
+  end
+
+  it 'should support expires on store and key?' do
+    store.store(Value.new(:objkey1), true, :expires => 2)
+    store.key?(Value.new(:objkey1)).should == true
+    sleep 1
+    store.key?(Value.new(:objkey1)).should == true
+    sleep 2
+    store.key?(Value.new(:objkey1)).should == false
+  end
+
+  it 'should support updating the expiration time in load' do
+    store.store(Value.new(:objkey2), false, :expires => 2)
+    store[Value.new(:objkey2)].should == false
+    sleep 1
+    store.load(Value.new(:objkey2), :expires => 3).should == false
+    store[Value.new(:objkey2)].should == false
+    sleep 1
+    store[Value.new(:objkey2)].should == false
+    sleep 3
+    store[Value.new(:objkey2)].should == nil
+  end
+
+  it 'should support updating the expiration time in key?' do
+    store.store(Value.new(:objkey2), false, :expires => 2)
+    store[Value.new(:objkey2)].should == false
+    sleep 1
+    store.key?(Value.new(:objkey2), :expires => 3).should be_true
+    store[Value.new(:objkey2)].should == false
+    sleep 1
+    store[Value.new(:objkey2)].should == false
+    sleep 3
+    store[Value.new(:objkey2)].should == nil
+  end
+
+  it 'should support updating the expiration time in fetch' do
+    store.store(Value.new(:objkey1), true, :expires => 2)
+    store[Value.new(:objkey1)].should == true
+    sleep 1
+    store.fetch(Value.new(:objkey1), nil, :expires => 3).should == true
+    store[Value.new(:objkey1)].should == true
+    sleep 1
+    store[Value.new(:objkey1)].should == true
+    sleep 3
+    store[Value.new(:objkey1)].should == nil
+  end
+
+  it 'should respect expires in delete' do
+    store.store(Value.new(:objkey2), false, :expires => 2)
+    store[Value.new(:objkey2)].should == false
+    sleep 1
+    store[Value.new(:objkey2)].should == false
+    sleep 2
+    store.delete(Value.new(:objkey2)).should == nil
+  end
+
+  it 'should support the #expires syntactic sugar' do
+    store['longlive_key'] = 'longlive_value'
+    store.expires(2).store(Value.new(:objkey2), false)
+    store[Value.new(:objkey2)].should == false
+    sleep 1
+    store[Value.new(:objkey2)].should == false
+    sleep 2
+    store.delete(Value.new(:objkey2)).should == nil
+    store['longlive_key'].should == 'longlive_value'
+  end
+end
+
+#################### null_objectkey_stringvalue ####################
+
+shared_examples_for 'null_objectkey_stringvalue' do
+  it "reads from keys that are Objects like a Hash" do
+    store[Value.new(:objkey1)].should == nil
+    store.load(Value.new(:objkey1)).should == nil
+  end
+
+  it "guarantees that the same String value is returned when setting a Object key" do
+    value = "strval1"
+    (store[Value.new(:objkey1)] = value).should equal(value)
+  end
+
+  it "returns false from key? if a Object key is not available" do
+    store.key?(Value.new(:objkey1)).should == false
+  end
+
+  it "returns nil from delete if an element for a Object key does not exist" do
+    store.delete(Value.new(:objkey1)).should == nil
+  end
+
+  it "removes all Object keys from the store with clear" do
+    store[Value.new(:objkey1)] = "strval1"
+    store[Value.new(:objkey2)] = "strval2"
+    store.clear.should equal(store)
+    store.key?(Value.new(:objkey1)).should_not ==  true
+    store.key?(Value.new(:objkey2)).should_not == true
+  end
+
+  it "fetches a Object key with a default value with fetch, if the key is not available" do
+    store.fetch(Value.new(:objkey1), "strval1").should == "strval1"
+  end
+
+  it "fetches a Object key with a block with fetch, if the key is not available" do
+    key = Value.new(:objkey1)
+    value = "strval1"
+    store.fetch(key) do |k|
+      k.should equal(key)
+      value
+    end.should equal(value)
+  end
+
+  it 'should accept options' do
+    store.key?(Value.new(:objkey1), :option1 => 1).should == false
+    store.load(Value.new(:objkey1), :option2 => 2).should == nil
+    store.fetch(Value.new(:objkey1), 42, :option3 => 3).should == 42
+    store.fetch(Value.new(:objkey1), :option3 => 3) { 42 }.should == 42
+    store.delete(Value.new(:objkey1), :option4 => 4).should == nil
+    store.clear(:option5 => 5).should equal(store)
+    store.store(Value.new(:objkey1), "strval1", :option6 => 6).should == "strval1"
+  end
+end
+
+#################### store_objectkey_stringvalue ####################
+
+shared_examples_for 'store_objectkey_stringvalue' do
+  it "writes String values to keys that are Objects like a Hash" do
+    store[Value.new(:objkey1)] = "strval1"
+    store[Value.new(:objkey1)].should == "strval1"
+    store.load(Value.new(:objkey1)).should == "strval1"
+  end
+
+  it "returns true from key? if a Object key is available" do
+    store[Value.new(:objkey1)] = "strval1"
+    store.key?(Value.new(:objkey1)).should == true
+    store[Value.new(:objkey2)] = "strval2"
+    store.key?(Value.new(:objkey2)).should == true
+  end
+
+  it "stores String values with Object keys with #store" do
+    value = "strval1"
+    store.store(Value.new(:objkey1), value).should equal(value)
+    store[Value.new(:objkey1)].should == "strval1"
+    store.load(Value.new(:objkey1)).should == "strval1"
+  end
+
+  it "stores Object after clear" do
+    store[Value.new(:objkey1)] = "strval1"
+    store[Value.new(:objkey2)] = "strval2"
+    store.clear.should equal(store)
+    store[Value.new(:objkey1)] = "strval1"
+    store[Value.new(:objkey1)].should == "strval1"
+    store[Value.new(:objkey2)].should be_nil
+  end
+
+  it "removes and returns a String element with a Object key from the backing store via delete if it exists" do
+    store[Value.new(:objkey1)] = "strval1"
+    store.delete(Value.new(:objkey1)).should == "strval1"
+    store.key?(Value.new(:objkey1)).should == false
+  end
+
+  it "overwrites existing String values with Object" do
+    store[Value.new(:objkey1)] = "strval1"
+    store[Value.new(:objkey1)].should == "strval1"
+    store[Value.new(:objkey1)] = "strval2"
+    store[Value.new(:objkey1)].should == "strval2"
+  end
+
+  it "does not run the block if the Object key is available" do
+    store[Value.new(:objkey1)] = "strval1"
+    unaltered = "unaltered"
+    store.fetch(Value.new(:objkey1)) { unaltered = "altered" }
+    unaltered.should == "unaltered"
+  end
+
+  it "fetches a Object key with a default value with fetch, if the key is available" do
+    store[Value.new(:objkey1)] = "strval1"
+    store.fetch(Value.new(:objkey1), "strval2").should == "strval1"
+  end
+end
+
+#################### returndifferent_objectkey_stringvalue ####################
+
+shared_examples_for 'returndifferent_objectkey_stringvalue' do
+  it "guarantees that a different String value is retrieved from the Object key" do
+    value = "strval1"
+    store[Value.new(:objkey1)] = "strval1"
+    store[Value.new(:objkey1)].should_not be_equal("strval1")
+  end
+end
+
+#################### expires_objectkey_stringvalue ####################
+
+shared_examples_for 'expires_objectkey_stringvalue' do
+  it 'should support expires on store and #[]' do
+    store.store(Value.new(:objkey1), "strval1", :expires => 2)
+    store[Value.new(:objkey1)].should == "strval1"
+    sleep 1
+    store[Value.new(:objkey1)].should == "strval1"
+    sleep 2
+    store[Value.new(:objkey1)].should == nil
+  end
+
+  it 'should support expires on store and load' do
+    store.store(Value.new(:objkey1), "strval1", :expires => 2)
+    store.load(Value.new(:objkey1)).should == "strval1"
+    sleep 1
+    store.load(Value.new(:objkey1)).should == "strval1"
+    sleep 2
+    store.load(Value.new(:objkey1)).should == nil
+  end
+
+  it 'should support expires on store and key?' do
+    store.store(Value.new(:objkey1), "strval1", :expires => 2)
+    store.key?(Value.new(:objkey1)).should == true
+    sleep 1
+    store.key?(Value.new(:objkey1)).should == true
+    sleep 2
+    store.key?(Value.new(:objkey1)).should == false
+  end
+
+  it 'should support updating the expiration time in load' do
+    store.store(Value.new(:objkey2), "strval2", :expires => 2)
+    store[Value.new(:objkey2)].should == "strval2"
+    sleep 1
+    store.load(Value.new(:objkey2), :expires => 3).should == "strval2"
+    store[Value.new(:objkey2)].should == "strval2"
+    sleep 1
+    store[Value.new(:objkey2)].should == "strval2"
+    sleep 3
+    store[Value.new(:objkey2)].should == nil
+  end
+
+  it 'should support updating the expiration time in key?' do
+    store.store(Value.new(:objkey2), "strval2", :expires => 2)
+    store[Value.new(:objkey2)].should == "strval2"
+    sleep 1
+    store.key?(Value.new(:objkey2), :expires => 3).should be_true
+    store[Value.new(:objkey2)].should == "strval2"
+    sleep 1
+    store[Value.new(:objkey2)].should == "strval2"
+    sleep 3
+    store[Value.new(:objkey2)].should == nil
+  end
+
+  it 'should support updating the expiration time in fetch' do
+    store.store(Value.new(:objkey1), "strval1", :expires => 2)
+    store[Value.new(:objkey1)].should == "strval1"
+    sleep 1
+    store.fetch(Value.new(:objkey1), nil, :expires => 3).should == "strval1"
+    store[Value.new(:objkey1)].should == "strval1"
+    sleep 1
+    store[Value.new(:objkey1)].should == "strval1"
+    sleep 3
+    store[Value.new(:objkey1)].should == nil
+  end
+
+  it 'should respect expires in delete' do
+    store.store(Value.new(:objkey2), "strval2", :expires => 2)
+    store[Value.new(:objkey2)].should == "strval2"
+    sleep 1
+    store[Value.new(:objkey2)].should == "strval2"
+    sleep 2
+    store.delete(Value.new(:objkey2)).should == nil
+  end
+
+  it 'should support the #expires syntactic sugar' do
+    store['longlive_key'] = 'longlive_value'
+    store.expires(2).store(Value.new(:objkey2), "strval2")
+    store[Value.new(:objkey2)].should == "strval2"
+    sleep 1
+    store[Value.new(:objkey2)].should == "strval2"
+    sleep 2
+    store.delete(Value.new(:objkey2)).should == nil
+    store['longlive_key'].should == 'longlive_value'
+  end
+end
+
+#################### null_objectkey_hashvalue ####################
+
+shared_examples_for 'null_objectkey_hashvalue' do
+  it "reads from keys that are Objects like a Hash" do
+    store[Value.new(:objkey1)].should == nil
+    store.load(Value.new(:objkey1)).should == nil
+  end
+
+  it "guarantees that the same Hash value is returned when setting a Object key" do
+    value = {"hashval1"=>["array1", 1]}
+    (store[Value.new(:objkey1)] = value).should equal(value)
+  end
+
+  it "returns false from key? if a Object key is not available" do
+    store.key?(Value.new(:objkey1)).should == false
+  end
+
+  it "returns nil from delete if an element for a Object key does not exist" do
+    store.delete(Value.new(:objkey1)).should == nil
+  end
+
+  it "removes all Object keys from the store with clear" do
+    store[Value.new(:objkey1)] = {"hashval1"=>["array1", 1]}
+    store[Value.new(:objkey2)] = {"hashval3"=>["array2", {"hashval4"=>42}]}
+    store.clear.should equal(store)
+    store.key?(Value.new(:objkey1)).should_not ==  true
+    store.key?(Value.new(:objkey2)).should_not == true
+  end
+
+  it "fetches a Object key with a default value with fetch, if the key is not available" do
+    store.fetch(Value.new(:objkey1), {"hashval1"=>["array1", 1]}).should == {"hashval1"=>["array1", 1]}
+  end
+
+  it "fetches a Object key with a block with fetch, if the key is not available" do
+    key = Value.new(:objkey1)
+    value = {"hashval1"=>["array1", 1]}
+    store.fetch(key) do |k|
+      k.should equal(key)
+      value
+    end.should equal(value)
+  end
+
+  it 'should accept options' do
+    store.key?(Value.new(:objkey1), :option1 => 1).should == false
+    store.load(Value.new(:objkey1), :option2 => 2).should == nil
+    store.fetch(Value.new(:objkey1), 42, :option3 => 3).should == 42
+    store.fetch(Value.new(:objkey1), :option3 => 3) { 42 }.should == 42
+    store.delete(Value.new(:objkey1), :option4 => 4).should == nil
+    store.clear(:option5 => 5).should equal(store)
+    store.store(Value.new(:objkey1), {"hashval1"=>["array1", 1]}, :option6 => 6).should == {"hashval1"=>["array1", 1]}
+  end
+end
+
+#################### store_objectkey_hashvalue ####################
+
+shared_examples_for 'store_objectkey_hashvalue' do
+  it "writes Hash values to keys that are Objects like a Hash" do
+    store[Value.new(:objkey1)] = {"hashval1"=>["array1", 1]}
+    store[Value.new(:objkey1)].should == {"hashval1"=>["array1", 1]}
+    store.load(Value.new(:objkey1)).should == {"hashval1"=>["array1", 1]}
+  end
+
+  it "returns true from key? if a Object key is available" do
+    store[Value.new(:objkey1)] = {"hashval1"=>["array1", 1]}
+    store.key?(Value.new(:objkey1)).should == true
+    store[Value.new(:objkey2)] = {"hashval3"=>["array2", {"hashval4"=>42}]}
+    store.key?(Value.new(:objkey2)).should == true
+  end
+
+  it "stores Hash values with Object keys with #store" do
+    value = {"hashval1"=>["array1", 1]}
+    store.store(Value.new(:objkey1), value).should equal(value)
+    store[Value.new(:objkey1)].should == {"hashval1"=>["array1", 1]}
+    store.load(Value.new(:objkey1)).should == {"hashval1"=>["array1", 1]}
+  end
+
+  it "stores Object after clear" do
+    store[Value.new(:objkey1)] = {"hashval1"=>["array1", 1]}
+    store[Value.new(:objkey2)] = {"hashval3"=>["array2", {"hashval4"=>42}]}
+    store.clear.should equal(store)
+    store[Value.new(:objkey1)] = {"hashval1"=>["array1", 1]}
+    store[Value.new(:objkey1)].should == {"hashval1"=>["array1", 1]}
+    store[Value.new(:objkey2)].should be_nil
+  end
+
+  it "removes and returns a Hash element with a Object key from the backing store via delete if it exists" do
+    store[Value.new(:objkey1)] = {"hashval1"=>["array1", 1]}
+    store.delete(Value.new(:objkey1)).should == {"hashval1"=>["array1", 1]}
+    store.key?(Value.new(:objkey1)).should == false
+  end
+
+  it "overwrites existing Hash values with Object" do
+    store[Value.new(:objkey1)] = {"hashval1"=>["array1", 1]}
+    store[Value.new(:objkey1)].should == {"hashval1"=>["array1", 1]}
+    store[Value.new(:objkey1)] = {"hashval3"=>["array2", {"hashval4"=>42}]}
+    store[Value.new(:objkey1)].should == {"hashval3"=>["array2", {"hashval4"=>42}]}
+  end
+
+  it "does not run the block if the Object key is available" do
+    store[Value.new(:objkey1)] = {"hashval1"=>["array1", 1]}
+    unaltered = "unaltered"
+    store.fetch(Value.new(:objkey1)) { unaltered = "altered" }
+    unaltered.should == "unaltered"
+  end
+
+  it "fetches a Object key with a default value with fetch, if the key is available" do
+    store[Value.new(:objkey1)] = {"hashval1"=>["array1", 1]}
+    store.fetch(Value.new(:objkey1), {"hashval3"=>["array2", {"hashval4"=>42}]}).should == {"hashval1"=>["array1", 1]}
+  end
+end
+
+#################### returndifferent_objectkey_hashvalue ####################
+
+shared_examples_for 'returndifferent_objectkey_hashvalue' do
+  it "guarantees that a different Hash value is retrieved from the Object key" do
+    value = {"hashval1"=>["array1", 1]}
+    store[Value.new(:objkey1)] = {"hashval1"=>["array1", 1]}
+    store[Value.new(:objkey1)].should_not be_equal({"hashval1"=>["array1", 1]})
+  end
+end
+
+#################### expires_objectkey_hashvalue ####################
+
+shared_examples_for 'expires_objectkey_hashvalue' do
+  it 'should support expires on store and #[]' do
+    store.store(Value.new(:objkey1), {"hashval1"=>["array1", 1]}, :expires => 2)
+    store[Value.new(:objkey1)].should == {"hashval1"=>["array1", 1]}
+    sleep 1
+    store[Value.new(:objkey1)].should == {"hashval1"=>["array1", 1]}
+    sleep 2
+    store[Value.new(:objkey1)].should == nil
+  end
+
+  it 'should support expires on store and load' do
+    store.store(Value.new(:objkey1), {"hashval1"=>["array1", 1]}, :expires => 2)
+    store.load(Value.new(:objkey1)).should == {"hashval1"=>["array1", 1]}
+    sleep 1
+    store.load(Value.new(:objkey1)).should == {"hashval1"=>["array1", 1]}
+    sleep 2
+    store.load(Value.new(:objkey1)).should == nil
+  end
+
+  it 'should support expires on store and key?' do
+    store.store(Value.new(:objkey1), {"hashval1"=>["array1", 1]}, :expires => 2)
+    store.key?(Value.new(:objkey1)).should == true
+    sleep 1
+    store.key?(Value.new(:objkey1)).should == true
+    sleep 2
+    store.key?(Value.new(:objkey1)).should == false
+  end
+
+  it 'should support updating the expiration time in load' do
+    store.store(Value.new(:objkey2), {"hashval3"=>["array2", {"hashval4"=>42}]}, :expires => 2)
+    store[Value.new(:objkey2)].should == {"hashval3"=>["array2", {"hashval4"=>42}]}
+    sleep 1
+    store.load(Value.new(:objkey2), :expires => 3).should == {"hashval3"=>["array2", {"hashval4"=>42}]}
+    store[Value.new(:objkey2)].should == {"hashval3"=>["array2", {"hashval4"=>42}]}
+    sleep 1
+    store[Value.new(:objkey2)].should == {"hashval3"=>["array2", {"hashval4"=>42}]}
+    sleep 3
+    store[Value.new(:objkey2)].should == nil
+  end
+
+  it 'should support updating the expiration time in key?' do
+    store.store(Value.new(:objkey2), {"hashval3"=>["array2", {"hashval4"=>42}]}, :expires => 2)
+    store[Value.new(:objkey2)].should == {"hashval3"=>["array2", {"hashval4"=>42}]}
+    sleep 1
+    store.key?(Value.new(:objkey2), :expires => 3).should be_true
+    store[Value.new(:objkey2)].should == {"hashval3"=>["array2", {"hashval4"=>42}]}
+    sleep 1
+    store[Value.new(:objkey2)].should == {"hashval3"=>["array2", {"hashval4"=>42}]}
+    sleep 3
+    store[Value.new(:objkey2)].should == nil
+  end
+
+  it 'should support updating the expiration time in fetch' do
+    store.store(Value.new(:objkey1), {"hashval1"=>["array1", 1]}, :expires => 2)
+    store[Value.new(:objkey1)].should == {"hashval1"=>["array1", 1]}
+    sleep 1
+    store.fetch(Value.new(:objkey1), nil, :expires => 3).should == {"hashval1"=>["array1", 1]}
+    store[Value.new(:objkey1)].should == {"hashval1"=>["array1", 1]}
+    sleep 1
+    store[Value.new(:objkey1)].should == {"hashval1"=>["array1", 1]}
+    sleep 3
+    store[Value.new(:objkey1)].should == nil
+  end
+
+  it 'should respect expires in delete' do
+    store.store(Value.new(:objkey2), {"hashval3"=>["array2", {"hashval4"=>42}]}, :expires => 2)
+    store[Value.new(:objkey2)].should == {"hashval3"=>["array2", {"hashval4"=>42}]}
+    sleep 1
+    store[Value.new(:objkey2)].should == {"hashval3"=>["array2", {"hashval4"=>42}]}
+    sleep 2
+    store.delete(Value.new(:objkey2)).should == nil
+  end
+
+  it 'should support the #expires syntactic sugar' do
+    store['longlive_key'] = 'longlive_value'
+    store.expires(2).store(Value.new(:objkey2), {"hashval3"=>["array2", {"hashval4"=>42}]})
+    store[Value.new(:objkey2)].should == {"hashval3"=>["array2", {"hashval4"=>42}]}
+    sleep 1
+    store[Value.new(:objkey2)].should == {"hashval3"=>["array2", {"hashval4"=>42}]}
+    sleep 2
+    store.delete(Value.new(:objkey2)).should == nil
+    store['longlive_key'].should == 'longlive_value'
+  end
+end
+
+#################### null_objectkey_objectvalue ####################
+
+shared_examples_for 'null_objectkey_objectvalue' do
+  it "reads from keys that are Objects like a Hash" do
+    store[Value.new(:objkey1)].should == nil
+    store.load(Value.new(:objkey1)).should == nil
+  end
+
+  it "guarantees that the same Object value is returned when setting a Object key" do
+    value = Value.new(:objval1)
+    (store[Value.new(:objkey1)] = value).should equal(value)
+  end
+
+  it "returns false from key? if a Object key is not available" do
+    store.key?(Value.new(:objkey1)).should == false
+  end
+
+  it "returns nil from delete if an element for a Object key does not exist" do
+    store.delete(Value.new(:objkey1)).should == nil
+  end
+
+  it "removes all Object keys from the store with clear" do
+    store[Value.new(:objkey1)] = Value.new(:objval1)
+    store[Value.new(:objkey2)] = Value.new(:objval2)
+    store.clear.should equal(store)
+    store.key?(Value.new(:objkey1)).should_not ==  true
+    store.key?(Value.new(:objkey2)).should_not == true
+  end
+
+  it "fetches a Object key with a default value with fetch, if the key is not available" do
+    store.fetch(Value.new(:objkey1), Value.new(:objval1)).should == Value.new(:objval1)
+  end
+
+  it "fetches a Object key with a block with fetch, if the key is not available" do
+    key = Value.new(:objkey1)
+    value = Value.new(:objval1)
+    store.fetch(key) do |k|
+      k.should equal(key)
+      value
+    end.should equal(value)
+  end
+
+  it 'should accept options' do
+    store.key?(Value.new(:objkey1), :option1 => 1).should == false
+    store.load(Value.new(:objkey1), :option2 => 2).should == nil
+    store.fetch(Value.new(:objkey1), 42, :option3 => 3).should == 42
+    store.fetch(Value.new(:objkey1), :option3 => 3) { 42 }.should == 42
+    store.delete(Value.new(:objkey1), :option4 => 4).should == nil
+    store.clear(:option5 => 5).should equal(store)
+    store.store(Value.new(:objkey1), Value.new(:objval1), :option6 => 6).should == Value.new(:objval1)
+  end
+end
+
+#################### store_objectkey_objectvalue ####################
+
+shared_examples_for 'store_objectkey_objectvalue' do
+  it "writes Object values to keys that are Objects like a Hash" do
+    store[Value.new(:objkey1)] = Value.new(:objval1)
+    store[Value.new(:objkey1)].should == Value.new(:objval1)
+    store.load(Value.new(:objkey1)).should == Value.new(:objval1)
+  end
+
+  it "returns true from key? if a Object key is available" do
+    store[Value.new(:objkey1)] = Value.new(:objval1)
+    store.key?(Value.new(:objkey1)).should == true
+    store[Value.new(:objkey2)] = Value.new(:objval2)
+    store.key?(Value.new(:objkey2)).should == true
+  end
+
+  it "stores Object values with Object keys with #store" do
+    value = Value.new(:objval1)
+    store.store(Value.new(:objkey1), value).should equal(value)
+    store[Value.new(:objkey1)].should == Value.new(:objval1)
+    store.load(Value.new(:objkey1)).should == Value.new(:objval1)
+  end
+
+  it "stores Object after clear" do
+    store[Value.new(:objkey1)] = Value.new(:objval1)
+    store[Value.new(:objkey2)] = Value.new(:objval2)
+    store.clear.should equal(store)
+    store[Value.new(:objkey1)] = Value.new(:objval1)
+    store[Value.new(:objkey1)].should == Value.new(:objval1)
+    store[Value.new(:objkey2)].should be_nil
+  end
+
+  it "removes and returns a Object element with a Object key from the backing store via delete if it exists" do
+    store[Value.new(:objkey1)] = Value.new(:objval1)
+    store.delete(Value.new(:objkey1)).should == Value.new(:objval1)
+    store.key?(Value.new(:objkey1)).should == false
+  end
+
+  it "overwrites existing Object values with Object" do
+    store[Value.new(:objkey1)] = Value.new(:objval1)
+    store[Value.new(:objkey1)].should == Value.new(:objval1)
+    store[Value.new(:objkey1)] = Value.new(:objval2)
+    store[Value.new(:objkey1)].should == Value.new(:objval2)
+  end
+
+  it "does not run the block if the Object key is available" do
+    store[Value.new(:objkey1)] = Value.new(:objval1)
+    unaltered = "unaltered"
+    store.fetch(Value.new(:objkey1)) { unaltered = "altered" }
+    unaltered.should == "unaltered"
+  end
+
+  it "fetches a Object key with a default value with fetch, if the key is available" do
+    store[Value.new(:objkey1)] = Value.new(:objval1)
+    store.fetch(Value.new(:objkey1), Value.new(:objval2)).should == Value.new(:objval1)
+  end
+end
+
+#################### returndifferent_objectkey_objectvalue ####################
+
+shared_examples_for 'returndifferent_objectkey_objectvalue' do
+  it "guarantees that a different Object value is retrieved from the Object key" do
+    value = Value.new(:objval1)
+    store[Value.new(:objkey1)] = Value.new(:objval1)
+    store[Value.new(:objkey1)].should_not be_equal(Value.new(:objval1))
+  end
+end
+
+#################### expires_objectkey_objectvalue ####################
+
+shared_examples_for 'expires_objectkey_objectvalue' do
+  it 'should support expires on store and #[]' do
+    store.store(Value.new(:objkey1), Value.new(:objval1), :expires => 2)
+    store[Value.new(:objkey1)].should == Value.new(:objval1)
+    sleep 1
+    store[Value.new(:objkey1)].should == Value.new(:objval1)
+    sleep 2
+    store[Value.new(:objkey1)].should == nil
+  end
+
+  it 'should support expires on store and load' do
+    store.store(Value.new(:objkey1), Value.new(:objval1), :expires => 2)
+    store.load(Value.new(:objkey1)).should == Value.new(:objval1)
+    sleep 1
+    store.load(Value.new(:objkey1)).should == Value.new(:objval1)
+    sleep 2
+    store.load(Value.new(:objkey1)).should == nil
+  end
+
+  it 'should support expires on store and key?' do
+    store.store(Value.new(:objkey1), Value.new(:objval1), :expires => 2)
+    store.key?(Value.new(:objkey1)).should == true
+    sleep 1
+    store.key?(Value.new(:objkey1)).should == true
+    sleep 2
+    store.key?(Value.new(:objkey1)).should == false
+  end
+
+  it 'should support updating the expiration time in load' do
+    store.store(Value.new(:objkey2), Value.new(:objval2), :expires => 2)
+    store[Value.new(:objkey2)].should == Value.new(:objval2)
+    sleep 1
+    store.load(Value.new(:objkey2), :expires => 3).should == Value.new(:objval2)
+    store[Value.new(:objkey2)].should == Value.new(:objval2)
+    sleep 1
+    store[Value.new(:objkey2)].should == Value.new(:objval2)
+    sleep 3
+    store[Value.new(:objkey2)].should == nil
+  end
+
+  it 'should support updating the expiration time in key?' do
+    store.store(Value.new(:objkey2), Value.new(:objval2), :expires => 2)
+    store[Value.new(:objkey2)].should == Value.new(:objval2)
+    sleep 1
+    store.key?(Value.new(:objkey2), :expires => 3).should be_true
+    store[Value.new(:objkey2)].should == Value.new(:objval2)
+    sleep 1
+    store[Value.new(:objkey2)].should == Value.new(:objval2)
+    sleep 3
+    store[Value.new(:objkey2)].should == nil
+  end
+
+  it 'should support updating the expiration time in fetch' do
+    store.store(Value.new(:objkey1), Value.new(:objval1), :expires => 2)
+    store[Value.new(:objkey1)].should == Value.new(:objval1)
+    sleep 1
+    store.fetch(Value.new(:objkey1), nil, :expires => 3).should == Value.new(:objval1)
+    store[Value.new(:objkey1)].should == Value.new(:objval1)
+    sleep 1
+    store[Value.new(:objkey1)].should == Value.new(:objval1)
+    sleep 3
+    store[Value.new(:objkey1)].should == nil
+  end
+
+  it 'should respect expires in delete' do
+    store.store(Value.new(:objkey2), Value.new(:objval2), :expires => 2)
+    store[Value.new(:objkey2)].should == Value.new(:objval2)
+    sleep 1
+    store[Value.new(:objkey2)].should == Value.new(:objval2)
+    sleep 2
+    store.delete(Value.new(:objkey2)).should == nil
+  end
+
+  it 'should support the #expires syntactic sugar' do
+    store['longlive_key'] = 'longlive_value'
+    store.expires(2).store(Value.new(:objkey2), Value.new(:objval2))
+    store[Value.new(:objkey2)].should == Value.new(:objval2)
+    sleep 1
+    store[Value.new(:objkey2)].should == Value.new(:objval2)
+    sleep 2
+    store.delete(Value.new(:objkey2)).should == nil
+    store['longlive_key'].should == 'longlive_value'
+  end
+end
+
+#################### null_hashkey_booleanvalue ####################
+
+shared_examples_for 'null_hashkey_booleanvalue' do
+  it "reads from keys that are Hashs like a Hash" do
+    store[{"hashkey1"=>"hashkey2"}].should == nil
+    store.load({"hashkey1"=>"hashkey2"}).should == nil
+  end
+
+  it "guarantees that the same Boolean value is returned when setting a Hash key" do
+    value = true
+    (store[{"hashkey1"=>"hashkey2"}] = value).should equal(value)
+  end
+
+  it "returns false from key? if a Hash key is not available" do
+    store.key?({"hashkey1"=>"hashkey2"}).should == false
+  end
+
+  it "returns nil from delete if an element for a Hash key does not exist" do
+    store.delete({"hashkey1"=>"hashkey2"}).should == nil
+  end
+
+  it "removes all Hash keys from the store with clear" do
+    store[{"hashkey1"=>"hashkey2"}] = true
+    store[{"hashkey3"=>"hashkey4"}] = false
+    store.clear.should equal(store)
+    store.key?({"hashkey1"=>"hashkey2"}).should_not ==  true
+    store.key?({"hashkey3"=>"hashkey4"}).should_not == true
+  end
+
+  it "fetches a Hash key with a default value with fetch, if the key is not available" do
+    store.fetch({"hashkey1"=>"hashkey2"}, true).should == true
+  end
+
+  it "fetches a Hash key with a block with fetch, if the key is not available" do
+    key = {"hashkey1"=>"hashkey2"}
+    value = true
+    store.fetch(key) do |k|
+      k.should equal(key)
+      value
+    end.should equal(value)
+  end
+
+  it 'should accept options' do
+    store.key?({"hashkey1"=>"hashkey2"}, :option1 => 1).should == false
+    store.load({"hashkey1"=>"hashkey2"}, :option2 => 2).should == nil
+    store.fetch({"hashkey1"=>"hashkey2"}, 42, :option3 => 3).should == 42
+    store.fetch({"hashkey1"=>"hashkey2"}, :option3 => 3) { 42 }.should == 42
+    store.delete({"hashkey1"=>"hashkey2"}, :option4 => 4).should == nil
+    store.clear(:option5 => 5).should equal(store)
+    store.store({"hashkey1"=>"hashkey2"}, true, :option6 => 6).should == true
+  end
+end
+
+#################### store_hashkey_booleanvalue ####################
+
+shared_examples_for 'store_hashkey_booleanvalue' do
+  it "writes Boolean values to keys that are Hashs like a Hash" do
+    store[{"hashkey1"=>"hashkey2"}] = true
+    store[{"hashkey1"=>"hashkey2"}].should == true
+    store.load({"hashkey1"=>"hashkey2"}).should == true
+  end
+
+  it "returns true from key? if a Hash key is available" do
+    store[{"hashkey1"=>"hashkey2"}] = true
+    store.key?({"hashkey1"=>"hashkey2"}).should == true
+    store[{"hashkey3"=>"hashkey4"}] = false
+    store.key?({"hashkey3"=>"hashkey4"}).should == true
+  end
+
+  it "stores Boolean values with Hash keys with #store" do
+    value = true
+    store.store({"hashkey1"=>"hashkey2"}, value).should equal(value)
+    store[{"hashkey1"=>"hashkey2"}].should == true
+    store.load({"hashkey1"=>"hashkey2"}).should == true
+  end
+
+  it "stores Hash after clear" do
+    store[{"hashkey1"=>"hashkey2"}] = true
+    store[{"hashkey3"=>"hashkey4"}] = false
+    store.clear.should equal(store)
+    store[{"hashkey1"=>"hashkey2"}] = true
+    store[{"hashkey1"=>"hashkey2"}].should == true
+    store[{"hashkey3"=>"hashkey4"}].should be_nil
+  end
+
+  it "removes and returns a Boolean element with a Hash key from the backing store via delete if it exists" do
+    store[{"hashkey1"=>"hashkey2"}] = true
+    store.delete({"hashkey1"=>"hashkey2"}).should == true
+    store.key?({"hashkey1"=>"hashkey2"}).should == false
+  end
+
+  it "overwrites existing Boolean values with Hash" do
+    store[{"hashkey1"=>"hashkey2"}] = true
+    store[{"hashkey1"=>"hashkey2"}].should == true
+    store[{"hashkey1"=>"hashkey2"}] = false
+    store[{"hashkey1"=>"hashkey2"}].should == false
+  end
+
+  it "does not run the block if the Hash key is available" do
+    store[{"hashkey1"=>"hashkey2"}] = true
+    unaltered = "unaltered"
+    store.fetch({"hashkey1"=>"hashkey2"}) { unaltered = "altered" }
+    unaltered.should == "unaltered"
+  end
+
+  it "fetches a Hash key with a default value with fetch, if the key is available" do
+    store[{"hashkey1"=>"hashkey2"}] = true
+    store.fetch({"hashkey1"=>"hashkey2"}, false).should == true
+  end
+end
+
+#################### expires_hashkey_booleanvalue ####################
+
+shared_examples_for 'expires_hashkey_booleanvalue' do
+  it 'should support expires on store and #[]' do
+    store.store({"hashkey1"=>"hashkey2"}, true, :expires => 2)
+    store[{"hashkey1"=>"hashkey2"}].should == true
+    sleep 1
+    store[{"hashkey1"=>"hashkey2"}].should == true
+    sleep 2
+    store[{"hashkey1"=>"hashkey2"}].should == nil
+  end
+
+  it 'should support expires on store and load' do
+    store.store({"hashkey1"=>"hashkey2"}, true, :expires => 2)
+    store.load({"hashkey1"=>"hashkey2"}).should == true
+    sleep 1
+    store.load({"hashkey1"=>"hashkey2"}).should == true
+    sleep 2
+    store.load({"hashkey1"=>"hashkey2"}).should == nil
+  end
+
+  it 'should support expires on store and key?' do
+    store.store({"hashkey1"=>"hashkey2"}, true, :expires => 2)
+    store.key?({"hashkey1"=>"hashkey2"}).should == true
+    sleep 1
+    store.key?({"hashkey1"=>"hashkey2"}).should == true
+    sleep 2
+    store.key?({"hashkey1"=>"hashkey2"}).should == false
+  end
+
+  it 'should support updating the expiration time in load' do
+    store.store({"hashkey3"=>"hashkey4"}, false, :expires => 2)
+    store[{"hashkey3"=>"hashkey4"}].should == false
+    sleep 1
+    store.load({"hashkey3"=>"hashkey4"}, :expires => 3).should == false
+    store[{"hashkey3"=>"hashkey4"}].should == false
+    sleep 1
+    store[{"hashkey3"=>"hashkey4"}].should == false
+    sleep 3
+    store[{"hashkey3"=>"hashkey4"}].should == nil
+  end
+
+  it 'should support updating the expiration time in key?' do
+    store.store({"hashkey3"=>"hashkey4"}, false, :expires => 2)
+    store[{"hashkey3"=>"hashkey4"}].should == false
+    sleep 1
+    store.key?({"hashkey3"=>"hashkey4"}, :expires => 3).should be_true
+    store[{"hashkey3"=>"hashkey4"}].should == false
+    sleep 1
+    store[{"hashkey3"=>"hashkey4"}].should == false
+    sleep 3
+    store[{"hashkey3"=>"hashkey4"}].should == nil
+  end
+
+  it 'should support updating the expiration time in fetch' do
+    store.store({"hashkey1"=>"hashkey2"}, true, :expires => 2)
+    store[{"hashkey1"=>"hashkey2"}].should == true
+    sleep 1
+    store.fetch({"hashkey1"=>"hashkey2"}, nil, :expires => 3).should == true
+    store[{"hashkey1"=>"hashkey2"}].should == true
+    sleep 1
+    store[{"hashkey1"=>"hashkey2"}].should == true
+    sleep 3
+    store[{"hashkey1"=>"hashkey2"}].should == nil
+  end
+
+  it 'should respect expires in delete' do
+    store.store({"hashkey3"=>"hashkey4"}, false, :expires => 2)
+    store[{"hashkey3"=>"hashkey4"}].should == false
+    sleep 1
+    store[{"hashkey3"=>"hashkey4"}].should == false
+    sleep 2
+    store.delete({"hashkey3"=>"hashkey4"}).should == nil
+  end
+
+  it 'should support the #expires syntactic sugar' do
+    store['longlive_key'] = 'longlive_value'
+    store.expires(2).store({"hashkey3"=>"hashkey4"}, false)
+    store[{"hashkey3"=>"hashkey4"}].should == false
+    sleep 1
+    store[{"hashkey3"=>"hashkey4"}].should == false
+    sleep 2
+    store.delete({"hashkey3"=>"hashkey4"}).should == nil
+    store['longlive_key'].should == 'longlive_value'
+  end
+end
+
+#################### null_hashkey_stringvalue ####################
+
+shared_examples_for 'null_hashkey_stringvalue' do
+  it "reads from keys that are Hashs like a Hash" do
+    store[{"hashkey1"=>"hashkey2"}].should == nil
+    store.load({"hashkey1"=>"hashkey2"}).should == nil
+  end
+
+  it "guarantees that the same String value is returned when setting a Hash key" do
+    value = "strval1"
+    (store[{"hashkey1"=>"hashkey2"}] = value).should equal(value)
+  end
+
+  it "returns false from key? if a Hash key is not available" do
+    store.key?({"hashkey1"=>"hashkey2"}).should == false
+  end
+
+  it "returns nil from delete if an element for a Hash key does not exist" do
+    store.delete({"hashkey1"=>"hashkey2"}).should == nil
+  end
+
+  it "removes all Hash keys from the store with clear" do
+    store[{"hashkey1"=>"hashkey2"}] = "strval1"
+    store[{"hashkey3"=>"hashkey4"}] = "strval2"
+    store.clear.should equal(store)
+    store.key?({"hashkey1"=>"hashkey2"}).should_not ==  true
+    store.key?({"hashkey3"=>"hashkey4"}).should_not == true
+  end
+
+  it "fetches a Hash key with a default value with fetch, if the key is not available" do
+    store.fetch({"hashkey1"=>"hashkey2"}, "strval1").should == "strval1"
+  end
+
+  it "fetches a Hash key with a block with fetch, if the key is not available" do
+    key = {"hashkey1"=>"hashkey2"}
+    value = "strval1"
+    store.fetch(key) do |k|
+      k.should equal(key)
+      value
+    end.should equal(value)
+  end
+
+  it 'should accept options' do
+    store.key?({"hashkey1"=>"hashkey2"}, :option1 => 1).should == false
+    store.load({"hashkey1"=>"hashkey2"}, :option2 => 2).should == nil
+    store.fetch({"hashkey1"=>"hashkey2"}, 42, :option3 => 3).should == 42
+    store.fetch({"hashkey1"=>"hashkey2"}, :option3 => 3) { 42 }.should == 42
+    store.delete({"hashkey1"=>"hashkey2"}, :option4 => 4).should == nil
+    store.clear(:option5 => 5).should equal(store)
+    store.store({"hashkey1"=>"hashkey2"}, "strval1", :option6 => 6).should == "strval1"
+  end
+end
+
+#################### store_hashkey_stringvalue ####################
+
+shared_examples_for 'store_hashkey_stringvalue' do
+  it "writes String values to keys that are Hashs like a Hash" do
+    store[{"hashkey1"=>"hashkey2"}] = "strval1"
+    store[{"hashkey1"=>"hashkey2"}].should == "strval1"
+    store.load({"hashkey1"=>"hashkey2"}).should == "strval1"
+  end
+
+  it "returns true from key? if a Hash key is available" do
+    store[{"hashkey1"=>"hashkey2"}] = "strval1"
+    store.key?({"hashkey1"=>"hashkey2"}).should == true
+    store[{"hashkey3"=>"hashkey4"}] = "strval2"
+    store.key?({"hashkey3"=>"hashkey4"}).should == true
+  end
+
+  it "stores String values with Hash keys with #store" do
+    value = "strval1"
+    store.store({"hashkey1"=>"hashkey2"}, value).should equal(value)
+    store[{"hashkey1"=>"hashkey2"}].should == "strval1"
+    store.load({"hashkey1"=>"hashkey2"}).should == "strval1"
+  end
+
+  it "stores Hash after clear" do
+    store[{"hashkey1"=>"hashkey2"}] = "strval1"
+    store[{"hashkey3"=>"hashkey4"}] = "strval2"
+    store.clear.should equal(store)
+    store[{"hashkey1"=>"hashkey2"}] = "strval1"
+    store[{"hashkey1"=>"hashkey2"}].should == "strval1"
+    store[{"hashkey3"=>"hashkey4"}].should be_nil
+  end
+
+  it "removes and returns a String element with a Hash key from the backing store via delete if it exists" do
+    store[{"hashkey1"=>"hashkey2"}] = "strval1"
+    store.delete({"hashkey1"=>"hashkey2"}).should == "strval1"
+    store.key?({"hashkey1"=>"hashkey2"}).should == false
+  end
+
+  it "overwrites existing String values with Hash" do
+    store[{"hashkey1"=>"hashkey2"}] = "strval1"
+    store[{"hashkey1"=>"hashkey2"}].should == "strval1"
+    store[{"hashkey1"=>"hashkey2"}] = "strval2"
+    store[{"hashkey1"=>"hashkey2"}].should == "strval2"
+  end
+
+  it "does not run the block if the Hash key is available" do
+    store[{"hashkey1"=>"hashkey2"}] = "strval1"
+    unaltered = "unaltered"
+    store.fetch({"hashkey1"=>"hashkey2"}) { unaltered = "altered" }
+    unaltered.should == "unaltered"
+  end
+
+  it "fetches a Hash key with a default value with fetch, if the key is available" do
+    store[{"hashkey1"=>"hashkey2"}] = "strval1"
+    store.fetch({"hashkey1"=>"hashkey2"}, "strval2").should == "strval1"
+  end
+end
+
+#################### returndifferent_hashkey_stringvalue ####################
+
+shared_examples_for 'returndifferent_hashkey_stringvalue' do
+  it "guarantees that a different String value is retrieved from the Hash key" do
+    value = "strval1"
+    store[{"hashkey1"=>"hashkey2"}] = "strval1"
+    store[{"hashkey1"=>"hashkey2"}].should_not be_equal("strval1")
+  end
+end
+
+#################### expires_hashkey_stringvalue ####################
+
+shared_examples_for 'expires_hashkey_stringvalue' do
+  it 'should support expires on store and #[]' do
+    store.store({"hashkey1"=>"hashkey2"}, "strval1", :expires => 2)
+    store[{"hashkey1"=>"hashkey2"}].should == "strval1"
+    sleep 1
+    store[{"hashkey1"=>"hashkey2"}].should == "strval1"
+    sleep 2
+    store[{"hashkey1"=>"hashkey2"}].should == nil
+  end
+
+  it 'should support expires on store and load' do
+    store.store({"hashkey1"=>"hashkey2"}, "strval1", :expires => 2)
+    store.load({"hashkey1"=>"hashkey2"}).should == "strval1"
+    sleep 1
+    store.load({"hashkey1"=>"hashkey2"}).should == "strval1"
+    sleep 2
+    store.load({"hashkey1"=>"hashkey2"}).should == nil
+  end
+
+  it 'should support expires on store and key?' do
+    store.store({"hashkey1"=>"hashkey2"}, "strval1", :expires => 2)
+    store.key?({"hashkey1"=>"hashkey2"}).should == true
+    sleep 1
+    store.key?({"hashkey1"=>"hashkey2"}).should == true
+    sleep 2
+    store.key?({"hashkey1"=>"hashkey2"}).should == false
+  end
+
+  it 'should support updating the expiration time in load' do
+    store.store({"hashkey3"=>"hashkey4"}, "strval2", :expires => 2)
+    store[{"hashkey3"=>"hashkey4"}].should == "strval2"
+    sleep 1
+    store.load({"hashkey3"=>"hashkey4"}, :expires => 3).should == "strval2"
+    store[{"hashkey3"=>"hashkey4"}].should == "strval2"
+    sleep 1
+    store[{"hashkey3"=>"hashkey4"}].should == "strval2"
+    sleep 3
+    store[{"hashkey3"=>"hashkey4"}].should == nil
+  end
+
+  it 'should support updating the expiration time in key?' do
+    store.store({"hashkey3"=>"hashkey4"}, "strval2", :expires => 2)
+    store[{"hashkey3"=>"hashkey4"}].should == "strval2"
+    sleep 1
+    store.key?({"hashkey3"=>"hashkey4"}, :expires => 3).should be_true
+    store[{"hashkey3"=>"hashkey4"}].should == "strval2"
+    sleep 1
+    store[{"hashkey3"=>"hashkey4"}].should == "strval2"
+    sleep 3
+    store[{"hashkey3"=>"hashkey4"}].should == nil
+  end
+
+  it 'should support updating the expiration time in fetch' do
+    store.store({"hashkey1"=>"hashkey2"}, "strval1", :expires => 2)
+    store[{"hashkey1"=>"hashkey2"}].should == "strval1"
+    sleep 1
+    store.fetch({"hashkey1"=>"hashkey2"}, nil, :expires => 3).should == "strval1"
+    store[{"hashkey1"=>"hashkey2"}].should == "strval1"
+    sleep 1
+    store[{"hashkey1"=>"hashkey2"}].should == "strval1"
+    sleep 3
+    store[{"hashkey1"=>"hashkey2"}].should == nil
+  end
+
+  it 'should respect expires in delete' do
+    store.store({"hashkey3"=>"hashkey4"}, "strval2", :expires => 2)
+    store[{"hashkey3"=>"hashkey4"}].should == "strval2"
+    sleep 1
+    store[{"hashkey3"=>"hashkey4"}].should == "strval2"
+    sleep 2
+    store.delete({"hashkey3"=>"hashkey4"}).should == nil
+  end
+
+  it 'should support the #expires syntactic sugar' do
+    store['longlive_key'] = 'longlive_value'
+    store.expires(2).store({"hashkey3"=>"hashkey4"}, "strval2")
+    store[{"hashkey3"=>"hashkey4"}].should == "strval2"
+    sleep 1
+    store[{"hashkey3"=>"hashkey4"}].should == "strval2"
+    sleep 2
+    store.delete({"hashkey3"=>"hashkey4"}).should == nil
+    store['longlive_key'].should == 'longlive_value'
+  end
+end
+
+#################### null_hashkey_hashvalue ####################
+
+shared_examples_for 'null_hashkey_hashvalue' do
+  it "reads from keys that are Hashs like a Hash" do
+    store[{"hashkey1"=>"hashkey2"}].should == nil
+    store.load({"hashkey1"=>"hashkey2"}).should == nil
+  end
+
+  it "guarantees that the same Hash value is returned when setting a Hash key" do
+    value = {"hashval1"=>["array1", 1]}
+    (store[{"hashkey1"=>"hashkey2"}] = value).should equal(value)
+  end
+
+  it "returns false from key? if a Hash key is not available" do
+    store.key?({"hashkey1"=>"hashkey2"}).should == false
+  end
+
+  it "returns nil from delete if an element for a Hash key does not exist" do
+    store.delete({"hashkey1"=>"hashkey2"}).should == nil
+  end
+
+  it "removes all Hash keys from the store with clear" do
+    store[{"hashkey1"=>"hashkey2"}] = {"hashval1"=>["array1", 1]}
+    store[{"hashkey3"=>"hashkey4"}] = {"hashval3"=>["array2", {"hashval4"=>42}]}
+    store.clear.should equal(store)
+    store.key?({"hashkey1"=>"hashkey2"}).should_not ==  true
+    store.key?({"hashkey3"=>"hashkey4"}).should_not == true
+  end
+
+  it "fetches a Hash key with a default value with fetch, if the key is not available" do
+    store.fetch({"hashkey1"=>"hashkey2"}, {"hashval1"=>["array1", 1]}).should == {"hashval1"=>["array1", 1]}
+  end
+
+  it "fetches a Hash key with a block with fetch, if the key is not available" do
+    key = {"hashkey1"=>"hashkey2"}
+    value = {"hashval1"=>["array1", 1]}
+    store.fetch(key) do |k|
+      k.should equal(key)
+      value
+    end.should equal(value)
+  end
+
+  it 'should accept options' do
+    store.key?({"hashkey1"=>"hashkey2"}, :option1 => 1).should == false
+    store.load({"hashkey1"=>"hashkey2"}, :option2 => 2).should == nil
+    store.fetch({"hashkey1"=>"hashkey2"}, 42, :option3 => 3).should == 42
+    store.fetch({"hashkey1"=>"hashkey2"}, :option3 => 3) { 42 }.should == 42
+    store.delete({"hashkey1"=>"hashkey2"}, :option4 => 4).should == nil
+    store.clear(:option5 => 5).should equal(store)
+    store.store({"hashkey1"=>"hashkey2"}, {"hashval1"=>["array1", 1]}, :option6 => 6).should == {"hashval1"=>["array1", 1]}
+  end
+end
+
+#################### store_hashkey_hashvalue ####################
+
+shared_examples_for 'store_hashkey_hashvalue' do
+  it "writes Hash values to keys that are Hashs like a Hash" do
+    store[{"hashkey1"=>"hashkey2"}] = {"hashval1"=>["array1", 1]}
+    store[{"hashkey1"=>"hashkey2"}].should == {"hashval1"=>["array1", 1]}
+    store.load({"hashkey1"=>"hashkey2"}).should == {"hashval1"=>["array1", 1]}
+  end
+
+  it "returns true from key? if a Hash key is available" do
+    store[{"hashkey1"=>"hashkey2"}] = {"hashval1"=>["array1", 1]}
+    store.key?({"hashkey1"=>"hashkey2"}).should == true
+    store[{"hashkey3"=>"hashkey4"}] = {"hashval3"=>["array2", {"hashval4"=>42}]}
+    store.key?({"hashkey3"=>"hashkey4"}).should == true
+  end
+
+  it "stores Hash values with Hash keys with #store" do
+    value = {"hashval1"=>["array1", 1]}
+    store.store({"hashkey1"=>"hashkey2"}, value).should equal(value)
+    store[{"hashkey1"=>"hashkey2"}].should == {"hashval1"=>["array1", 1]}
+    store.load({"hashkey1"=>"hashkey2"}).should == {"hashval1"=>["array1", 1]}
+  end
+
+  it "stores Hash after clear" do
+    store[{"hashkey1"=>"hashkey2"}] = {"hashval1"=>["array1", 1]}
+    store[{"hashkey3"=>"hashkey4"}] = {"hashval3"=>["array2", {"hashval4"=>42}]}
+    store.clear.should equal(store)
+    store[{"hashkey1"=>"hashkey2"}] = {"hashval1"=>["array1", 1]}
+    store[{"hashkey1"=>"hashkey2"}].should == {"hashval1"=>["array1", 1]}
+    store[{"hashkey3"=>"hashkey4"}].should be_nil
+  end
+
+  it "removes and returns a Hash element with a Hash key from the backing store via delete if it exists" do
+    store[{"hashkey1"=>"hashkey2"}] = {"hashval1"=>["array1", 1]}
+    store.delete({"hashkey1"=>"hashkey2"}).should == {"hashval1"=>["array1", 1]}
+    store.key?({"hashkey1"=>"hashkey2"}).should == false
+  end
+
+  it "overwrites existing Hash values with Hash" do
+    store[{"hashkey1"=>"hashkey2"}] = {"hashval1"=>["array1", 1]}
+    store[{"hashkey1"=>"hashkey2"}].should == {"hashval1"=>["array1", 1]}
+    store[{"hashkey1"=>"hashkey2"}] = {"hashval3"=>["array2", {"hashval4"=>42}]}
+    store[{"hashkey1"=>"hashkey2"}].should == {"hashval3"=>["array2", {"hashval4"=>42}]}
+  end
+
+  it "does not run the block if the Hash key is available" do
+    store[{"hashkey1"=>"hashkey2"}] = {"hashval1"=>["array1", 1]}
+    unaltered = "unaltered"
+    store.fetch({"hashkey1"=>"hashkey2"}) { unaltered = "altered" }
+    unaltered.should == "unaltered"
+  end
+
+  it "fetches a Hash key with a default value with fetch, if the key is available" do
+    store[{"hashkey1"=>"hashkey2"}] = {"hashval1"=>["array1", 1]}
+    store.fetch({"hashkey1"=>"hashkey2"}, {"hashval3"=>["array2", {"hashval4"=>42}]}).should == {"hashval1"=>["array1", 1]}
+  end
+end
+
+#################### returndifferent_hashkey_hashvalue ####################
+
+shared_examples_for 'returndifferent_hashkey_hashvalue' do
+  it "guarantees that a different Hash value is retrieved from the Hash key" do
+    value = {"hashval1"=>["array1", 1]}
+    store[{"hashkey1"=>"hashkey2"}] = {"hashval1"=>["array1", 1]}
+    store[{"hashkey1"=>"hashkey2"}].should_not be_equal({"hashval1"=>["array1", 1]})
+  end
+end
+
+#################### expires_hashkey_hashvalue ####################
+
+shared_examples_for 'expires_hashkey_hashvalue' do
+  it 'should support expires on store and #[]' do
+    store.store({"hashkey1"=>"hashkey2"}, {"hashval1"=>["array1", 1]}, :expires => 2)
+    store[{"hashkey1"=>"hashkey2"}].should == {"hashval1"=>["array1", 1]}
+    sleep 1
+    store[{"hashkey1"=>"hashkey2"}].should == {"hashval1"=>["array1", 1]}
+    sleep 2
+    store[{"hashkey1"=>"hashkey2"}].should == nil
+  end
+
+  it 'should support expires on store and load' do
+    store.store({"hashkey1"=>"hashkey2"}, {"hashval1"=>["array1", 1]}, :expires => 2)
+    store.load({"hashkey1"=>"hashkey2"}).should == {"hashval1"=>["array1", 1]}
+    sleep 1
+    store.load({"hashkey1"=>"hashkey2"}).should == {"hashval1"=>["array1", 1]}
+    sleep 2
+    store.load({"hashkey1"=>"hashkey2"}).should == nil
+  end
+
+  it 'should support expires on store and key?' do
+    store.store({"hashkey1"=>"hashkey2"}, {"hashval1"=>["array1", 1]}, :expires => 2)
+    store.key?({"hashkey1"=>"hashkey2"}).should == true
+    sleep 1
+    store.key?({"hashkey1"=>"hashkey2"}).should == true
+    sleep 2
+    store.key?({"hashkey1"=>"hashkey2"}).should == false
+  end
+
+  it 'should support updating the expiration time in load' do
+    store.store({"hashkey3"=>"hashkey4"}, {"hashval3"=>["array2", {"hashval4"=>42}]}, :expires => 2)
+    store[{"hashkey3"=>"hashkey4"}].should == {"hashval3"=>["array2", {"hashval4"=>42}]}
+    sleep 1
+    store.load({"hashkey3"=>"hashkey4"}, :expires => 3).should == {"hashval3"=>["array2", {"hashval4"=>42}]}
+    store[{"hashkey3"=>"hashkey4"}].should == {"hashval3"=>["array2", {"hashval4"=>42}]}
+    sleep 1
+    store[{"hashkey3"=>"hashkey4"}].should == {"hashval3"=>["array2", {"hashval4"=>42}]}
+    sleep 3
+    store[{"hashkey3"=>"hashkey4"}].should == nil
+  end
+
+  it 'should support updating the expiration time in key?' do
+    store.store({"hashkey3"=>"hashkey4"}, {"hashval3"=>["array2", {"hashval4"=>42}]}, :expires => 2)
+    store[{"hashkey3"=>"hashkey4"}].should == {"hashval3"=>["array2", {"hashval4"=>42}]}
+    sleep 1
+    store.key?({"hashkey3"=>"hashkey4"}, :expires => 3).should be_true
+    store[{"hashkey3"=>"hashkey4"}].should == {"hashval3"=>["array2", {"hashval4"=>42}]}
+    sleep 1
+    store[{"hashkey3"=>"hashkey4"}].should == {"hashval3"=>["array2", {"hashval4"=>42}]}
+    sleep 3
+    store[{"hashkey3"=>"hashkey4"}].should == nil
+  end
+
+  it 'should support updating the expiration time in fetch' do
+    store.store({"hashkey1"=>"hashkey2"}, {"hashval1"=>["array1", 1]}, :expires => 2)
+    store[{"hashkey1"=>"hashkey2"}].should == {"hashval1"=>["array1", 1]}
+    sleep 1
+    store.fetch({"hashkey1"=>"hashkey2"}, nil, :expires => 3).should == {"hashval1"=>["array1", 1]}
+    store[{"hashkey1"=>"hashkey2"}].should == {"hashval1"=>["array1", 1]}
+    sleep 1
+    store[{"hashkey1"=>"hashkey2"}].should == {"hashval1"=>["array1", 1]}
+    sleep 3
+    store[{"hashkey1"=>"hashkey2"}].should == nil
+  end
+
+  it 'should respect expires in delete' do
+    store.store({"hashkey3"=>"hashkey4"}, {"hashval3"=>["array2", {"hashval4"=>42}]}, :expires => 2)
+    store[{"hashkey3"=>"hashkey4"}].should == {"hashval3"=>["array2", {"hashval4"=>42}]}
+    sleep 1
+    store[{"hashkey3"=>"hashkey4"}].should == {"hashval3"=>["array2", {"hashval4"=>42}]}
+    sleep 2
+    store.delete({"hashkey3"=>"hashkey4"}).should == nil
+  end
+
+  it 'should support the #expires syntactic sugar' do
+    store['longlive_key'] = 'longlive_value'
+    store.expires(2).store({"hashkey3"=>"hashkey4"}, {"hashval3"=>["array2", {"hashval4"=>42}]})
+    store[{"hashkey3"=>"hashkey4"}].should == {"hashval3"=>["array2", {"hashval4"=>42}]}
+    sleep 1
+    store[{"hashkey3"=>"hashkey4"}].should == {"hashval3"=>["array2", {"hashval4"=>42}]}
+    sleep 2
+    store.delete({"hashkey3"=>"hashkey4"}).should == nil
+    store['longlive_key'].should == 'longlive_value'
+  end
+end
+
+#################### null_hashkey_objectvalue ####################
+
+shared_examples_for 'null_hashkey_objectvalue' do
+  it "reads from keys that are Hashs like a Hash" do
+    store[{"hashkey1"=>"hashkey2"}].should == nil
+    store.load({"hashkey1"=>"hashkey2"}).should == nil
+  end
+
+  it "guarantees that the same Object value is returned when setting a Hash key" do
+    value = Value.new(:objval1)
+    (store[{"hashkey1"=>"hashkey2"}] = value).should equal(value)
+  end
+
+  it "returns false from key? if a Hash key is not available" do
+    store.key?({"hashkey1"=>"hashkey2"}).should == false
+  end
+
+  it "returns nil from delete if an element for a Hash key does not exist" do
+    store.delete({"hashkey1"=>"hashkey2"}).should == nil
+  end
+
+  it "removes all Hash keys from the store with clear" do
+    store[{"hashkey1"=>"hashkey2"}] = Value.new(:objval1)
+    store[{"hashkey3"=>"hashkey4"}] = Value.new(:objval2)
+    store.clear.should equal(store)
+    store.key?({"hashkey1"=>"hashkey2"}).should_not ==  true
+    store.key?({"hashkey3"=>"hashkey4"}).should_not == true
+  end
+
+  it "fetches a Hash key with a default value with fetch, if the key is not available" do
+    store.fetch({"hashkey1"=>"hashkey2"}, Value.new(:objval1)).should == Value.new(:objval1)
+  end
+
+  it "fetches a Hash key with a block with fetch, if the key is not available" do
+    key = {"hashkey1"=>"hashkey2"}
+    value = Value.new(:objval1)
+    store.fetch(key) do |k|
+      k.should equal(key)
+      value
+    end.should equal(value)
+  end
+
+  it 'should accept options' do
+    store.key?({"hashkey1"=>"hashkey2"}, :option1 => 1).should == false
+    store.load({"hashkey1"=>"hashkey2"}, :option2 => 2).should == nil
+    store.fetch({"hashkey1"=>"hashkey2"}, 42, :option3 => 3).should == 42
+    store.fetch({"hashkey1"=>"hashkey2"}, :option3 => 3) { 42 }.should == 42
+    store.delete({"hashkey1"=>"hashkey2"}, :option4 => 4).should == nil
+    store.clear(:option5 => 5).should equal(store)
+    store.store({"hashkey1"=>"hashkey2"}, Value.new(:objval1), :option6 => 6).should == Value.new(:objval1)
+  end
+end
+
+#################### store_hashkey_objectvalue ####################
+
+shared_examples_for 'store_hashkey_objectvalue' do
+  it "writes Object values to keys that are Hashs like a Hash" do
+    store[{"hashkey1"=>"hashkey2"}] = Value.new(:objval1)
+    store[{"hashkey1"=>"hashkey2"}].should == Value.new(:objval1)
+    store.load({"hashkey1"=>"hashkey2"}).should == Value.new(:objval1)
+  end
+
+  it "returns true from key? if a Hash key is available" do
+    store[{"hashkey1"=>"hashkey2"}] = Value.new(:objval1)
+    store.key?({"hashkey1"=>"hashkey2"}).should == true
+    store[{"hashkey3"=>"hashkey4"}] = Value.new(:objval2)
+    store.key?({"hashkey3"=>"hashkey4"}).should == true
+  end
+
+  it "stores Object values with Hash keys with #store" do
+    value = Value.new(:objval1)
+    store.store({"hashkey1"=>"hashkey2"}, value).should equal(value)
+    store[{"hashkey1"=>"hashkey2"}].should == Value.new(:objval1)
+    store.load({"hashkey1"=>"hashkey2"}).should == Value.new(:objval1)
+  end
+
+  it "stores Hash after clear" do
+    store[{"hashkey1"=>"hashkey2"}] = Value.new(:objval1)
+    store[{"hashkey3"=>"hashkey4"}] = Value.new(:objval2)
+    store.clear.should equal(store)
+    store[{"hashkey1"=>"hashkey2"}] = Value.new(:objval1)
+    store[{"hashkey1"=>"hashkey2"}].should == Value.new(:objval1)
+    store[{"hashkey3"=>"hashkey4"}].should be_nil
+  end
+
+  it "removes and returns a Object element with a Hash key from the backing store via delete if it exists" do
+    store[{"hashkey1"=>"hashkey2"}] = Value.new(:objval1)
+    store.delete({"hashkey1"=>"hashkey2"}).should == Value.new(:objval1)
+    store.key?({"hashkey1"=>"hashkey2"}).should == false
+  end
+
+  it "overwrites existing Object values with Hash" do
+    store[{"hashkey1"=>"hashkey2"}] = Value.new(:objval1)
+    store[{"hashkey1"=>"hashkey2"}].should == Value.new(:objval1)
+    store[{"hashkey1"=>"hashkey2"}] = Value.new(:objval2)
+    store[{"hashkey1"=>"hashkey2"}].should == Value.new(:objval2)
+  end
+
+  it "does not run the block if the Hash key is available" do
+    store[{"hashkey1"=>"hashkey2"}] = Value.new(:objval1)
+    unaltered = "unaltered"
+    store.fetch({"hashkey1"=>"hashkey2"}) { unaltered = "altered" }
+    unaltered.should == "unaltered"
+  end
+
+  it "fetches a Hash key with a default value with fetch, if the key is available" do
+    store[{"hashkey1"=>"hashkey2"}] = Value.new(:objval1)
+    store.fetch({"hashkey1"=>"hashkey2"}, Value.new(:objval2)).should == Value.new(:objval1)
+  end
+end
+
+#################### returndifferent_hashkey_objectvalue ####################
+
+shared_examples_for 'returndifferent_hashkey_objectvalue' do
+  it "guarantees that a different Object value is retrieved from the Hash key" do
+    value = Value.new(:objval1)
+    store[{"hashkey1"=>"hashkey2"}] = Value.new(:objval1)
+    store[{"hashkey1"=>"hashkey2"}].should_not be_equal(Value.new(:objval1))
+  end
+end
+
+#################### expires_hashkey_objectvalue ####################
+
+shared_examples_for 'expires_hashkey_objectvalue' do
+  it 'should support expires on store and #[]' do
+    store.store({"hashkey1"=>"hashkey2"}, Value.new(:objval1), :expires => 2)
+    store[{"hashkey1"=>"hashkey2"}].should == Value.new(:objval1)
+    sleep 1
+    store[{"hashkey1"=>"hashkey2"}].should == Value.new(:objval1)
+    sleep 2
+    store[{"hashkey1"=>"hashkey2"}].should == nil
+  end
+
+  it 'should support expires on store and load' do
+    store.store({"hashkey1"=>"hashkey2"}, Value.new(:objval1), :expires => 2)
+    store.load({"hashkey1"=>"hashkey2"}).should == Value.new(:objval1)
+    sleep 1
+    store.load({"hashkey1"=>"hashkey2"}).should == Value.new(:objval1)
+    sleep 2
+    store.load({"hashkey1"=>"hashkey2"}).should == nil
+  end
+
+  it 'should support expires on store and key?' do
+    store.store({"hashkey1"=>"hashkey2"}, Value.new(:objval1), :expires => 2)
+    store.key?({"hashkey1"=>"hashkey2"}).should == true
+    sleep 1
+    store.key?({"hashkey1"=>"hashkey2"}).should == true
+    sleep 2
+    store.key?({"hashkey1"=>"hashkey2"}).should == false
+  end
+
+  it 'should support updating the expiration time in load' do
+    store.store({"hashkey3"=>"hashkey4"}, Value.new(:objval2), :expires => 2)
+    store[{"hashkey3"=>"hashkey4"}].should == Value.new(:objval2)
+    sleep 1
+    store.load({"hashkey3"=>"hashkey4"}, :expires => 3).should == Value.new(:objval2)
+    store[{"hashkey3"=>"hashkey4"}].should == Value.new(:objval2)
+    sleep 1
+    store[{"hashkey3"=>"hashkey4"}].should == Value.new(:objval2)
+    sleep 3
+    store[{"hashkey3"=>"hashkey4"}].should == nil
+  end
+
+  it 'should support updating the expiration time in key?' do
+    store.store({"hashkey3"=>"hashkey4"}, Value.new(:objval2), :expires => 2)
+    store[{"hashkey3"=>"hashkey4"}].should == Value.new(:objval2)
+    sleep 1
+    store.key?({"hashkey3"=>"hashkey4"}, :expires => 3).should be_true
+    store[{"hashkey3"=>"hashkey4"}].should == Value.new(:objval2)
+    sleep 1
+    store[{"hashkey3"=>"hashkey4"}].should == Value.new(:objval2)
+    sleep 3
+    store[{"hashkey3"=>"hashkey4"}].should == nil
+  end
+
+  it 'should support updating the expiration time in fetch' do
+    store.store({"hashkey1"=>"hashkey2"}, Value.new(:objval1), :expires => 2)
+    store[{"hashkey1"=>"hashkey2"}].should == Value.new(:objval1)
+    sleep 1
+    store.fetch({"hashkey1"=>"hashkey2"}, nil, :expires => 3).should == Value.new(:objval1)
+    store[{"hashkey1"=>"hashkey2"}].should == Value.new(:objval1)
+    sleep 1
+    store[{"hashkey1"=>"hashkey2"}].should == Value.new(:objval1)
+    sleep 3
+    store[{"hashkey1"=>"hashkey2"}].should == nil
+  end
+
+  it 'should respect expires in delete' do
+    store.store({"hashkey3"=>"hashkey4"}, Value.new(:objval2), :expires => 2)
+    store[{"hashkey3"=>"hashkey4"}].should == Value.new(:objval2)
+    sleep 1
+    store[{"hashkey3"=>"hashkey4"}].should == Value.new(:objval2)
+    sleep 2
+    store.delete({"hashkey3"=>"hashkey4"}).should == nil
+  end
+
+  it 'should support the #expires syntactic sugar' do
+    store['longlive_key'] = 'longlive_value'
+    store.expires(2).store({"hashkey3"=>"hashkey4"}, Value.new(:objval2))
+    store[{"hashkey3"=>"hashkey4"}].should == Value.new(:objval2)
+    sleep 1
+    store[{"hashkey3"=>"hashkey4"}].should == Value.new(:objval2)
+    sleep 2
+    store.delete({"hashkey3"=>"hashkey4"}).should == nil
+    store['longlive_key'].should == 'longlive_value'
+  end
+end
+
+#################### not_increment ####################
+
+shared_examples_for 'not_increment' do
+  it 'should not support increment' do
+    expect do
+      store.increment('inckey')
+    end.to raise_error(NotImplementedError)
+  end
+end
+
+#################### increment ####################
+
+shared_examples_for 'increment' do
+  it 'should initialize in increment with 1' do
+    store.key?('inckey').should be_false
+    store.increment('inckey').should == 1
+    store.key?('inckey').should be_true
+    store.raw['inckey'].should == '1'
+    store.raw.load('inckey').should == '1'
+    store.load('inckey', :raw => true).should == '1'
+    store['inckey'].should == '1'
+
+    store.delete('inckey', :raw => true).should == '1'
+    store.key?('inckey').should be_false
+  end
+
+  it 'should initialize in increment with higher value' do
+    store.increment('inckey', 42).should == 42
+    store.key?('inckey').should be_true
+    store.raw['inckey'].should == '42'
+    store['inckey'].should == '42'
+    store.delete('inckey', :raw => true).should == '42'
+  end
+
+  it 'should initialize in increment with 0' do
+    store.increment('inckey', 0).should == 0
+    store.key?('inckey').should be_true
+    store.raw['inckey'].should == '0'
+    store['inckey'].should == '0'
+    store.delete('inckey', :raw => true).should == '0'
+  end
+
+  it 'should support incrementing existing value by value' do
+    store.increment('inckey').should == 1
+    store.increment('inckey', 42).should == 43
+    store.raw['inckey'].should == '43'
+  end
+
+  it 'should support incrementing existing value by 0' do
+    store.increment('inckey').should == 1
+    store.increment('inckey', 0).should == 1
+    store.raw['inckey'].should == '1'
+  end
+
+  it 'should support deleting integer value' do
+    store.increment('inckey').should == 1
+    store.delete('inckey').should == '1'
+    store.key?('inckey').should be_false
+  end
+
+  it 'should support decrementing existing value' do
+    store.increment('inckey', 10).should == 10
+    store.increment('inckey', -5).should == 5
+    store.raw['inckey'].should == '5'
+    store.increment('inckey', -5).should == 0
+    store.raw['inckey'].should == '0'
+  end
+
+  it 'interpret raw value as integer' do
+    store.store('inckey', '42', :raw => true)
+    store.increment('inckey').should == 43
+    store.raw['inckey'].should == '43'
+  end
+
+  it 'should raise error on non integer value' do
+    store['strkey'] = 'value'
+    expect do
+      store.increment('strkey')
+    end.to raise_error
+  end
+end
+
+#################### marshallable_key ####################
+
+shared_examples_for 'marshallable_key' do
+  it 'refuses to #[] from keys that cannot be marshalled' do
+    expect do
+      store[Struct.new(:foo).new(:bar)]
+    end.to raise_error(marshal_error)
+  end
+
+  it 'refuses to load from keys that cannot be marshalled' do
+    expect do
+      store.load(Struct.new(:foo).new(:bar))
+    end.to raise_error(marshal_error)
+  end
+
+  it 'refuses to fetch from keys that cannot be marshalled' do
+    expect do
+      store.fetch(Struct.new(:foo).new(:bar), true)
+    end.to raise_error(marshal_error)
+  end
+
+  it 'refuses to #[]= to keys that cannot be marshalled' do
+    expect do
+      store[Struct.new(:foo).new(:bar)] = 'value'
+    end.to raise_error(marshal_error)
+  end
+
+  it 'refuses to store to keys that cannot be marshalled' do
+    expect do
+      store.store Struct.new(:foo).new(:bar), 'value'
+    end.to raise_error(marshal_error)
+  end
+
+  it 'refuses to check for key? if the key cannot be marshalled' do
+    expect do
+      store.key? Struct.new(:foo).new(:bar)
+    end.to raise_error(marshal_error)
+  end
+
+  it 'refuses to delete a key if the key cannot be marshalled' do
+    expect do
+      store.delete Struct.new(:foo).new(:bar)
+    end.to raise_error(marshal_error)
+  end
+end
+
+#################### marshallable_value ####################
+
+shared_examples_for 'marshallable_value' do
+  it 'refuses to store values that cannot be marshalled' do
+    expect do
+      store.store 'key', Struct.new(:foo).new(:bar)
+    end.to raise_error(marshal_error)
+  end
+end
+
+#################### transform_value ####################
+
+shared_examples_for 'transform_value' do
+  it 'allows to bypass transformer with :raw' do
+    store['key'] = 'value'
+    load_value(store.load('key', :raw => true)).should == 'value'
+
+    store.store('key', 'value', :raw => true)
+    store.load('key', :raw => true).should == 'value'
+    store.delete('key', :raw => true).should == 'value'
+  end
+
+  it 'allows to bypass transformer with raw syntactic sugar' do
+    store['key'] = 'value'
+    load_value(store.raw.load('key')).should == 'value'
+
+    store.raw.store('key', 'value')
+    store.raw['key'].should == 'value'
+    store.raw.load('key').should == 'value'
+    store.raw.delete('key').should == 'value'
+
+    store.raw['key'] = 'value2'
+    store.raw['key'].should == 'value2'
+  end
+
+  it 'should return unmarshalled value' do
+    store.store('key', 'unmarshalled value', :raw => true)
+    store.load('key', :raw => true).should == 'unmarshalled value'
+    store['key'].should == 'unmarshalled value'
+    store.delete('key').should == 'unmarshalled value'
+  end
+end
+
+#################### transform_value_with_expires ####################
+
+shared_examples_for 'transform_value_with_expires' do
+  it 'allows to bypass transformer with :raw' do
+    store['key'] = 'value'
+    load_value(store.load('key', :raw => true)).should == ['value']
+
+    store.store('key', 'value', :expires => 10)
+    load_value(store.load('key', :raw => true)).first.should == 'value'
+    load_value(store.load('key', :raw => true)).last.should respond_to(:to_int)
+
+    store.store('key', 'value', :raw => true)
+    store.load('key', :raw => true).should == 'value'
+    store.delete('key', :raw => true).should == 'value'
+  end
+
+  it 'should return unmarshalled value' do
+    store.store('key', 'unmarshalled value', :raw => true)
+    store.load('key', :raw => true).should == 'unmarshalled value'
+    store['key'].should == 'unmarshalled value'
+    store.delete('key').should == 'unmarshalled value'
+  end
+end
+