bihash 1.2.0 → 2.0.0

data/spec/bihash_spec.rb

@@ -2,244 +2,380 @@ require 'spec_helper'
 
 describe Bihash do
   it 'should be enumerable' do
-    Bihash.must_include Enumerable
+    _(Bihash).must_include Enumerable
+  end
+
+  Bihash::UNIMPLEMENTED_CLASS_METHODS.each do |method|
+    it "should report that it does not respond to ::#{method}" do
+      _(Bihash.respond_to?(method)).must_equal false
+    end
+
+    it "should raise NoMethodError if ::#{method} is called" do
+      error = _(-> { Bihash.send(method) }).must_raise NoMethodError
+      _(error.message).must_equal "Bihash::#{method} not implemented"
+    end
   end
 
   Bihash::UNIMPLEMENTED_METHODS.each do |method|
     it "should report that it does not respond to ##{method}" do
-      Bihash.new.respond_to?(method).must_equal false
+      _(Bihash.new.respond_to?(method)).must_equal false
     end
 
     it "should raise NoMethodError if ##{method} is called" do
-      error = -> { Bihash.new.send(method) }.must_raise NoMethodError
-      error.message.must_equal "Bihash##{method} not implemented"
+      error = _(-> { Bihash.new.send(method) }).must_raise NoMethodError
+      _(error.message).must_equal "Bihash##{method} not implemented"
     end
   end
 
   describe '::[]' do
     it 'should be able to create an empty bihash' do
       bh = Bihash[]
-      bh.must_be_instance_of Bihash
-      bh.must_be_empty
+      _(bh).must_be_instance_of Bihash
+      _(bh).must_be_empty
     end
 
     it 'should convert a hash to a bihash' do
       bh = Bihash[:key => 'value']
-      bh.must_be_instance_of Bihash
-      bh[:key].must_equal 'value'
-      bh['value'].must_equal :key
+      _(bh).must_be_instance_of Bihash
+      _(bh[:key]).must_equal 'value'
+      _(bh['value']).must_equal :key
+    end
+
+    it 'should not carry over the default value' do
+      h = Hash.new(404)
+      bh = Bihash[h]
+      _(bh.default).must_be_nil
+      _(bh[:not_a_key]).must_be_nil
+    end
+
+    it 'should not carry over the default_proc' do
+      h = Hash.new { "#{_2} not found" }
+      bh = Bihash[h]
+      _(bh.default_proc).must_be_nil
+      _(bh[:not_a_key]).must_be_nil
+    end
+
+    it 'should not carry over compare_by_identity' do
+      h = Hash.new.compare_by_identity
+      h[Array.new] = :array
+      bh = Bihash[h]
+      _(bh.compare_by_identity?).must_equal false
+      _(bh[Array.new]).must_equal :array
     end
 
     it 'should not accept a hash with duplicate values' do
-      -> { Bihash[:k1 => 'val', :k2 => 'val'] }.must_raise ArgumentError
+      _(-> { Bihash[:k1 => 'val', :k2 => 'val'] }).must_raise ArgumentError
     end
 
     it 'should not accept a hash that would result in ambiguous mappings' do
-      -> { Bihash[1, 2, 2, 3] }.must_raise ArgumentError
+      _(-> { Bihash[1, 2, 2, 3] }).must_raise ArgumentError
+    end
+
+    it 'should not accept a hash that has ambiguous mappings that are ==' do
+      _(-> { Bihash[1, 1.0, 1.0, :anything]}).must_raise ArgumentError
     end
 
     it 'should accept a hash where a key equals its value' do
       bh = Bihash[:key => :key]
-      bh.must_be_instance_of Bihash
-      bh[:key].must_equal :key
+      _(bh).must_be_instance_of Bihash
+      _(bh[:key]).must_equal :key
     end
 
     it 'should always return the value object if key-value pairs are equal' do
       key, value = [], []
       bh = Bihash[key => value]
-      bh.must_be_instance_of Bihash
-      bh[key].object_id.must_equal value.object_id
-      bh[value].object_id.must_equal value.object_id
+      _(bh).must_be_instance_of Bihash
+      _(bh[key].object_id).must_equal value.object_id
+      _(bh[value].object_id).must_equal value.object_id
     end
 
     it 'should accept an even number of arguments' do
       bh = Bihash[:k1, 1, :k2, 2]
-      bh.must_be_instance_of Bihash
-      bh[:k1].must_equal 1
-      bh[:k2].must_equal 2
-      bh[1].must_equal :k1
-      bh[2].must_equal :k2
+      _(bh).must_be_instance_of Bihash
+      _(bh[:k1]).must_equal 1
+      _(bh[:k2]).must_equal 2
+      _(bh[1]).must_equal :k1
+      _(bh[2]).must_equal :k2
     end
 
     it 'should accept an array of key-value pairs packaged in arrays' do
       array = [[:k1, 1], [:k2, 2]]
       bh = Bihash[array]
-      bh.must_be_instance_of Bihash
-      bh[:k1].must_equal 1
-      bh[:k2].must_equal 2
-      bh[1].must_equal :k1
-      bh[2].must_equal :k2
+      _(bh).must_be_instance_of Bihash
+      _(bh[:k1]).must_equal 1
+      _(bh[:k2]).must_equal 2
+      _(bh[1]).must_equal :k1
+      _(bh[2]).must_equal :k2
     end
   end
 
   describe '::new' do
     it 'should create an empty bihash with a default of nil if no args' do
       bh = Bihash.new
-      bh.must_be_instance_of Bihash
-      bh.must_be_empty
-      bh[:not_a_key].must_be_nil
+      _(bh).must_be_instance_of Bihash
+      _(bh).must_be_empty
+      _(bh[:not_a_key]).must_be_nil
     end
 
     it 'should create an empty bihash with a default if given an object arg' do
-      bh = Bihash.new('default')
-      bh.must_be_instance_of Bihash
-      bh.must_be_empty
-      bh[:not_a_key].must_equal 'default'
-      bh[:not_a_key].tr!('ealt', '3417')
-      bh[:still_not_a_key].must_equal 'd3f4u17'
+      bh = Bihash.new(['default'])
+      _(bh).must_be_instance_of Bihash
+      _(bh).must_be_empty
+      _(bh[:not_a_key]).must_equal ['default']
+      bh[:not_a_key] << 'pwned'
+      _(bh[:still_not_a_key]).must_equal ['default', 'pwned']
     end
 
     it 'should create an empty bihash with a default if given a block arg' do
-      bh = Bihash.new { 'd3f4u17' }
-      bh.must_be_instance_of Bihash
-      bh.must_be_empty
-      bh[:not_a_key].must_equal 'd3f4u17'
-      bh[:not_a_key].tr!('3417', 'ealt')
-      bh[:not_a_key].must_equal 'd3f4u17'
+      bh = Bihash.new { ['default'] }
+      _(bh).must_be_instance_of Bihash
+      _(bh).must_be_empty
+      _(bh[:not_a_key]).must_equal ['default']
+      bh[:not_a_key] << '(not) pwned'
+      _(bh[:not_a_key]).must_equal ['default']
     end
 
     it 'should allow assignment of new pairs if given a block arg' do
       bh = Bihash.new { |bihash, key| bihash[key] = key.to_s }
-      bh[404].must_equal '404'
-      bh.size.must_equal 1
-      bh.must_include 404
-      bh.must_include '404'
+      _(bh[404]).must_equal '404'
+      _(bh.size).must_equal 1
+      _(bh).must_include 404
+      _(bh).must_include '404'
+    end
+
+    it 'should accept capacity as an optimization with and without defaults' do
+      bh1 = Bihash.new(capacity: 42)
+      _(bh1[:not_a_key]).must_be_nil
+
+      bh2 = Bihash.new(404, capacity: 42)
+      _(bh2[:not_a_key]).must_equal 404
+
+      bh3 = Bihash.new(capacity: 42) { "#{_2} not found" }
+      _(bh3[404]).must_equal '404 not found'
+    end
+
+    it 'should not accept arbitrary keyword arguments' do
+      _(-> { Bihash.new(keywords: true) }).must_raise ArgumentError
+    end
+
+    it 'should accept a default that is a hash' do
+      bh = Bihash.new({hash: true})
+      _(bh[:not_a_key]).must_equal({hash: true})
     end
 
     it 'should not accept both an object and a block' do
-      -> { Bihash.new('default 1') { 'default 2' } }.must_raise ArgumentError
+      _(-> { Bihash.new('default 1') { 'default 2' } }).must_raise ArgumentError
     end
   end
 
   describe '::try_convert' do
+    it 'should return the bihash if given a bihash' do
+      original_bh = Bihash[:key => 'value']
+      returned_bh = Bihash.try_convert(original_bh)
+      _(original_bh.object_id).must_equal returned_bh.object_id
+    end
+
     it 'should convert an object to a bihash if it responds to #to_hash' do
       hash = {:k1 => 1, :k2 => 2}
       bh = Bihash.try_convert(hash)
-      bh.must_be_instance_of Bihash
-      bh[:k1].must_equal 1
-      bh[:k2].must_equal 2
-      bh[1].must_equal :k1
-      bh[2].must_equal :k2
+      _(bh).must_be_instance_of Bihash
+      _(bh[:k1]).must_equal 1
+      _(bh[:k2]).must_equal 2
+      _(bh[1]).must_equal :k1
+      _(bh[2]).must_equal :k2
     end
 
