Update to ruby/spec@83e26c9

7 files changed, 280 insertions, 294 deletions

diff --git a/spec/ruby/core/objectspace/weakkeymap/clear_spec.rb b/spec/ruby/core/objectspace/weakkeymap/clear_spec.rb
index 8050e2c307..b1804ec9b0 100644
--- a/spec/ruby/core/objectspace/weakkeymap/clear_spec.rb
+++ b/spec/ruby/core/objectspace/weakkeymap/clear_spec.rb
@@ -1,27 +1,25 @@
 require_relative '../../../spec_helper'
 
-ruby_version_is '3.3' do
-  describe "ObjectSpace::WeakKeyMap#clear" do
-    it "removes all the entries" do
-      m = ObjectSpace::WeakKeyMap.new
+describe "ObjectSpace::WeakKeyMap#clear" do
+  it "removes all the entries" do
+    m = ObjectSpace::WeakKeyMap.new
 
-      key = Object.new
-      value = Object.new
-      m[key] = value
+    key = Object.new
+    value = Object.new
+    m[key] = value
 
-      key2 = Object.new
-      value2 = Object.new
-      m[key2] = value2
+    key2 = Object.new
+    value2 = Object.new
+    m[key2] = value2
 
-      m.clear
+    m.clear
 
-      m.key?(key).should == false
-      m.key?(key2).should == false
-    end
+    m.key?(key).should == false
+    m.key?(key2).should == false
+  end
 
-    it "returns self" do
-      m = ObjectSpace::WeakKeyMap.new
-      m.clear.should.equal?(m)
-    end
+  it "returns self" do
+    m = ObjectSpace::WeakKeyMap.new
+    m.clear.should.equal?(m)
   end
 end
diff --git a/spec/ruby/core/objectspace/weakkeymap/delete_spec.rb b/spec/ruby/core/objectspace/weakkeymap/delete_spec.rb
index 3cd61355d6..ad32c2c75e 100644
--- a/spec/ruby/core/objectspace/weakkeymap/delete_spec.rb
+++ b/spec/ruby/core/objectspace/weakkeymap/delete_spec.rb
@@ -1,51 +1,49 @@
 require_relative '../../../spec_helper'
 
-ruby_version_is '3.3' do
-  describe "ObjectSpace::WeakKeyMap#delete" do
-    it "removes the entry and returns the deleted value" do
-      m = ObjectSpace::WeakKeyMap.new
-      key = Object.new
-      value = Object.new
-      m[key] = value
-
-      m.delete(key).should == value
-      m.key?(key).should == false
-    end
+describe "ObjectSpace::WeakKeyMap#delete" do
+  it "removes the entry and returns the deleted value" do
+    m = ObjectSpace::WeakKeyMap.new
+    key = Object.new
+    value = Object.new
+    m[key] = value
+
+    m.delete(key).should == value
+    m.key?(key).should == false
+  end
 
-    it "uses equality semantic" do
-      m = ObjectSpace::WeakKeyMap.new
-      key = "foo".upcase
-      value = Object.new
-      m[key] = value
+  it "uses equality semantic" do
+    m = ObjectSpace::WeakKeyMap.new
+    key = "foo".upcase
+    value = Object.new
+    m[key] = value
 
-      m.delete("foo".upcase).should == value
-      m.key?(key).should == false
-    end
+    m.delete("foo".upcase).should == value
+    m.key?(key).should == false
+  end
 
-    it "calls supplied block if the key is not found" do
-      key = Object.new
-      m = ObjectSpace::WeakKeyMap.new
-      return_value = m.delete(key) do |yielded_key|
-        yielded_key.should == key
-        5
-      end
-      return_value.should == 5
+  it "calls supplied block if the key is not found" do
+    key = Object.new
+    m = ObjectSpace::WeakKeyMap.new
+    return_value = m.delete(key) do |yielded_key|
+      yielded_key.should == key
+      5
     end
+    return_value.should == 5
+  end
 
-    it "returns nil if the key is not found when no block is given" do
-      m = ObjectSpace::WeakKeyMap.new
-      m.delete(Object.new).should == nil
-    end
+  it "returns nil if the key is not found when no block is given" do
+    m = ObjectSpace::WeakKeyMap.new
+    m.delete(Object.new).should == nil
+  end
 
-    it "returns nil when a key cannot be garbage collected" do
-      map = ObjectSpace::WeakKeyMap.new
+  it "returns nil when a key cannot be garbage collected" do
+    map = ObjectSpace::WeakKeyMap.new
 