-    it 'should convert a bihash to a bihash' do
-      bh = Bihash[:key => 'value']
-      Bihash.try_convert(bh).must_equal bh
+    it 'should return nil if the object does not respond to #to_hash' do
+      _(Bihash.try_convert(Object.new)).must_be_nil
     end
 
-    it 'should return nil if the object does not respond to #to_hash' do
-      Bihash.try_convert(Object.new).must_be_nil
+    it 'should protect against mutations the original object' do
+      hash = {:k1 => 1, :k2 => 2}
+      bh = Bihash.try_convert(hash)
+      hash[:k3] = 3
+      _(bh).must_equal Bihash[:k1 => 1, :k2 => 2]
+      _(bh.include?(:k3)).must_equal false
+      _(bh.include?(3)).must_equal false
+    end
+
+    it 'should not carry over the default value' do
+      h = Hash.new(404)
+      bh = Bihash.try_convert(h)
+      _(bh.default).must_be_nil
+      _(bh[:not_a_key]).must_be_nil
+    end
+
+    it 'should not carry over the default_proc' do
+      h = Hash.new { "#{_2} not found" }
+      bh = Bihash.try_convert(h)
+      _(bh.default_proc).must_be_nil
+      _(bh[:not_a_key]).must_be_nil
+    end
+
+    it 'should not carry over compare_by_identity' do
+      h = Hash.new.compare_by_identity
+      h[Array.new] = :array
+      bh = Bihash.try_convert(h)
+      _(bh.compare_by_identity?).must_equal false
+      _(bh[Array.new]).must_equal :array
     end
 
     it 'should not accept a hash with duplicate values' do
-      -> { Bihash.try_convert(:k1 => 1, :k2 => 1) }.must_raise ArgumentError
+      _(-> { Bihash.try_convert(:k1 => 1, :k2 => 1) }).must_raise ArgumentError
     end
   end
 
   describe '#<' do
     it 'should raise an error if the right hand side is not a bihash' do
-      -> { Bihash[a: 1, b: 2] < {a: 1, b: 2, c: 3} }.must_raise TypeError
+      _(-> { Bihash[a: 1, b: 2] < {a: 1, b: 2, c: 3} }).must_raise TypeError
     end
 
     it 'should return true when the argument is a strict subset of self' do
-      (Bihash[a: 1, b: 2] < Bihash[a: 1, b: 2, c: 3]).must_equal true
+      _(Bihash[a: 1, b: 2] < Bihash[a: 1, b: 2, c: 3]).must_equal true
     end
 
     it 'should return false when the argument is equal to self' do
-      (Bihash[a: 1, b: 2] < Bihash[a: 1, b: 2]).must_equal false
+      _(Bihash[a: 1, b: 2] < Bihash[a: 1, b: 2]).must_equal false
     end
 
     it 'should return false when the argument is not a subset of self' do
-      (Bihash[a: 1, b: 2, c: 3] < Bihash[a: 1, b: 2]).must_equal false
+      _(Bihash[a: 1, b: 2, c: 3] < Bihash[a: 1, b: 2]).must_equal false
     end
   end
 
   describe '#<=' do
     it 'should raise an error if the right hand side is not a bihash' do
-      -> { Bihash[a: 1, b: 2] <= {a: 1, b: 2, c: 3} }.must_raise TypeError
+      _(-> { Bihash[a: 1, b: 2] <= {a: 1, b: 2, c: 3} }).must_raise TypeError
     end
 
     it 'should return true when the argument is a strict subset of self' do
-      (Bihash[a: 1, b: 2] <= Bihash[a: 1, b: 2, c: 3]).must_equal true
+      _(Bihash[a: 1, b: 2] <= Bihash[a: 1, b: 2, c: 3]).must_equal true
     end
 
     it 'should return true when the argument is equal to self' do
-      (Bihash[a: 1, b: 2] <= Bihash[a: 1, b: 2]).must_equal true
+      _(Bihash[a: 1, b: 2] <= Bihash[a: 1, b: 2]).must_equal true
     end
 
     it 'should return false when the argument is not a subset of self' do
-      (Bihash[a: 1, b: 2, c: 3] <= Bihash[a: 1, b: 2]).must_equal false
+      _(Bihash[a: 1, b: 2, c: 3] <= Bihash[a: 1, b: 2]).must_equal false
+    end
+
+    it 'should not treat == values as eql? when comparing pairs' do
+      bh1 = Bihash[1.to_i => 1.to_r, 1.to_f => 1.to_c]
+      bh2 = Bihash[1.to_i => 1.to_c, 1.to_f => 1.to_r]
+      _(bh1 <= bh2).must_equal false
     end
   end
 
   describe '#==' do
     it 'should return true when two bihashes have the same pairs' do
       bh1, bh2 = Bihash[:k1 => 1, :k2 => 2], Bihash[2 => :k2, 1 => :k1]
-      (bh1 == bh2).must_equal true
+      _(bh1 == bh2).must_equal true
     end
 
     it 'should return false when two bihashes do not have the same pairs' do
       bh1, bh2 = Bihash[:k1 => 1, :k2 => 2], Bihash[:k1 => 1, :k2 => 99]
-      (bh1 == bh2).must_equal false
+      _(bh1 == bh2).must_equal false
+    end
+
+    it 'should compare pairs using #eql? (since all values are also keys)' do
+      bh1 = Bihash[1.to_i => 1.to_r, 1.to_f => 1.to_c]
+      bh2 = Bihash[1.to_i => 1.to_c, 1.to_f => 1.to_r]
+      _(bh1 == bh2).must_equal false
+    end
+
+    describe 'when the bihashes differ on compare_by_identity' do
+      it 'should return true when both bihashes are empty' do
+        bh1 = Bihash[].compare_by_identity
+        bh2 = Bihash[]
+        _(bh1 == bh2).must_equal true
+      end
+
+      it 'should return false for non-empty bihashes' do
+        bh1 = Bihash[one: 1].compare_by_identity
+        bh2 = Bihash[one: 1]
+        _(bh1 == bh2).must_equal false
+      end
+    end
+
+    describe 'when compare_by_identity is set on both bihashes' do
+      it 'should return true when all pairs are equal?' do
+        i, r, f, c = 1.to_i, 1.to_r, 1.to_f, 1.to_c
+        bh1 = Bihash[i => r, f => c].compare_by_identity
+        bh2 = Bihash[i => r, f => c].compare_by_identity
+        _(bh1 == bh2).must_equal true
+      end
+
+      it 'should return false when all pairs are eql? but not equal?' do
+        bh1 = Bihash[1.to_i => 1.to_r, 1.to_f => 1.to_c].compare_by_identity
+        bh2 = Bihash[1.to_i => 1.to_r, 1.to_f => 1.to_c].compare_by_identity
+        _(bh1 == bh2).must_equal false
+      end
     end
 
     it 'should be aliased to #eql?' do
       bh = Bihash.new
-      bh.method(:eql?).must_equal bh.method(:==)
+      _(bh.method(:eql?)).must_equal bh.method(:==)
     end
   end
 
   describe '#>' do
     it 'should raise an error if the right hand side is not a bihash' do
-      -> { Bihash[a: 1, b: 2] > {a: 1, b: 2, c: 3} }.must_raise TypeError
+      _(-> { Bihash[a: 1, b: 2] > {a: 1, b: 2, c: 3} }).must_raise TypeError
     end
 
     it 'should return true when the argument is a strict superset of self' do
-      (Bihash[a: 1, b: 2, c: 3] > Bihash[a: 1, b: 2]).must_equal true
+      _(Bihash[a: 1, b: 2, c: 3] > Bihash[a: 1, b: 2]).must_equal true
     end
 
     it 'should return false when the argument is equal to self' do
-      (Bihash[a: 1, b: 2] > Bihash[a: 1, b: 2]).must_equal false
+      _(Bihash[a: 1, b: 2] > Bihash[a: 1, b: 2]).must_equal false
     end
 
     it 'should return false when the argument is not a superset of self' do
-      (Bihash[a: 1, b: 2] > Bihash[a: 1, b: 2, c: 3]).must_equal false
+      _(Bihash[a: 1, b: 2] > Bihash[a: 1, b: 2, c: 3]).must_equal false
     end
   end
 
   describe '#>=' do
     it 'should raise an error if the right hand side is not a bihash' do
-      -> { Bihash[a: 1, b: 2] >= {a: 1, b: 2, c: 3} }.must_raise TypeError
+      _(-> { Bihash[a: 1, b: 2] >= {a: 1, b: 2, c: 3} }).must_raise TypeError
     end
 
     it 'should return true when the argument is a strict superset of self' do
-      (Bihash[a: 1, b: 2, c: 3] >= Bihash[a: 1, b: 2]).must_equal true
+      _(Bihash[a: 1, b: 2, c: 3] >= Bihash[a: 1, b: 2]).must_equal true
     end
 
     it 'should return true when the argument is equal to self' do
-      (Bihash[a: 1, b: 2] >= Bihash[a: 1, b: 2]).must_equal true
+      _(Bihash[a: 1, b: 2] >= Bihash[a: 1, b: 2]).must_equal true
     end
 
     it 'should return false when the argument is not a superset of self' do
-      (Bihash[a: 1, b: 2] >= Bihash[a: 1, b: 2, c: 3]).must_equal false
+      _(Bihash[a: 1, b: 2] >= Bihash[a: 1, b: 2, c: 3]).must_equal false
+    end
+
+    it 'should not treat == values as eql? when comparing pairs' do
+      bh1 = Bihash[1.to_i => 1.to_r, 1.to_f => 1.to_c]
+      bh2 = Bihash[1.to_i => 1.to_c, 1.to_f => 1.to_r]
+      _(bh1 >= bh2).must_equal false
     end
   end
 
   describe '#[]' do
     it 'should return the other pair' do
       bh = Bihash[:key => 'value']
-      bh[:key].must_equal 'value'
-      bh['value'].must_equal :key
+      _(bh[:key]).must_equal 'value'
+      _(bh['value']).must_equal :key
     end
 
     it 'should return falsey values correctly' do
       bh1 = Bihash[nil => false]
-      bh1[nil].must_equal false
-      bh1[false].must_be_nil
+      _(bh1[nil]).must_equal false
+      _(bh1[false]).must_be_nil
 
       bh2 = Bihash[false => nil]
-      bh2[false].must_be_nil
-      bh2[nil].must_equal false
+      _(bh2[false]).must_be_nil
+      _(bh2[nil]).must_equal false
     end
   end
 
@@ -247,68 +383,125 @@ describe Bihash do
     it 'should allow assignment of new pairs' do
       bh = Bihash.new
       bh[:key] = 'value'
-      bh[:key].must_equal 'value'
-      bh['value'].must_equal :key
+      _(bh[:key]).must_equal 'value'
+      _(bh['value']).must_equal :key
     end
 
     it 'should remove old pairs if old keys are re-assigned' do
       bh = Bihash[1 => 'one', 2 => 'two']
       bh[1] = 'uno'
-      bh[1].must_equal 'uno'
-      bh['uno'].must_equal 1
-      bh.wont_include 'one'
+      _(bh[1]).must_equal 'uno'
+      _(bh['uno']).must_equal 1
+      _(bh).wont_include 'one'
     end
 
     it 'should always return the value object if key-value pairs are equal' do
       key, value = [], []
       bh = Bihash.new
       bh[key] = value
-      bh[key].object_id.must_equal value.object_id
-      bh[value].object_id.must_equal value.object_id
+      _(bh[key].object_id).must_equal value.object_id
+      _(bh[value].object_id).must_equal value.object_id
     end
 
     it 'should be aliased to #store' do
       bh = Bihash.new
-      bh.method(:store).must_equal bh.method(:[]=)
+      _(bh.method(:store)).must_equal bh.method(:[]=)
       bh.store(:key, 'value')
-      bh[:key].must_equal 'value'
-      bh['value'].must_equal :key
+      _(bh[:key]).must_equal 'value'
+      _(bh['value']).must_equal :key
     end
 
-    it 'should raise RuntimeError if called on a frozen bihash' do
-      -> { Bihash.new.freeze[:key] = 'value' }.must_raise RuntimeError
+    it 'should raise FrozenError if called on a frozen bihash' do
+      _(-> { Bihash.new.freeze[:key] = 'value' }).must_raise FrozenError
     end
   end
 
   describe '#assoc' do
     it 'should return the pair if the argument is a key' do
       bh = Bihash[:k1 => 'v1', :k2 => 'v2']
-      bh.assoc(:k1).must_equal [:k1, 'v1']
-      bh.assoc('v2').must_equal ['v2', :k2]
+      _(bh.assoc(:k1)).must_equal [:k1, 'v1']
+      _(bh.assoc('v2')).must_equal ['v2', :k2]
     end
 
     it 'should return nil if the argument is not a key' do
       bh = Bihash.new(404)
-      bh.assoc(:not_a_key).must_be_nil
+      _(bh.assoc(:not_a_key)).must_be_nil
     end
 
     it 'should find the key using #==' do
       bh = Bihash[[] => 'array']
       bh['array'] << 'modified'
-      bh.assoc(['modified']).must_equal [['modified'], 'array']
-      bh.assoc([]).must_be_nil
+      _(bh.assoc(['modified'])).must_equal [['modified'], 'array']
+      _(bh.assoc([])).must_be_nil
+    end
+  end
+
+  describe '#compact' do
+    describe 'when any pairs contain a nil key' do
+      it 'should return a new bihash with any pairs containing nil removed' do
+        bh = Bihash[1 => :one, 2 => nil, 3 => :three]
+        _(bh.compact).must_equal Bihash[1 => :one, 3 => :three]
+        _(bh).must_equal Bihash[1 => :one, 2 => nil, 3 => :three]
+      end
+    end
+
+    describe 'no pairs contain a nil key' do
+      it 'should return a copy of the original bihash' do
+        bh = Bihash[1 => :one, 2 => :two, 3 => :three]
+        compacted_bh = bh.compact
+        _(compacted_bh).must_equal Bihash[1 => :one, 2=> :two, 3 => :three]
+        _(compacted_bh.object_id).wont_equal bh.object_id
+      end
+    end
+
+    it 'should return a new bihash with defaults copied' do
+      bh_default = Bihash.new(404)
+      _(bh_default.compact.default).must_equal 404
+      bh_default_proc = Bihash.new { "hello #{_2}" }
+      _(bh_default_proc.compact.default(:world)).must_equal "hello world"
+    end
+
+    it 'should return a new bihash with compare_by_identity copied' do
+      bh = Bihash[]
+      _(bh.compact.compare_by_identity?).must_equal false
+      bh.compare_by_identity
+      _(bh.compact.compare_by_identity?).must_equal true
+    end
+  end
+
+  describe '#compact!' do
+    it 'should delete any pairs containing nil' do
+      bh1 = Bihash[1 => :one, 2 => nil, 3 => :three]
+      bh1_id = bh1.object_id
+      _(bh1.compact!.object_id).must_equal bh1_id
+      _(bh1).must_equal Bihash[1 => :one, 3 => :three]
+
+      bh2 = Bihash[1 => :one, 2 => nil, 3 => :three]
+      bh2_id = bh2.object_id
+      _(bh2.compact!.object_id).must_equal bh2_id
+      _(bh2).must_equal Bihash[1 => :one, 3 => :three]
+    end
+
+    it 'should return nil if no changes were made to the bihash' do
+      bh = Bihash[1 => :one, 2 => :two, 3 => :three, 4 => :four]
+      _(bh.compact!).must_be_nil
+      _(bh).must_equal Bihash[1 => :one, 2 => :two, 3 => :three, 4 => :four]
+    end
+
+    it 'should raise FrozenError if called on a frozen bihash' do
+      _(-> { Bihash.new.freeze.compact! }).must_raise FrozenError
     end
   end
 
   describe '#clear' do
     it 'should remove all pairs and return the bihash' do
       bh = Bihash[:key => 'value']
-      bh.clear.object_id.must_equal bh.object_id
-      bh.must_be_empty
+      _(bh.clear.object_id).must_equal bh.object_id
+      _(bh).must_be_empty
     end
 
-    it 'should raise RuntimeError if called on a frozen bihash' do
-      -> { Bihash.new.freeze.clear }.must_raise RuntimeError
+    it 'should raise FrozenError if called on a frozen bihash' do
+      _(-> { Bihash.new.freeze.clear }).must_raise FrozenError
     end
   end
 
@@ -317,7 +510,30 @@ describe Bihash do
       bh = Bihash[1 => :one]
       clone = bh.clone
       clone[2] = :two
-      bh[2].must_be_nil
+      _(bh[2]).must_be_nil
+    end
+
+    it 'should copy the default value' do
+      bh = Bihash.new(404)
+      clone = bh.clone
+      _(clone.default).must_equal 404
+    end
+
+    it 'should copy the default proc' do
+      bh = Bihash.new { |_,k| k.to_s }
+      clone = bh.clone
+      _(clone.default(:not_a_key)).must_equal 'not_a_key'
+    end
+
+    it 'should copy compare_by_identity' do
+      bh = Bihash[]
+      _(bh.clone.compare_by_identity?).must_equal false
+      bh.compare_by_identity
+      _(bh.clone.compare_by_identity?).must_equal true
+    end
+
+    it 'should copy the frozen state' do
+      _(Bihash.new.freeze.clone.frozen?).must_equal true
     end
   end
 
@@ -326,58 +542,76 @@ describe Bihash do
       bh = Bihash.new.compare_by_identity
       key1, key2 = 'key', 'value'
       bh[key1] = key2
-      bh['key'].must_be_nil
-      bh['value'].must_be_nil
-      bh[key1].must_equal 'value'
-      bh[key2].must_equal 'key'
+      _(bh['key']).must_be_nil
+      _(bh['value']).must_be_nil
+      _(bh[key1]).must_equal 'value'
+      _(bh[key2]).must_equal 'key'
+    end
+
+    it 'should raise FrozenError if called on a frozen bihash' do
+      _(-> { Bihash.new.freeze.compare_by_identity }).must_raise FrozenError
     end
 