-      map.delete(1).should == nil
-      map.delete(1.0).should == nil
-      map.delete(:a).should == nil
-      map.delete(true).should == nil
-      map.delete(false).should == nil
-      map.delete(nil).should == nil
-    end
+    map.delete(1).should == nil
+    map.delete(1.0).should == nil
+    map.delete(:a).should == nil
+    map.delete(true).should == nil
+    map.delete(false).should == nil
+    map.delete(nil).should == nil
   end
 end
diff --git a/spec/ruby/core/objectspace/weakkeymap/element_reference_spec.rb b/spec/ruby/core/objectspace/weakkeymap/element_reference_spec.rb
index 51368e8d3b..53eff79c40 100644
--- a/spec/ruby/core/objectspace/weakkeymap/element_reference_spec.rb
+++ b/spec/ruby/core/objectspace/weakkeymap/element_reference_spec.rb
@@ -1,107 +1,105 @@
 require_relative '../../../spec_helper'
 require_relative 'fixtures/classes'
 
-ruby_version_is "3.3" do
-  describe "ObjectSpace::WeakKeyMap#[]" do
-    it "is faithful to the map's content" do
-      map = ObjectSpace::WeakKeyMap.new
-      key1, key2 = %w[a b].map(&:upcase)
-      ref1, ref2 = %w[x y]
-      map[key1] = ref1
-      map[key1].should == ref1
-      map[key1] = ref1
-      map[key1].should == ref1
-      map[key2] = ref2
-      map[key1].should == ref1
-      map[key2].should == ref2
-    end
-
-    it "compares keys with #eql? semantics" do
-      map = ObjectSpace::WeakKeyMap.new
-      key = [1.0]
-      map[key] = "x"
-      map[[1]].should == nil
-      map[[1.0]].should == "x"
-      key.should == [1.0] # keep the key alive until here to keep the map entry
-
-      map = ObjectSpace::WeakKeyMap.new
-      key = [1]
-      map[key] = "x"
-      map[[1.0]].should == nil
-      map[[1]].should == "x"
-      key.should == [1] # keep the key alive until here to keep the map entry
-
-      map = ObjectSpace::WeakKeyMap.new
-      key1, key2 = %w[a a].map(&:upcase)
-      ref = "x"
-      map[key1] = ref
-      map[key2].should == ref
-    end
-
-    it "compares key via #hash first" do
-      x = mock('0')
-      x.should_receive(:hash).and_return(0)
-
-      map = ObjectSpace::WeakKeyMap.new
-      key = 'foo'
-      map[key] = :bar
-      map[x].should == nil
-    end
-
-    it "does not compare keys with different #hash values via #eql?" do
-      x = mock('x')
-      x.should_not_receive(:eql?)
-      x.stub!(:hash).and_return(0)
-
-      y = mock('y')
-      y.should_not_receive(:eql?)
-      y.stub!(:hash).and_return(1)
-
-      map = ObjectSpace::WeakKeyMap.new
-      map[y] = 1
-      map[x].should == nil
-    end
-
-    it "compares keys with the same #hash value via #eql?" do
-      x = mock('x')
-      x.should_receive(:eql?).and_return(true)
-      x.stub!(:hash).and_return(42)
-
-      y = mock('y')
-      y.should_not_receive(:eql?)
-      y.stub!(:hash).and_return(42)
-
-      map = ObjectSpace::WeakKeyMap.new
-      map[y] = 1
-      map[x].should == 1
-    end
-
-    it "finds a value via an identical key even when its #eql? isn't reflexive" do
-      x = mock('x')
-      x.should_receive(:hash).at_least(1).and_return(42)
-      x.stub!(:eql?).and_return(false) # Stubbed for clarity and latitude in implementation; not actually sent by MRI.
-
-      map = ObjectSpace::WeakKeyMap.new
-      map[x] = :x
-      map[x].should == :x
-    end
-
-    it "supports keys with private #hash method" do
-      key = WeakKeyMapSpecs::KeyWithPrivateHash.new
-      map = ObjectSpace::WeakKeyMap.new
-      map[key] = 42
-      map[key].should == 42
-    end
-
-    it "returns nil and does not raise error when a key cannot be garbage collected" do
-      map = ObjectSpace::WeakKeyMap.new
-
-      map[1].should == nil
-      map[1.0].should == nil
-      map[:a].should == nil
-      map[true].should == nil
-      map[false].should == nil
-      map[nil].should == nil
-    end
+describe "ObjectSpace::WeakKeyMap#[]" do
+  it "is faithful to the map's content" do
+    map = ObjectSpace::WeakKeyMap.new
+    key1, key2 = %w[a b].map(&:upcase)
+    ref1, ref2 = %w[x y]
+    map[key1] = ref1
+    map[key1].should == ref1
+    map[key1] = ref1
+    map[key1].should == ref1
+    map[key2] = ref2
+    map[key1].should == ref1
+    map[key2].should == ref2
+  end
+
+  it "compares keys with #eql? semantics" do
+    map = ObjectSpace::WeakKeyMap.new
+    key = [1.0]
+    map[key] = "x"
+    map[[1]].should == nil
+    map[[1.0]].should == "x"
+    key.should == [1.0] # keep the key alive until here to keep the map entry
+
+    map = ObjectSpace::WeakKeyMap.new
+    key = [1]
+    map[key] = "x"
+    map[[1.0]].should == nil
+    map[[1]].should == "x"
+    key.should == [1] # keep the key alive until here to keep the map entry
+
+    map = ObjectSpace::WeakKeyMap.new
+    key1, key2 = %w[a a].map(&:upcase)
+    ref = "x"
+    map[key1] = ref
+    map[key2].should == ref
+  end
+
+  it "compares key via #hash first" do
+    x = mock('0')
+    x.should_receive(:hash).and_return(0)
+
+    map = ObjectSpace::WeakKeyMap.new
+    key = 'foo'
+    map[key] = :bar
+    map[x].should == nil
+  end
+
+  it "does not compare keys with different #hash values via #eql?" do
+    x = mock('x')
+    x.should_not_receive(:eql?)
+    x.stub!(:hash).and_return(0)
+
+    y = mock('y')
+    y.should_not_receive(:eql?)
+    y.stub!(:hash).and_return(1)
+
+    map = ObjectSpace::WeakKeyMap.new
+    map[y] = 1
+    map[x].should == nil
+  end
+
+  it "compares keys with the same #hash value via #eql?" do
+    x = mock('x')
+    x.should_receive(:eql?).and_return(true)
+    x.stub!(:hash).and_return(42)
+
+    y = mock('y')
+    y.should_not_receive(:eql?)
+    y.stub!(:hash).and_return(42)
+
+    map = ObjectSpace::WeakKeyMap.new
+    map[y] = 1
+    map[x].should == 1
+  end
+
+  it "finds a value via an identical key even when its #eql? isn't reflexive" do
+    x = mock('x')
+    x.should_receive(:hash).at_least(1).and_return(42)
+    x.stub!(:eql?).and_return(false) # Stubbed for clarity and latitude in implementation; not actually sent by MRI.
+
+    map = ObjectSpace::WeakKeyMap.new
+    map[x] = :x
+    map[x].should == :x
+  end
+
+  it "supports keys with private #hash method" do
+    key = WeakKeyMapSpecs::KeyWithPrivateHash.new
+    map = ObjectSpace::WeakKeyMap.new
+    map[key] = 42
+    map[key].should == 42
+  end
+
+  it "returns nil and does not raise error when a key cannot be garbage collected" do
+    map = ObjectSpace::WeakKeyMap.new
+
+    map[1].should == nil
+    map[1.0].should == nil
+    map[:a].should == nil
+    map[true].should == nil
+    map[false].should == nil
+    map[nil].should == nil
   end
 end