-    it 'should raise RuntimeError if called on a frozen bihash' do
-      -> { Bihash.new.freeze.compare_by_identity }.must_raise RuntimeError
+    it 'should raise if called when key duplicated (equal?) outside pair' do
+      a, b, c, d = [:a], [:b], [:c], [:d]
+      bh = Bihash[a => b, c => d]
+      d.replace([:a])
+      bh[d] = :anything
+      _(-> { bh.compare_by_identity }).must_raise RuntimeError
     end
   end
 
   describe '#compare_by_identity?' do
     it 'should indicate whether bihash is comparing by identity' do
-      Bihash.new.compare_by_identity.compare_by_identity?.must_equal true
-      Bihash.new.compare_by_identity?.must_equal false
+      _(Bihash.new.compare_by_identity.compare_by_identity?).must_equal true
+      _(Bihash.new.compare_by_identity?).must_equal false
+    end
+  end
+
+  describe '#deconstruct_keys' do
+    it 'should enable pattern matching in the forward and reverse direction' do
+      bh = Bihash[left: :right]
+      bh in {left:}
+      _(left).must_equal :right
+      bh in {right:}
+      _(right).must_equal :left
     end
   end
 
   describe '#default' do
     it 'should not accept more than one argument' do
-      -> { Bihash.new.default(1,2) }.must_raise ArgumentError
+      _(-> { Bihash.new.default(1,2) }).must_raise ArgumentError
     end
 
     describe 'when there is not a default proc' do
       it 'should return the default' do
         bh1 = Bihash[:key => 'value']
-        bh1.default.must_be_nil
-        bh1.default(:not_a_key).must_be_nil
-        bh1.default(:key).must_be_nil
+        _(bh1.default).must_be_nil
+        _(bh1.default(:not_a_key)).must_be_nil
+        _(bh1.default(:key)).must_be_nil
 
         bh2 = Bihash.new(404)
         bh2[:key] = 'value'
-        bh2.default.must_equal 404
-        bh2.default(:not_a_key).must_equal 404
-        bh2.default(:key).must_equal 404
+        _(bh2.default).must_equal 404
+        _(bh2.default(:not_a_key)).must_equal 404
+        _(bh2.default(:key)).must_equal 404
       end
     end
 
     describe 'when there is a default proc' do
       it 'should return the default if called with no argument' do
-        Bihash.new { 'proc called' }.default.must_be_nil
+        _(Bihash.new { 'proc called' }.default).must_be_nil
       end
 
       it 'should call the default proc when called with an argument' do
         bh = Bihash.new { |bihash, key| bihash[key] = key.to_s }
         bh[:key] = 'value'
 
-        bh.default(:key).must_equal 'key'
-        bh[:key].must_equal 'key'
+        _(bh.default(:key)).must_equal 'key'
+        _(bh[:key]).must_equal 'key'
 
-        bh.default(404).must_equal '404'
-        bh[404].must_equal '404'
+        _(bh.default(404)).must_equal '404'
+        _(bh[404]).must_equal '404'
       end
     end
   end
@@ -385,13 +619,13 @@ describe Bihash do
   describe '#default=' do
     it 'should set the default object' do
       bh = Bihash.new { 'proc called' }
-      bh[:not_a_key].must_equal 'proc called'
-      (bh.default = 404).must_equal 404
-      bh[:not_a_key].must_equal 404
+      _(bh[:not_a_key]).must_equal 'proc called'
+      _(bh.default = 404).must_equal 404
+      _(bh[:not_a_key]).must_equal 404
     end
 
-    it 'should raise RuntimeError if called on a frozen bihash' do
-      -> { Bihash.new.freeze.default = 404 }.must_raise RuntimeError
+    it 'should raise FrozenError if called on a frozen bihash' do
+      _(-> { Bihash.new.freeze.default = 404 }).must_raise FrozenError
     end
   end
 
@@ -401,68 +635,68 @@ describe Bihash do
       prc = bh.default_proc
       array = []
       prc.call(array, 2)
-      array.must_equal [nil, nil, 2]
+      _(array).must_equal [nil, nil, 2]
     end
 
     it 'should return nil if there is no default proc' do
-      Bihash.new.default_proc.must_be_nil
-      Bihash.new(404).default_proc.must_be_nil
+      _(Bihash.new.default_proc).must_be_nil
+      _(Bihash.new(404).default_proc).must_be_nil
     end
   end
 
   describe '#default_proc=' do
     it 'should set the default proc' do
       bh = Bihash.new(:default_object)
-      bh[:not_a_key].must_equal :default_object
-      (bh.default_proc = ->(bihash, key) { '404' }).must_be_instance_of Proc
-      bh[:not_a_key].must_equal '404'
+      _(bh[:not_a_key]).must_equal :default_object
+      _(bh.default_proc = ->(bihash, key) { '404' }).must_be_instance_of Proc
+      _(bh[:not_a_key]).must_equal '404'
     end
 
     it 'should set the default value to nil if argument is nil' do
       bh = Bihash.new(:default_object)
-      bh[:not_a_key].must_equal :default_object
-      (bh.default_proc = nil).must_be_nil
-      bh[:not_a_key].must_be_nil
+      _(bh[:not_a_key]).must_equal :default_object
+      _(bh.default_proc = nil).must_be_nil
+      _(bh[:not_a_key]).must_be_nil
     end
 
     it 'should raise TypeError if not given a non-proc (except nil)' do
-      -> { Bihash.new.default_proc = :not_a_proc }.must_raise TypeError
+      _(-> { Bihash.new.default_proc = :not_a_proc }).must_raise TypeError
     end
 
     it 'should raise TypeError given a lambda without 2 args' do
-      -> { Bihash.new.default_proc = -> { '404' } }.must_raise TypeError
+      _(-> { Bihash.new.default_proc = -> { '404' } }).must_raise TypeError
     end
 
-    it 'should raise RuntimeError if called on a frozen bihash' do
-      -> { Bihash[].freeze.default_proc = proc { '' } }.must_raise RuntimeError
+    it 'should raise FrozenError if called on a frozen bihash' do
+      _(-> { Bihash[].freeze.default_proc = proc { '' } }).must_raise FrozenError
     end
   end
 
   describe '#delete' do
     it 'should return the other key if the given key is found' do
-      Bihash[:key => 'value'].delete(:key).must_equal 'value'
-      Bihash[:key => 'value'].delete('value').must_equal :key
+      _(Bihash[:key => 'value'].delete(:key)).must_equal 'value'
+      _(Bihash[:key => 'value'].delete('value')).must_equal :key
     end
 
     it 'should remove both keys' do
       bh1 = Bihash[:key => 'value']
       bh1.delete(:key)
-      bh1.wont_include :key
-      bh1.wont_include 'value'
+      _(bh1).wont_include :key
+      _(bh1).wont_include 'value'
 
       bh2 = Bihash[:key => 'value']
       bh2.delete('value')
-      bh2.wont_include :key
-      bh2.wont_include 'value'
+      _(bh2).wont_include :key
+      _(bh2).wont_include 'value'
     end
 
     it 'should call the block (if given) when the key is not found' do
       out = Bihash[:key => 'value'].delete(404) { |key| "#{key} not found" }
-      out.must_equal '404 not found'
+      _(out).must_equal '404 not found'
     end
 
-    it 'should raise RuntimeError if called on a frozen bihash' do
-      -> { Bihash.new.freeze.delete(:key) }.must_raise RuntimeError
+    it 'should raise FrozenError if called on a frozen bihash' do
+      _(-> { Bihash.new.freeze.delete(:key) }).must_raise FrozenError
     end
   end
 
@@ -470,41 +704,64 @@ describe Bihash do
     it 'should delete any pairs for which the block evaluates to true' do
       bh = Bihash[1 => :one, 2 => :two, 3 => :three, 4 => :four]
       bh_id = bh.object_id
-      bh.delete_if { |key1, key2| key1.even? }.object_id.must_equal bh_id
-      bh.must_equal Bihash[1 => :one, 3 => :three]
+      _(bh.delete_if { |key1, key2| key1.even? }.object_id).must_equal bh_id
+      _(bh).must_equal Bihash[1 => :one, 3 => :three]
     end
 
-    it 'should raise RuntimeError if called on a frozen bihash with a block' do
-      -> { Bihash.new.freeze.delete_if { false } }.must_raise RuntimeError
+    it 'should raise FrozenError if called on a frozen bihash with a block' do
+      _(-> { Bihash.new.freeze.delete_if { false } }).must_raise FrozenError
     end
 
     it 'should return an enumerator if not given a block' do
       enum = Bihash[1 => :one, 2 => :two, 3 => :three, 4 => :four].delete_if
-      enum.must_be_instance_of Enumerator
-      enum.each { |k1, k2| k1.even? }.must_equal Bihash[1 => :one, 3 => :three]
+      _(enum).must_be_instance_of Enumerator
+      _(enum.size).must_equal 4
+      _(enum.each { |k1, k2| k1.even? }).must_equal Bihash[1 => :one, 3 => :three]
     end
   end
 
   describe '#dig' do
     it 'should traverse nested bihashes' do
       bh = Bihash[foo: Bihash[bar: Bihash[baz: 4]]]
-      bh.dig(:foo, :bar, :baz).must_equal 4
-      bh.dig(:foo, :bar, 4).must_equal :baz
+      _(bh.dig(:foo, :bar, :baz)).must_equal 4
+      _(bh.dig(:foo, :bar, 4)).must_equal :baz
     end
 
     it 'should traverse nested hashes' do
       bh = Bihash[foo: {bar: {baz: 4}}]
-      bh.dig(:foo, :bar, :baz).must_equal 4
+      _(bh.dig(:foo, :bar, :baz)).must_equal 4
     end
 
     it 'should traverse nested arrays' do
       bh = Bihash[foo: [[4]]]
-      bh.dig(:foo, 0, 0).must_equal 4
+      _(bh.dig(:foo, 0, 0)).must_equal 4
     end
 
     it 'should return nil if any intermediate step is nil' do
       bh = Bihash[foo: Bihash[bar: Bihash[baz: 4]]]
-      bh.dig(:foo, :bur, :boz).must_be_nil
+      _(bh.dig(:foo, :bur, :boz)).must_be_nil
+    end
+
+    describe 'when a key is not found' do
+      it 'should use the default value if present' do
+        bh = Bihash.new(404)
+        _(bh.dig(:not_a_key)).must_equal 404
+      end
+
+      it 'should use the default proc if present' do
+        bh = Bihash.new { "#{_2} not found" }
+        _(bh.dig(:not_a_key)).must_equal "not_a_key not found"
+      end
+
+      it 'should early return nil if the default is nil' do
+        bh = Bihash.new(nil)
+        _(bh.dig(:not_a_key, :dont_try_me)).must_be_nil
+      end
+
+      it 'should continue to dig on the default if it is not nil' do
+        bh = Bihash.new(Bihash[do_try_me: "it worked!"])
+        _(bh.dig(:not_a_key, :do_try_me)).must_equal "it worked!"
+      end
     end
   end
 
@@ -513,7 +770,30 @@ describe Bihash do
       bh = Bihash[1 => :one]
       dup = bh.dup
       dup[2] = :two
-      bh[2].must_be_nil
+      _(bh[2]).must_be_nil
+    end
+
+    it 'should copy the default value' do
+      bh = Bihash.new(404)
+      dup = bh.dup
+      _(dup.default).must_equal 404
+    end
+
+    it 'should copy the default proc' do
+      bh = Bihash.new { |_,k| k.to_s }
+      dup = bh.dup
+      _(dup.default(:not_a_key)).must_equal 'not_a_key'
+    end
+
+    it 'should copy compare_by_identity' do
+      bh = Bihash[]
+      _(bh.dup.compare_by_identity?).must_equal false
+      bh.compare_by_identity
+      _(bh.dup.compare_by_identity?).must_equal true
+    end
+
+    it 'should not copy the frozen state' do
+      _(Bihash.new.freeze.dup.frozen?).must_equal false
     end
   end
 
@@ -521,120 +801,147 @@ describe Bihash do
     it 'should iterate over each pair in the bihash' do
       array = []
       Bihash[:k1 => 'v1', :k2 => 'v2'].each { |pair| array << pair }
-      array.must_equal [[:k1, 'v1'], [:k2, 'v2']]
+      _(array).must_equal [[:k1, 'v1'], [:k2, 'v2']]
     end
 
     it 'should return the bihash if given a block' do
       bh = Bihash.new
-      bh.each { |p| }.must_be_instance_of Bihash
-      bh.each { |p| }.object_id.must_equal bh.object_id
+      _(bh.each { |p| }).must_be_instance_of Bihash
+      _(bh.each { |p| }.object_id).must_equal bh.object_id
     end
 
     it 'should return an enumerator if not given a block' do
       enum = Bihash[:k1 => 'v1', :k2 => 'v2'].each
-      enum.must_be_instance_of Enumerator
-      enum.each { |pair| pair }.must_equal Bihash[:k1 => 'v1', :k2 => 'v2']
+      _(enum).must_be_instance_of Enumerator
+      _(enum.size).must_equal 2
+      _(enum.each { |pair| pair }).must_equal Bihash[:k1 => 'v1', :k2 => 'v2']
     end
 
     it 'should be aliased to #each_pair' do
       bh = Bihash.new
-      bh.method(:each_pair).must_equal bh.method(:each)
+      _(bh.method(:each_pair)).must_equal bh.method(:each)
     end
   end
 
   describe '#empty?' do
     it 'should indicate if the bihash is empty' do
-      Bihash.new.empty?.must_equal true
-      Bihash[:key => 'value'].empty?.must_equal false
+      _(Bihash.new.empty?).must_equal true
+      _(Bihash[:key => 'value'].empty?).must_equal false
+    end
+  end
+
+  describe '#except' do
+    it 'should return a new bihash without the pairs that are in the args' do
+      bh = Bihash[1 => :one, 2 => :two, 3 => :three]
+      _(bh.except(1, :two, "nope")).must_equal Bihash[3 => :three]
+      _(bh).must_equal Bihash[1 => :one, 2 => :two, 3 => :three]
+    end
+
+    it 'should return a new bihash without defaults copied' do
+      bh_default = Bihash.new(404)
+      _(bh_default.except.default).must_be_nil
+      bh_default_proc = Bihash.new { 404 }
+      _(bh_default_proc.except.default_proc).must_be_nil
+    end
+
+    it 'should return a new bihash with compare_by_identity copied' do
+      bh = Bihash[]
+      _(bh.except.compare_by_identity?).must_equal false
+      bh.compare_by_identity
+      _(bh.except.compare_by_identity?).must_equal true
     end
   end
 
   describe '#fetch' do
     it 'should return the other pair' do
       bh = Bihash[:key => 'value']
-      bh.fetch(:key).must_equal 'value'
-      bh.fetch('value').must_equal :key
+      _(bh.fetch(:key)).must_equal 'value'
+      _(bh.fetch('value')).must_equal :key
     end
 
     it 'should return falsey values correctly' do
       bh1 = Bihash[nil => false]
-      bh1.fetch(nil).must_equal false
-      bh1.fetch(false).must_be_nil
+      _(bh1.fetch(nil)).must_equal false
+      _(bh1.fetch(false)).must_be_nil
 
       bh2 = Bihash[false => nil]
-      bh2.fetch(false).must_be_nil
-      bh2.fetch(nil).must_equal false
+      _(bh2.fetch(false)).must_be_nil
+      _(bh2.fetch(nil)).must_equal false
     end
 
     describe 'when the key is not found' do
       it 'should raise KeyError when not supplied any default' do
-        -> { Bihash[].fetch(:not_a_key) }.must_raise KeyError
+        _(-> { Bihash[].fetch(:not_a_key) }).must_raise KeyError
       end
 
       it 'should return the second arg when supplied with one' do
-        Bihash[].fetch(:not_a_key, :second_arg).must_equal :second_arg
+        _(Bihash[].fetch(:not_a_key, :second_arg)).must_equal :second_arg
       end
 
       it 'should call the block if supplied with one' do
-        Bihash[].fetch(404) { |k| "#{k} not found" }.must_equal '404 not found'
+        _(Bihash[].fetch(404) { |k| "#{k} not found" }).must_equal '404 not found'
       end
     end
   end
 
   describe '#fetch_values' do
     it 'should return an array of values corresponding to the given keys' do
-      Bihash[1 => :one, 2 => :two].fetch_values(1, 2).must_equal [:one, :two]
-      Bihash[1 => :one, 2 => :two].fetch_values(:one, :two).must_equal [1, 2]
-      Bihash[1 => :one, 2 => :two].fetch_values(1, :two).must_equal [:one, 2]
-    end
-
-    it 'should raise a KeyError if any key is not found' do
-      -> { Bihash.new.fetch_values(404) }.must_raise KeyError
+      _(Bihash[1 => :one, 2 => :two].fetch_values(1, 2)).must_equal [:one, :two]
+      _(Bihash[1 => :one, 2 => :two].fetch_values(:one, :two)).must_equal [1, 2]
+      _(Bihash[1 => :one, 2 => :two].fetch_values(1, :two)).must_equal [:one, 2]
     end
 
     it 'should not duplicate entries if a key equals its value' do
-      Bihash[:key => :key].fetch_values(:key).must_equal [:key]
+      _(Bihash[:key => :key].fetch_values(:key)).must_equal [:key]
     end
 
     it 'should return an empty array with no args' do
-      Bihash[:key => 'value'].fetch_values.must_equal []
+      _(Bihash[:key => 'value'].fetch_values).must_equal []
+    end
+
+    it 'should raise a KeyError if any key is not found without a block' do
+      _(-> { Bihash.new.fetch_values(404) }).must_raise KeyError
+    end
+
+    it 'should yield missing keys to the block if one is given' do
+      _(Bihash[1 => :one, 2 => :two].fetch_values(1, :two, 'three') { |k| "#{k} is missing"}).must_equal [:one, 2, 'three is missing']
     end
   end
 
   describe '#flatten' do
     it 'should extract the pairs into an array' do
-      Bihash[:k1 => 'v1', :k2 => 'v2'].flatten.must_equal [:k1, 'v1', :k2, 'v2']
+      _(Bihash[:k1 => 'v1', :k2 => 'v2'].flatten).must_equal [:k1, 'v1', :k2, 'v2']
     end
 
     it 'should not flatten array keys if no argument is given' do