diff --git a/spec/ruby/core/objectspace/weakkeymap/element_set_spec.rb b/spec/ruby/core/objectspace/weakkeymap/element_set_spec.rb
index 8db8d780c7..c480aa661a 100644
--- a/spec/ruby/core/objectspace/weakkeymap/element_set_spec.rb
+++ b/spec/ruby/core/objectspace/weakkeymap/element_set_spec.rb
@@ -1,82 +1,80 @@
 require_relative '../../../spec_helper'
 
-ruby_version_is "3.3" do
-  describe "ObjectSpace::WeakKeyMap#[]=" do
-    def should_accept(map, key, value)
-      (map[key] = value).should == value
-      map.should.key?(key)
-      map[key].should == value
-    end
+describe "ObjectSpace::WeakKeyMap#[]=" do
+  def should_accept(map, key, value)
+    (map[key] = value).should == value
+    map.should.key?(key)
+    map[key].should == value
+  end
+
+  it "is correct" do
+    map = ObjectSpace::WeakKeyMap.new
+    key1, key2 = %w[a b].map(&:upcase)
+    ref1, ref2 = %w[x y]
+    should_accept(map, key1, ref1)
+    should_accept(map, key1, ref1)
+    should_accept(map, key2, ref2)
+    map[key1].should == ref1
+  end
+
+  it "requires the keys to implement #hash" do
+    map = ObjectSpace::WeakKeyMap.new
+    -> { map[BasicObject.new] = 1 }.should raise_error(NoMethodError, /undefined method [`']hash' for an instance of BasicObject/)
+  end
 
-    it "is correct" do
+  it "accepts frozen keys or values" do
+    map = ObjectSpace::WeakKeyMap.new
+    x = Object.new
+    should_accept(map, x, true)
+    should_accept(map, x, false)
+    should_accept(map, x, 42)
+    should_accept(map, x, :foo)
+
+    y = Object.new.freeze
+    should_accept(map, x, y)
+    should_accept(map, y, x)
+  end
+
+  it "does not duplicate and freeze String keys (like Hash#[]= does)" do
+    map = ObjectSpace::WeakKeyMap.new
+    key = +"a"
+    map[key] = 1
+
+    map.getkey("a").should.equal? key
+    map.getkey("a").should_not.frozen?
+
+    key.should == "a" # keep the key alive until here to keep the map entry
+  end
+
+  context "a key cannot be garbage collected" do
+    it "raises ArgumentError when Integer is used as a key" do
       map = ObjectSpace::WeakKeyMap.new
-      key1, key2 = %w[a b].map(&:upcase)
-      ref1, ref2 = %w[x y]
-      should_accept(map, key1, ref1)
-      should_accept(map, key1, ref1)
-      should_accept(map, key2, ref2)
-      map[key1].should == ref1
+      -> { map[1] = "x" }.should raise_error(ArgumentError, /WeakKeyMap (keys )?must be garbage collectable/)
     end
 
-    it "requires the keys to implement #hash" do
+    it "raises ArgumentError when Float is used as a key" do
       map = ObjectSpace::WeakKeyMap.new
-      -> { map[BasicObject.new] = 1 }.should raise_error(NoMethodError, /undefined method [`']hash' for an instance of BasicObject/)
+      -> { map[1.0] = "x" }.should raise_error(ArgumentError, /WeakKeyMap (keys )?must be garbage collectable/)
     end
 
-    it "accepts frozen keys or values" do
+    it "raises ArgumentError when Symbol is used as a key" do
       map = ObjectSpace::WeakKeyMap.new
-      x = Object.new
-      should_accept(map, x, true)
-      should_accept(map, x, false)
-      should_accept(map, x, 42)
-      should_accept(map, x, :foo)
-
-      y = Object.new.freeze
-      should_accept(map, x, y)
-      should_accept(map, y, x)
+      -> { map[:a] = "x" }.should raise_error(ArgumentError, /WeakKeyMap (keys )?must be garbage collectable/)
     end
 
-    it "does not duplicate and freeze String keys (like Hash#[]= does)" do
+    it "raises ArgumentError when true is used as a key" do
       map = ObjectSpace::WeakKeyMap.new
-      key = +"a"
-      map[key] = 1
-
-      map.getkey("a").should.equal? key
-      map.getkey("a").should_not.frozen?
-
-      key.should == "a" # keep the key alive until here to keep the map entry
+      -> { map[true] = "x" }.should raise_error(ArgumentError, /WeakKeyMap (keys )?must be garbage collectable/)
     end
 
-    context "a key cannot be garbage collected" do
-      it "raises ArgumentError when Integer is used as a key" do
-        map = ObjectSpace::WeakKeyMap.new
-        -> { map[1] = "x" }.should raise_error(ArgumentError, /WeakKeyMap (keys )?must be garbage collectable/)
-      end
-
-      it "raises ArgumentError when Float is used as a key" do
-        map = ObjectSpace::WeakKeyMap.new
-        -> { map[1.0] = "x" }.should raise_error(ArgumentError, /WeakKeyMap (keys )?must be garbage collectable/)
-      end
-
-      it "raises ArgumentError when Symbol is used as a key" do
-        map = ObjectSpace::WeakKeyMap.new
-        -> { map[:a] = "x" }.should raise_error(ArgumentError, /WeakKeyMap (keys )?must be garbage collectable/)
-      end
-
-      it "raises ArgumentError when true is used as a key" do
-        map = ObjectSpace::WeakKeyMap.new
-        -> { map[true] = "x" }.should raise_error(ArgumentError, /WeakKeyMap (keys )?must be garbage collectable/)
-      end
-
-      it "raises ArgumentError when false is used as a key" do
-        map = ObjectSpace::WeakKeyMap.new
-        -> { map[false] = "x" }.should raise_error(ArgumentError, /WeakKeyMap (keys )?must be garbage collectable/)
-      end
+    it "raises ArgumentError when false is used as a key" do
+      map = ObjectSpace::WeakKeyMap.new
+      -> { map[false] = "x" }.should raise_error(ArgumentError, /WeakKeyMap (keys )?must be garbage collectable/)
+    end
 
-      it "raises ArgumentError when nil is used as a key" do
-        map = ObjectSpace::WeakKeyMap.new
-        -> { map[nil] = "x" }.should raise_error(ArgumentError, /WeakKeyMap (keys )?must be garbage collectable/)
-      end
+    it "raises ArgumentError when nil is used as a key" do
+      map = ObjectSpace::WeakKeyMap.new
+      -> { map[nil] = "x" }.should raise_error(ArgumentError, /WeakKeyMap (keys )?must be garbage collectable/)
     end
   end
 end
diff --git a/spec/ruby/core/objectspace/weakkeymap/getkey_spec.rb b/spec/ruby/core/objectspace/weakkeymap/getkey_spec.rb
index 8a2dbf809d..0c8dec8aea 100644
--- a/spec/ruby/core/objectspace/weakkeymap/getkey_spec.rb
+++ b/spec/ruby/core/objectspace/weakkeymap/getkey_spec.rb
@@ -1,28 +1,26 @@
 require_relative '../../../spec_helper'
 
-ruby_version_is "3.3" do
-  describe "ObjectSpace::WeakKeyMap#getkey" do
-    it "returns the existing equal key" do
-      map = ObjectSpace::WeakKeyMap.new
-      key1, key2 = %w[a a].map(&:upcase)
+describe "ObjectSpace::WeakKeyMap#getkey" do
+  it "returns the existing equal key" do
+    map = ObjectSpace::WeakKeyMap.new
+    key1, key2 = %w[a a].map(&:upcase)
 
-      map[key1] = true
-      map.getkey(key2).should equal(key1)
-      map.getkey("X").should == nil
+    map[key1] = true
+    map.getkey(key2).should equal(key1)
+    map.getkey("X").should == nil
 
-      key1.should == "A" # keep the key alive until here to keep the map entry
-      key2.should == "A" # keep the key alive until here to keep the map entry
-    end
+    key1.should == "A" # keep the key alive until here to keep the map entry
+    key2.should == "A" # keep the key alive until here to keep the map entry
+  end
 
-    it "returns nil when a key cannot be garbage collected" do
-      map = ObjectSpace::WeakKeyMap.new
+  it "returns nil when a key cannot be garbage collected" do
+    map = ObjectSpace::WeakKeyMap.new
 
-      map.getkey(1).should == nil
-      map.getkey(1.0).should == nil
-      map.getkey(:a).should == nil
-      map.getkey(true).should == nil
-      map.getkey(false).should == nil
-      map.getkey(nil).should == nil
-    end
+    map.getkey(1).should == nil
+    map.getkey(1.0).should == nil
+    map.getkey(:a).should == nil
+    map.getkey(true).should == nil
+    map.getkey(false).should == nil
+    map.getkey(nil).should == nil
   end
 end
diff --git a/spec/ruby/core/objectspace/weakkeymap/inspect_spec.rb b/spec/ruby/core/objectspace/weakkeymap/inspect_spec.rb
index 319f050970..b6bb469158 100644
--- a/spec/ruby/core/objectspace/weakkeymap/inspect_spec.rb
+++ b/spec/ruby/core/objectspace/weakkeymap/inspect_spec.rb
@@ -1,21 +1,19 @@
 require_relative '../../../spec_helper'
 
-ruby_version_is "3.3" do
-  describe "ObjectSpace::WeakKeyMap#inspect" do
-    it "only displays size in output" do
-      map = ObjectSpace::WeakKeyMap.new
-      key1, key2, key3 = "foo", "bar", "bar"
-      map.inspect.should =~ /\A\#<ObjectSpace::WeakKeyMap:0x\h+ size=0>\z/
-      map[key1] = 1
-      map.inspect.should =~ /\A\#<ObjectSpace::WeakKeyMap:0x\h+ size=1>\z/
-      map[key2] = 2
-      map.inspect.should =~ /\A\#<ObjectSpace::WeakKeyMap:0x\h+ size=2>\z/
-      map[key3] = 3
-      map.inspect.should =~ /\A\#<ObjectSpace::WeakKeyMap:0x\h+ size=2>\z/
+describe "ObjectSpace::WeakKeyMap#inspect" do
+  it "only displays size in output" do
+    map = ObjectSpace::WeakKeyMap.new
+    key1, key2, key3 = "foo", "bar", "bar"
+    map.inspect.should =~ /\A\#<ObjectSpace::WeakKeyMap:0x\h+ size=0>\z/
+    map[key1] = 1
+    map.inspect.should =~ /\A\#<ObjectSpace::WeakKeyMap:0x\h+ size=1>\z/
+    map[key2] = 2
+    map.inspect.should =~ /\A\#<ObjectSpace::WeakKeyMap:0x\h+ size=2>\z/
+    map[key3] = 3
+    map.inspect.should =~ /\A\#<ObjectSpace::WeakKeyMap:0x\h+ size=2>\z/
 
-      key1.should == "foo" # keep the key alive until here to keep the map entry
-      key2.should == "bar" # keep the key alive until here to keep the map entry
-      key3.should == "bar" # keep the key alive until here to keep the map entry
-    end
+    key1.should == "foo" # keep the key alive until here to keep the map entry
+    key2.should == "bar" # keep the key alive until here to keep the map entry
+    key3.should == "bar" # keep the key alive until here to keep the map entry
   end
 end
diff --git a/spec/ruby/core/objectspace/weakkeymap/key_spec.rb b/spec/ruby/core/objectspace/weakkeymap/key_spec.rb
index a9a2e12432..e0b6866671 100644
--- a/spec/ruby/core/objectspace/weakkeymap/key_spec.rb
+++ b/spec/ruby/core/objectspace/weakkeymap/key_spec.rb
@@ -1,44 +1,42 @@
 require_relative '../../../spec_helper'
 
-ruby_version_is "3.3" do
-  describe "ObjectSpace::WeakKeyMap#key?" do
-    it "recognizes keys in use" do
-      map = ObjectSpace::WeakKeyMap.new
-      key1, key2 = %w[a b].map(&:upcase)
-      ref1, ref2 = %w[x y]
+describe "ObjectSpace::WeakKeyMap#key?" do
+  it "recognizes keys in use" do
+    map = ObjectSpace::WeakKeyMap.new
+    key1, key2 = %w[a b].map(&:upcase)
+    ref1, ref2 = %w[x y]
 
-      map[key1] = ref1
-      map.key?(key1).should == true
-      map[key1] = ref1
-      map.key?(key1).should == true
-      map[key2] = ref2
-      map.key?(key2).should == true
-    end
+    map[key1] = ref1
+    map.key?(key1).should == true
+    map[key1] = ref1
+    map.key?(key1).should == true
+    map[key2] = ref2
+    map.key?(key2).should == true
+  end
 
-    it "matches using equality semantics" do
-      map = ObjectSpace::WeakKeyMap.new
-      key1, key2 = %w[a a].map(&:upcase)
-      ref = "x"
-      map[key1] = ref
-      map.key?(key2).should == true
-    end
+  it "matches using equality semantics" do
+    map = ObjectSpace::WeakKeyMap.new
+    key1, key2 = %w[a a].map(&:upcase)
+    ref = "x"
+    map[key1] = ref
+    map.key?(key2).should == true
+  end
 
-    it "reports true if the pair exists and the value is nil" do
-      map = ObjectSpace::WeakKeyMap.new
-      key = Object.new
-      map[key] = nil
-      map.key?(key).should == true
-    end
+  it "reports true if the pair exists and the value is nil" do
+    map = ObjectSpace::WeakKeyMap.new
+    key = Object.new
+    map[key] = nil
+    map.key?(key).should == true
+  end
 
-    it "returns false when a key cannot be garbage collected" do
-      map = ObjectSpace::WeakKeyMap.new
+  it "returns false when a key cannot be garbage collected" do
+    map = ObjectSpace::WeakKeyMap.new
 
-      map.key?(1).should == false
-      map.key?(1.0).should == false
-      map.key?(:a).should == false
-      map.key?(true).should == false
-      map.key?(false).should == false
-      map.key?(nil).should == false
-    end
+    map.key?(1).should == false
+    map.key?(1.0).should == false
+    map.key?(:a).should == false
+    map.key?(true).should == false
+    map.key?(false).should == false
+    map.key?(nil).should == false
   end
 end