-      Bihash[:key => ['v1', 'v2']].flatten.must_equal [:key, ['v1', 'v2']]
+      _(Bihash[:key => ['v1', 'v2']].flatten).must_equal [:key, ['v1', 'v2']]
     end
 
     it 'should flatten to the level given as an argument' do
-      Bihash[:key => ['v1', 'v2']].flatten(2).must_equal [:key, 'v1', 'v2']
+      _(Bihash[:key => ['v1', 'v2']].flatten(2)).must_equal [:key, 'v1', 'v2']
     end
   end
 
   describe '#hash' do
     it 'should return the same hash code if two bihashes have the same pairs' do
       bh1, bh2 = Bihash[:k1 => 1, :k2 => 2], Bihash[2 => :k2, 1 => :k1]
-      bh1.hash.must_equal bh2.hash
+      _(bh1.hash).must_equal bh2.hash
     end
   end
 
   describe '#include?' do
     it 'should indicate if the bihash contains the argument' do
       bh = Bihash[:key => 'value']
-      bh.include?(:key).must_equal true
-      bh.include?('value').must_equal true
-      bh.include?(:not_a_key).must_equal false
+      _(bh.include?(:key)).must_equal true
+      _(bh.include?('value')).must_equal true
+      _(bh.include?(:not_a_key)).must_equal false
     end
 
     it 'should be aliased to #has_key?, #key?, and #member?' do
       bh = Bihash.new
-      bh.method(:has_key?).must_equal bh.method(:include?)
-      bh.method(:key?).must_equal bh.method(:include?)
-      bh.method(:member?).must_equal bh.method(:include?)
+      _(bh.method(:has_key?)).must_equal bh.method(:include?)
+      _(bh.method(:key?)).must_equal bh.method(:include?)
+      _(bh.method(:member?)).must_equal bh.method(:include?)
     end
   end
 
@@ -642,39 +949,74 @@ describe Bihash do
     it 'should retain any pairs for which the block evaluates to true' do
       bh = Bihash[1 => :one, 2 => :two, 3 => :three, 4 => :four]
       bh_id = bh.object_id
-      bh.keep_if { |key1, key2| key1.even? }.object_id.must_equal bh_id
-      bh.must_equal Bihash[2 => :two, 4 => :four]
+      _(bh.keep_if { |key1, key2| key1.even? }.object_id).must_equal bh_id
+      _(bh).must_equal Bihash[2 => :two, 4 => :four]
     end
 
-    it 'should raise RuntimeError if called on a frozen bihash with a block' do
-      -> { Bihash.new.freeze.keep_if { true } }.must_raise RuntimeError
+    it 'should raise FrozenError if called on a frozen bihash with a block' do
+      _(-> { Bihash.new.freeze.keep_if { true } }).must_raise FrozenError
     end
 
     it 'should return an enumerator if not given a block' do
       enum = Bihash[1 => :one, 2 => :two, 3 => :three, 4 => :four].keep_if
-      enum.must_be_instance_of Enumerator
-      enum.each { |k1, k2| k1.even? }.must_equal Bihash[2 => :two, 4 => :four]
+      _(enum).must_be_instance_of Enumerator
+      _(enum.size).must_equal 4
+      _(enum.each { |k1, k2| k1.even? }).must_equal Bihash[2 => :two, 4 => :four]
     end
   end
 
   describe '#length' do
     it 'should return the number of pairs in the bihash' do
-      Bihash[1 => :one, 2 => :two].length.must_equal 2
+      _(Bihash[1 => :one, 2 => :two].length).must_equal 2
     end
   end
 
   describe '#merge' do
-    it 'should merge bihashes, assigning each arg pair to a copy of reciever' do
+    it 'should merge bihashes, assigning each arg pair to a copy of receiver' do
       receiver = Bihash[:chips => :salsa, :milk => :cookies, :fish => :rice]
       original_receiver = receiver.dup
       argument = Bihash[:fish => :chips, :soup => :salad]
       return_value = Bihash[:milk => :cookies, :fish => :chips, :soup => :salad]
-      receiver.merge(argument).must_equal return_value
-      receiver.must_equal original_receiver
+      _(receiver.merge(argument)).must_equal return_value
+      _(receiver).must_equal original_receiver
     end
 
-    it 'should raise TypeError if arg is not a bihash' do
-      -> { Bihash.new.merge({:key => 'value'}) }.must_raise TypeError
+    it 'should accept multiple bihashes' do
+      receiver = Bihash[receiver: true]
+      original_receiver = receiver.dup
+      arg1 = Bihash[one: 1]
+      arg2 = Bihash[two: 2]
+      return_value = Bihash[receiver: true, one: 1, two: 2]
+      _(receiver.merge(arg1, arg2)).must_equal return_value
+      _(receiver).must_equal original_receiver
+    end
+
+    it 'should merge later bihashes over earlier ones' do
+      receiver = Bihash[a: 1]
+      original_receiver = receiver.dup
+      arg1 = Bihash[a: 2]
+      arg2 = Bihash[a: 3]
+      return_value = Bihash[a: 3]
+      _(receiver.merge(arg1, arg2)).must_equal return_value
+      _(receiver).must_equal original_receiver
+    end
+
+    it 'should return a new bihash with defaults copied' do
+      bh_default = Bihash.new(404)
+      _(bh_default.merge.default).must_equal 404
+      bh_default_proc = Bihash.new { "hello #{_2}" }
+      _(bh_default_proc.merge.default(:world)).must_equal "hello world"
+    end
+
+    it 'should return a new bihash with compare_by_identity copied' do
+      bh = Bihash[]
+      _(bh.merge.compare_by_identity?).must_equal false
+      bh.compare_by_identity
+      _(bh.merge.compare_by_identity?).must_equal true
+    end
+
+    it 'should raise TypeError if any arg is not a bihash' do
+      _(-> { Bihash.new.merge(Bihash[one: 1], Hash[two: 2]) }).must_raise TypeError
     end
   end
 
@@ -683,21 +1025,39 @@ describe Bihash do
       receiver = Bihash[:chips => :salsa, :milk => :cookies, :fish => :rice]
       argument = Bihash[:fish => :chips, :soup => :salad]
       return_value = Bihash[:milk => :cookies, :fish => :chips, :soup => :salad]
-      receiver.merge!(argument).must_equal return_value
-      receiver.must_equal return_value
+      _(receiver.merge!(argument)).must_equal return_value
+      _(receiver).must_equal return_value
     end
 
-    it 'should raise RuntimeError if called on a frozen bihash' do
-      -> { Bihash.new.freeze.merge!(Bihash.new) }.must_raise RuntimeError
+    it 'should accept multiple bihashes' do
+      receiver = Bihash[receiver: true]
+      arg1 = Bihash[one: 1]
+      arg2 = Bihash[two: 2]
+      return_value = Bihash[receiver: true, one: 1, two: 2]
+      _(receiver.merge!(arg1, arg2)).must_equal return_value
+      _(receiver).must_equal return_value
     end
 
-    it 'should raise TypeError if arg is not a bihash' do
-      -> { Bihash.new.merge!({:key => 'value'}) }.must_raise TypeError
+    it 'should merge later bihashes over earlier ones' do
+      receiver = Bihash[a: 1]
+      arg1 = Bihash[a: 2]
+      arg2 = Bihash[a: 3]
+      return_value = Bihash[a: 3]
+      _(receiver.merge!(arg1, arg2)).must_equal return_value
+      _(receiver).must_equal return_value
+    end
+
+    it 'should raise TypeError if any arg is not a bihash' do
+      _(-> { Bihash.new.merge!(Bihash[one: 1], Hash[two: 2]) }).must_raise TypeError
+    end
+
+    it 'should raise FrozenError if called on a frozen bihash' do
+      _(-> { Bihash.new.freeze.merge!(Bihash.new) }).must_raise FrozenError
     end
 
     it 'should be aliased to #update' do
       bh = Bihash.new
-      bh.method(:update).must_equal bh.method(:merge!)
+      _(bh.method(:update)).must_equal bh.method(:merge!)
     end
   end
 
@@ -705,19 +1065,30 @@ describe Bihash do
     it 'should recompute all key hash values and return the bihash' do
       bh = Bihash[[] => :array]
       bh[:array] << 1
-      bh[[1]].must_be_nil
-      bh.rehash[[1]].must_equal :array
-      bh[[1]].must_equal :array
+      _(bh[[1]]).must_be_nil
+      _(bh.rehash[[1]]).must_equal :array
+      _(bh[[1]]).must_equal :array
     end
 
-    it 'should raise RuntimeError if called on a frozen bihash' do
-      -> { Bihash.new.freeze.rehash }.must_raise RuntimeError
+    it 'should raise FrozenError if called on a frozen bihash' do
+      _(-> { Bihash.new.freeze.rehash }).must_raise FrozenError
     end
 
     it 'should raise RuntimeError if called when key duplicated outside pair' do
-      bh = Bihash[[1], [2], [3], [4]]
-      (bh[[4]] << 1).shift
-      -> { bh.rehash }.must_raise RuntimeError
+      a, b, c, d = [:a], [:b], [:c], [:d]
+      bh = Bihash[a => b, c => d]
+      d.replace([:a])
+      _(-> { bh.rehash }).must_raise RuntimeError
+    end
+
+    describe 'when #compare_by_identity is set' do
+      it 'should not raise when there are keys that are eql? but not equal?' do
+        bh = Bihash.new.compare_by_identity
+        foo1, foo2 = "foo", "foo"
+        bh[foo1] = 1
+        bh[foo2] = "foo"
+        bh.rehash
+      end
     end
   end
 
@@ -725,23 +1096,38 @@ describe Bihash do
     describe 'when some items are rejected' do
       it 'should return a bihash with items not rejected by the block' do
         bh = Bihash[1 => :one, 2 => :two, 3 => :three, 4 => :four]
-        bh.reject { |k1,k2| k1.even? }.must_equal Bihash[1 => :one, 3 => :three]
-        bh.must_equal Bihash[1 => :one, 2 => :two, 3 => :three, 4 => :four]
+        _(bh.reject { |k1,k2| k1.even? }).must_equal Bihash[1 => :one, 3 => :three]
+        _(bh).must_equal Bihash[1 => :one, 2 => :two, 3 => :three, 4 => :four]
       end
     end
 
     describe 'when no items are rejected' do
       it 'should return a bihash with items not rejected by the block' do
         bh = Bihash[1 => :one, 3 => :three, 5 => :five, 7 => :seven]
-        bh.reject { |k1,k2| k1.even? }.must_equal bh
-        bh.must_equal bh
+        _(bh.reject { |k1,k2| k1.even? }).must_equal bh
+        _(bh).must_equal bh
       end
     end
 
     it 'should return an enumerator if not given a block' do
       enum = Bihash[1 => :one, 2 => :two, 3 => :three, 4 => :four].reject
-      enum.must_be_instance_of Enumerator
-      enum.each { |k1,k2| k1.even? }.must_equal Bihash[1 => :one, 3 => :three]
+      _(enum).must_be_instance_of Enumerator
+      _(enum.size).must_equal 4
+      _(enum.each { |k1,k2| k1.even? }).must_equal Bihash[1 => :one, 3 => :three]
+    end
+
+    it 'should return a new bihash without defaults copied' do
+      bh_default = Bihash.new(404)
+      _(bh_default.reject { false }.default).must_be_nil
+      bh_default_proc = Bihash.new { 404 }
+      _(bh_default_proc.reject { false }.default_proc).must_be_nil
+    end
+
+    it 'should return a new bihash with compare_by_identity copied' do
+      bh = Bihash[]
+      _(bh.reject { false }.compare_by_identity?).must_equal false
+      bh.compare_by_identity
+      _(bh.reject { false }.compare_by_identity?).must_equal true
     end
   end
 
@@ -749,24 +1135,25 @@ describe Bihash do
     it 'should delete any pairs for which the block evaluates to true' do
       bh = Bihash[1 => :one, 2 => :two, 3 => :three, 4 => :four]
       bh_id = bh.object_id
-      bh.reject! { |key1, key2| key1.even? }.object_id.must_equal bh_id
-      bh.must_equal Bihash[1 => :one, 3 => :three]
+      _(bh.reject! { |key1, key2| key1.even? }.object_id).must_equal bh_id
+      _(bh).must_equal Bihash[1 => :one, 3 => :three]
     end
 
     it 'should return nil if no changes were made to the bihash' do
       bh = Bihash[1 => :one, 2 => :two, 3 => :three, 4 => :four]
-      bh.reject! { |key1, key2| key1 > 5 }.must_be_nil
-      bh.must_equal Bihash[1 => :one, 2 => :two, 3 => :three, 4 => :four]
+      _(bh.reject! { |key1, key2| key1 > 5 }).must_be_nil
+      _(bh).must_equal Bihash[1 => :one, 2 => :two, 3 => :three, 4 => :four]
     end
 
-    it 'should raise RuntimeError if called on a frozen bihash with a block' do
-      -> { Bihash.new.freeze.reject! { false } }.must_raise RuntimeError
+    it 'should raise FrozenError if called on a frozen bihash with a block' do
+      _(-> { Bihash.new.freeze.reject! { false } }).must_raise FrozenError
     end
 
     it 'should return an enumerator if not given a block' do
       enum = Bihash[1 => :one, 2 => :two, 3 => :three, 4 => :four].reject!
-      enum.must_be_instance_of Enumerator
-      enum.each { |k1, k2| k1.even? }.must_equal Bihash[1 => :one, 3 => :three]
+      _(enum).must_be_instance_of Enumerator
+      _(enum.size).must_equal 4
+      _(enum.each { |k1, k2| k1.even? }).must_equal Bihash[1 => :one, 3 => :three]
     end
   end
 
@@ -775,18 +1162,32 @@ describe Bihash do
       receiver = Bihash[]
       original_id = receiver.object_id
       arg = Bihash[:key => 'value']
-      receiver.replace(arg).must_equal Bihash[:key => 'value']
+      _(receiver.replace(arg)).must_equal Bihash[:key => 'value']
       arg[:another_key] = 'another_value'
-      receiver.object_id.must_equal original_id
-      receiver.must_equal Bihash[:key => 'value']
+      _(receiver.object_id).must_equal original_id
+      _(receiver).must_equal Bihash[:key => 'value']
+    end
+
+    it 'should copy the default value' do
+      receiver = Bihash[]
+      arg = Bihash.new(404)
+      receiver.replace(arg)
+      _(receiver.default).must_equal 404
+    end
+
+    it 'should copy the default proc' do
+      receiver = Bihash[]
+      arg = Bihash.new { |_, key| key.to_s }
+      receiver.replace(arg)
+      _(receiver.default(:not_a_key)).must_equal 'not_a_key'
     end
 
     it 'should raise TypeError if arg is not a bihash' do
-      -> { Bihash.new.replace({:key => 'value'}) }.must_raise TypeError
+      _(-> { Bihash.new.replace({:key => 'value'}) }).must_raise TypeError
     end
 
-    it 'should raise RuntimeError if called on a frozen bihash' do
-      -> { Bihash.new.freeze.replace(Bihash[:k, 'v']) }.must_raise RuntimeError
+    it 'should raise FrozenError if called on a frozen bihash' do
+      _(-> { Bihash.new.freeze.replace(Bihash[:k, 'v']) }).must_raise FrozenError
     end
   end
 
@@ -794,28 +1195,43 @@ describe Bihash do
     describe 'when only some items are selected' do
       it 'should return a bihash with items selected by the block' do
         bh = Bihash[1 => :one, 2 => :two, 3 => :three, 4 => :four]
-        bh.select { |k1,k2| k1.even? }.must_equal Bihash[2 => :two, 4 => :four]
-        bh.must_equal Bihash[1 => :one, 2 => :two, 3 => :three, 4 => :four]
+        _(bh.select { |k1,k2| k1.even? }).must_equal Bihash[2 => :two, 4 => :four]
+        _(bh).must_equal Bihash[1 => :one, 2 => :two, 3 => :three, 4 => :four]
       end
     end
 
     describe 'when all items are selected' do
       it 'should return a bihash with items selected by the block' do
         bh = Bihash[2 => :two, 4 => :four, 6 => :six, 8 => :eight]
-        bh.select { |k1,k2| k1.even? }.must_equal bh
-        bh.must_equal bh
+        _(bh.select { |k1,k2| k1.even? }).must_equal bh
+        _(bh).must_equal bh
       end
     end
 
     it 'should return an enumerator if not given a block' do
       enum = Bihash[1 => :one, 2 => :two, 3 => :three, 4 => :four].select
-      enum.must_be_instance_of Enumerator
-      enum.each { |k1,k2| k1.even? }.must_equal Bihash[2 => :two, 4 => :four]
+      _(enum).must_be_instance_of Enumerator
+      _(enum.size).must_equal 4
+      _(enum.each { |k1,k2| k1.even? }).must_equal Bihash[2 => :two, 4 => :four]
+    end
+
+    it 'should return a new bihash without defaults copied' do
+      bh_default = Bihash.new(404)
+      _(bh_default.select { true }.default).must_be_nil
+      bh_default_proc = Bihash.new { 404 }
+      _(bh_default_proc.select { true }.default_proc).must_be_nil
+    end
+
+    it 'should return a new bihash with compare_by_identity copied' do
+      bh = Bihash[]
+      _(bh.select { true }.compare_by_identity?).must_equal false
+      bh.compare_by_identity
+      _(bh.select { true }.compare_by_identity?).must_equal true
     end
 
     it 'should be aliased to #filter' do
       bh = Bihash.new
-      bh.method(:filter).must_equal bh.method(:select)
+      _(bh.method(:filter)).must_equal bh.method(:select)
     end
   end
 
@@ -823,133 +1239,157 @@ describe Bihash do
     it 'should retain any pairs for which the block evaluates to true' do
       bh = Bihash[1 => :one, 2 => :two, 3 => :three, 4 => :four]
       bh_id = bh.object_id
-      bh.select! { |key1, key2| key1.even? }.object_id.must_equal bh_id
-      bh.must_equal Bihash[2 => :two, 4 => :four]
+      _(bh.select! { |key1, key2| key1.even? }.object_id).must_equal bh_id
+      _(bh).must_equal Bihash[2 => :two, 4 => :four]
     end
 
     it 'should return nil if no changes were made to the bihash' do
       bh = Bihash[1 => :one, 2 => :two, 3 => :three, 4 => :four]
-      bh.select! { |key1, key2| key1 < 5 }.must_be_nil
-      bh.must_equal Bihash[1 => :one, 2 => :two, 3 => :three, 4 => :four]
+      _(bh.select! { |key1, key2| key1 < 5 }).must_be_nil
+      _(bh).must_equal Bihash[1 => :one, 2 => :two, 3 => :three, 4 => :four]
     end
 
-    it 'should raise RuntimeError if called on a frozen bihash with a block' do
-      -> { Bihash.new.freeze.select! { true } }.must_raise RuntimeError
+    it 'should raise FrozenError if called on a frozen bihash with a block' do
+      _(-> { Bihash.new.freeze.select! { true } }).must_raise FrozenError
     end
 
     it 'should return an enumerator if not given a block' do
       enum = Bihash[1 => :one, 2 => :two, 3 => :three, 4 => :four].select!
-      enum.must_be_instance_of Enumerator
-      enum.each { |k1, k2| k1.even? }.must_equal Bihash[2 => :two, 4 => :four]
+      _(enum).must_be_instance_of Enumerator
+      _(enum.size).must_equal 4
+      _(enum.each { |k1, k2| k1.even? }).must_equal Bihash[2 => :two, 4 => :four]
     end
 
     it 'should be aliased to #filter!' do
       bh = Bihash.new
-      bh.method(:filter!).must_equal bh.method(:select!)
+      _(bh.method(:filter!)).must_equal bh.method(:select!)
     end
   end
 
   describe '#shift' do
     it 'should remove the oldest pair from the bihash and return it' do
       bh = Bihash[1 => :one, 2 => :two, 3 => :three]
-      bh.shift.must_equal [1, :one]
-      bh.must_equal Bihash[2 => :two, 3 => :three]
+      _(bh.shift).must_equal [1, :one]
+      _(bh).must_equal Bihash[2 => :two, 3 => :three]
     end
 
-    it 'should return the default value if bihash is empty' do
-      Bihash.new.shift.must_be_nil
-      Bihash.new(404).shift.must_equal 404
-      Bihash.new { 'd3f4u17' }.shift.must_equal 'd3f4u17'
+    it 'should return nil if bihash is empty' do
+      _(Bihash.new.shift).must_be_nil
+      _(Bihash.new(404).shift).must_be_nil
+      _(Bihash.new { 'd3f4u17' }.shift).must_be_nil
     end
 
-    it 'should raise RuntimeError if called on a frozen bihash' do
-      -> { Bihash.new.freeze.shift }.must_raise RuntimeError
+    it 'should raise FrozenError if called on a frozen bihash' do
+      _(-> { Bihash.new.freeze.shift }).must_raise FrozenError
     end
   end
 
   describe '#size' do
     it 'should return the number of pairs in the bihash' do
-      Bihash[1 => :one, 2 => :two].size.must_equal 2
+      _(Bihash[1 => :one, 2 => :two].size).must_equal 2
     end
   end
 
   describe '#slice' do
     it 'should return a new bihash with only the pairs that are in the args' do
       bh = Bihash[1 => :one, 2 => :two, 3 => :three]
-      bh.slice(1, :one, :two, "nope").must_equal Bihash[1 => :one, 2 => :two]
-      bh.must_equal Bihash[1 => :one, 2 => :two, 3 => :three]
+      _(bh.slice(1, :one, :two, "nope")).must_equal Bihash[1 => :one, 2 => :two]
+      _(bh).must_equal Bihash[1 => :one, 2 => :two, 3 => :three]
     end
 
-    it 'should return a vanilla bihash without default values, etc.' do
-      sliced_bh = Bihash.new(404).slice
-      sliced_bh.default.must_be_nil
+    it 'should return a new bihash without defaults copied' do
+      bh_default = Bihash.new(404)
+      _(bh_default.slice.default).must_be_nil
+      bh_default_proc = Bihash.new { 404 }
+      _(bh_default_proc.slice.default_proc).must_be_nil
+    end
+
+    it 'should return a new bihash with compare_by_identity copied' do
+      bh = Bihash[]
+      _(bh.slice.compare_by_identity?).must_equal false
+      bh.compare_by_identity
+      _(bh.slice.compare_by_identity?).must_equal true
     end
   end
 
   describe '#to_h' do
-    it 'should return a copy of the forward hash' do
+    it 'without a block, should return a copy of the forward hash' do
       bh = Bihash[:key1 => 'val1', :key2 => 'val2']
       h = bh.to_h
-      h.must_equal Hash[:key1 => 'val1', :key2 => 'val2']
+      _(h).must_equal Hash[:key1 => 'val1', :key2 => 'val2']
       h.delete(:key1)
-      bh.must_include :key1
+      _(bh).must_include :key1
     end
 
-    it 'should be aliased to #to_hash' do
-      bh = Bihash.new
-      bh.method(:to_hash).must_equal bh.method(:to_h)
+    it 'with a block, should transform pairs from the forward hash' do
+      bh = Bihash[:key1 => 'val1', :key2 => 'val2']
+      h = bh.to_h { |k,v| [k.to_s, v.to_sym] }
+      _(h).must_equal Hash['key1' => :val1, 'key2' => :val2]
+      _(bh).must_equal Bihash[:key1 => 'val1', :key2 => 'val2']
+    end
+  end
+
+  describe '#to_hash' do
+    it 'should return a copy of the forward hash' do
+      bh = Bihash[:key1 => 'val1', :key2 => 'val2']
+      h = bh.to_hash
+      _(h).must_equal Hash[:key1 => 'val1', :key2 => 'val2']
+      h.delete(:key1)
+      _(bh).must_include :key1
     end
   end
 
   describe '#to_proc' do
     it 'should convert the bihash to a proc' do
-      Bihash[].to_proc.must_be_instance_of Proc
+      _(Bihash[].to_proc).must_be_instance_of Proc
     end
 
     it 'should call #[] on the bihash when the proc is called' do
-      Bihash[:key => 'value'].to_proc.call(:key).must_equal 'value'
+      _(Bihash[:key => 'value'].to_proc.call(:key)).must_equal 'value'
     end
   end
 
   describe '#to_s' do
     it 'should return a nice string representing the bihash' do
-      bh = Bihash[:k1 => 'v1', :k2 => [:v2], :k3 => {:k4 => 'v4'}]
-      bh.to_s.must_equal 'Bihash[:k1=>"v1", :k2=>[:v2], :k3=>{:k4=>"v4"}]'
+      h = {:k1 => 'v1', :k2 => [:v2], :k3 => {:k4 => 'v4'}}
+      bh = Bihash[h]
+      keys_and_values_to_s = h.to_s.delete_prefix('{').delete_suffix('}')
+      _(bh.to_s).must_equal "Bihash[#{keys_and_values_to_s}]"
     end
 
     it 'should be aliased to #inspect' do
       bh = Bihash.new
-      bh.method(:inspect).must_equal bh.method(:to_s)
+      _(bh.method(:inspect)).must_equal bh.method(:to_s)
     end
   end
 
   describe '#values_at' do
     it 'should return an array of values corresponding to the given keys' do
-      Bihash[1 => :one, 2 => :two].values_at(1, 2).must_equal [:one, :two]
-      Bihash[1 => :one, 2 => :two].values_at(:one, :two).must_equal [1, 2]
-      Bihash[1 => :one, 2 => :two].values_at(1, :two).must_equal [:one, 2]
+      _(Bihash[1 => :one, 2 => :two].values_at(1, 2)).must_equal [:one, :two]
+      _(Bihash[1 => :one, 2 => :two].values_at(:one, :two)).must_equal [1, 2]
+      _(Bihash[1 => :one, 2 => :two].values_at(1, :two)).must_equal [:one, 2]
     end
 
     it 'should use the default if a given key is not found' do
       bh = Bihash.new(404)
       bh[1] = :one
       bh[2] = :two
-      bh.values_at(1, 2, 3).must_equal [:one, :two, 404]
-      bh.values_at(:one, :two, :three).must_equal [1, 2, 404]
+      _(bh.values_at(1, 2, 3)).must_equal [:one, :two, 404]
+      _(bh.values_at(:one, :two, :three)).must_equal [1, 2, 404]
     end
 
     it 'should not duplicate entries if a key equals its value' do
-      Bihash[:key => :key].values_at(:key).must_equal [:key]
+      _(Bihash[:key => :key].values_at(:key)).must_equal [:key]
     end
 
     it 'should return an empty array with no args' do
-      Bihash[:key => 'value'].values_at.must_equal []
+      _(Bihash[:key => 'value'].values_at).must_equal []
     end
   end
 
   describe '#initialize' do
-    it 'should raise RuntimeError if called on a frozen bihash' do
-      -> { Bihash.new.freeze.send(:initialize) }.must_raise RuntimeError
+    it 'should raise FrozenError if called on a frozen bihash' do
+      _(-> { Bihash.new.freeze.send(:initialize) }).must_raise FrozenError
     end
   end
 end