4 files changed, 58 insertions, 84 deletions
diff --git a/spec/ruby/core/hash/shared/replace.rb b/spec/ruby/core/hash/shared/replace.rb
deleted file mode 100644
index bea64384bb..0000000000
--- a/spec/ruby/core/hash/shared/replace.rb
+++ /dev/null
@@ -1,51 +0,0 @@
-describe :hash_replace, shared: true do
-  it "replaces the contents of self with other" do
-    h = { a: 1, b: 2 }
-    h.send(@method, c: -1, d: -2).should equal(h)
-    h.should == { c: -1, d: -2 }
-  end
-
-  it "tries to convert the passed argument to a hash using #to_hash" do
-    obj = mock('{1=>2,3=>4}')
-    obj.should_receive(:to_hash).and_return({ 1 => 2, 3 => 4 })
-
-    h = {}
-    h.send(@method, obj)
-    h.should == { 1 => 2, 3 => 4 }
-  end
-
-  it "calls to_hash on hash subclasses" do
-    h = {}
-    h.send(@method, HashSpecs::ToHashHash[1 => 2])
-    h.should == { 1 => 2 }
-  end
-
-  it "does not transfer default values" do
-    hash_a = {}
-    hash_b = Hash.new(5)
-    hash_a.send(@method, hash_b)
-    hash_a.default.should == 5
-
-    hash_a = {}
-    hash_b = Hash.new { |h, k| k * 2 }
-    hash_a.send(@method, hash_b)
-    hash_a.default(5).should == 10
-
-    hash_a = Hash.new { |h, k| k * 5 }
-    hash_b = Hash.new(-> { raise "Should not invoke lambda" })
-    hash_a.send(@method, hash_b)
-    hash_a.default.should == hash_b.default
-  end
-
-  it "raises a FrozenError if called on a frozen instance that would not be modified" do
-    -> do
-      HashSpecs.frozen_hash.send(@method, HashSpecs.frozen_hash)
-    end.should raise_error(FrozenError)
-  end
-
-  it "raises a FrozenError if called on a frozen instance that is modified" do
-    -> do
-      HashSpecs.frozen_hash.send(@method, HashSpecs.empty_frozen_hash)
-    end.should raise_error(FrozenError)
-  end
-end
diff --git a/spec/ruby/core/hash/shared/select.rb b/spec/ruby/core/hash/shared/select.rb
index 5170af50d6..fbeff07330 100644
--- a/spec/ruby/core/hash/shared/select.rb
+++ b/spec/ruby/core/hash/shared/select.rb
@@ -40,6 +40,27 @@ describe :hash_select, shared: true do
     @empty.send(@method).should be_an_instance_of(Enumerator)
   end
 
+  it "does not retain the default value" do
+    h = Hash.new(1)
+    h.send(@method) { true }.default.should be_nil
+    h[:a] = 1
+    h.send(@method) { true }.default.should be_nil
+  end
+
+  it "does not retain the default_proc" do
+    pr = proc { |h, k| h[k] = [] }
+    h = Hash.new(&pr)
+    h.send(@method) { true }.default_proc.should be_nil
+    h[:a] = 1
+    h.send(@method) { true }.default_proc.should be_nil
+  end
+
+  it "retains compare_by_identity flag" do
+    h = { a: 9, c: 4 }.compare_by_identity
+    h2 = h.send(@method) { |k, _| k == :a }
+    h2.compare_by_identity?.should == true
+  end
+
   it_should_behave_like :hash_iteration_no_block
 
   before :each do
diff --git a/spec/ruby/core/hash/shared/store.rb b/spec/ruby/core/hash/shared/store.rb
index b823ea45ca..72a462a42f 100644
--- a/spec/ruby/core/hash/shared/store.rb
+++ b/spec/ruby/core/hash/shared/store.rb
@@ -9,7 +9,7 @@ describe :hash_store, shared: true do
 
   it "duplicates string keys using dup semantics" do
     # dup doesn't copy singleton methods
-    key = "foo"
+    key = +"foo"
     def key.reverse() "bar" end
     h = {}
     h.send(@method, key, 0)
@@ -44,7 +44,7 @@ describe :hash_store, shared: true do
   end
 
   it "duplicates and freezes string keys" do
-    key = "foo"
+    key = +"foo"
     h = {}
     h.send(@method, key, 0)
     key << "bar"
@@ -75,8 +75,8 @@ describe :hash_store, shared: true do
 
   it "keeps the existing String key in the hash if there is a matching one" do
     h = { "a" => 1, "b" => 2, "c" => 3, "d" => 4 }
-    key1 = "foo"
-    key2 = "foo"
+    key1 = "foo".dup
+    key2 = "foo".dup
     key1.should_not equal(key2)
     h[key1] = 41
     frozen_key = h.keys.last
@@ -91,9 +91,9 @@ describe :hash_store, shared: true do
   end
 
   it "does not raise an exception if changing the value of an existing key during iteration" do
-      hash = {1 => 2, 3 => 4, 5 => 6}
-      hash.each { hash.send(@method, 1, :foo) }
-      hash.should == {1 => :foo, 3 => 4, 5 => 6}
+    hash = {1 => 2, 3 => 4, 5 => 6}
+    hash.each { hash.send(@method, 1, :foo) }
+    hash.should == {1 => :foo, 3 => 4, 5 => 6}
   end
 
   it "does not dispatch to hash for Boolean, Integer, Float, String, or Symbol" do
diff --git a/spec/ruby/core/hash/shared/to_s.rb b/spec/ruby/core/hash/shared/to_s.rb
index 2db3a96583..e116b8878b 100644
--- a/spec/ruby/core/hash/shared/to_s.rb
+++ b/spec/ruby/core/hash/shared/to_s.rb
@@ -4,14 +4,8 @@ require_relative '../fixtures/classes'
 describe :hash_to_s, shared: true do
   it "returns a string representation with same order as each()" do
     h = { a: [1, 2], b: -2, d: -6, nil => nil }
-
-    pairs = []
-    h.each do |key, value|
-      pairs << key.inspect + '=>' + value.inspect
-    end
-
-    str = '{' + pairs.join(', ') + '}'
-    h.send(@method).should == str
+    expected = ruby_version_is("3.4") ? "{a: [1, 2], b: -2, d: -6, nil => nil}" : "{:a=>[1, 2], :b=>-2, :d=>-6, nil=>nil}"
+    h.send(@method).should == expected
   end
 
   it "calls #inspect on keys and values" do
@@ -19,31 +13,31 @@ describe :hash_to_s, shared: true do
     val = mock('val')
     key.should_receive(:inspect).and_return('key')
     val.should_receive(:inspect).and_return('val')
-
-    { key => val }.send(@method).should == '{key=>val}'
+    expected = ruby_version_is("3.4") ? "{key => val}" : "{key=>val}"
+    { key => val }.send(@method).should == expected
   end
 
   it "does not call #to_s on a String returned from #inspect" do
-    str = "abc"
+    str = +"abc"
     str.should_not_receive(:to_s)
-
-    { a: str }.send(@method).should == '{:a=>"abc"}'
+    expected = ruby_version_is("3.4") ? '{a: "abc"}' : '{:a=>"abc"}'
+    { a: str }.send(@method).should == expected
   end
 
   it "calls #to_s on the object returned from #inspect if the Object isn't a String" do
     obj = mock("Hash#inspect/to_s calls #to_s")
     obj.should_receive(:inspect).and_return(obj)
     obj.should_receive(:to_s).and_return("abc")
-
-    { a: obj }.send(@method).should == "{:a=>abc}"
+    expected = ruby_version_is("3.4") ? "{a: abc}" : "{:a=>abc}"
+    { a: obj }.send(@method).should == expected
   end
 
   it "does not call #to_str on the object returned from #inspect when it is not a String" do
     obj = mock("Hash#inspect/to_s does not call #to_str")
     obj.should_receive(:inspect).and_return(obj)
     obj.should_not_receive(:to_str)
-
-    { a: obj }.send(@method).should =~ /^\{:a=>#<MockObject:0x[0-9a-f]+>\}$/
+    expected_pattern = ruby_version_is("3.4") ? /^\{a: #<MockObject:0x[0-9a-f]+>\}$/ : /^\{:a=>#<MockObject:0x[0-9a-f]+>\}$/
+    { a: obj }.send(@method).should =~ expected_pattern
   end
 
   it "does not call #to_str on the object returned from #to_s when it is not a String" do
@@ -51,8 +45,8 @@ describe :hash_to_s, shared: true do
     obj.should_receive(:inspect).and_return(obj)
     obj.should_receive(:to_s).and_return(obj)
     obj.should_not_receive(:to_str)
-
-    { a: obj }.send(@method).should =~ /^\{:a=>#<MockObject:0x[0-9a-f]+>\}$/
+    expected_pattern = ruby_version_is("3.4") ? /^\{a: #<MockObject:0x[0-9a-f]+>\}$/ : /^\{:a=>#<MockObject:0x[0-9a-f]+>\}$/
+    { a: obj }.send(@method).should =~ expected_pattern
   end
 
   it "does not swallow exceptions raised by #to_s" do
@@ -66,24 +60,34 @@ describe :hash_to_s, shared: true do
   it "handles hashes with recursive values" do
     x = {}
     x[0] = x
-    x.send(@method).should == '{0=>{...}}'
+    expected = ruby_version_is("3.4") ? '{0 => {...}}' : '{0=>{...}}'
+    x.send(@method).should == expected
 
     x = {}
     y = {}
     x[0] = y
     y[1] = x
-    x.send(@method).should == "{0=>{1=>{...}}}"
-    y.send(@method).should == "{1=>{0=>{...}}}"
+    expected_x = ruby_version_is("3.4") ? '{0 => {1 => {...}}}' : '{0=>{1=>{...}}}'
+    expected_y = ruby_version_is("3.4") ? '{1 => {0 => {...}}}' : '{1=>{0=>{...}}}'
+    x.send(@method).should == expected_x
+    y.send(@method).should == expected_y
   end
 
   it "does not raise if inspected result is not default external encoding" do
     utf_16be = mock("utf_16be")
-    utf_16be.should_receive(:inspect).and_return(%<"utf_16be \u3042">.encode!(Encoding::UTF_16BE))
-
-    {a: utf_16be}.send(@method).should == '{:a=>"utf_16be \u3042"}'
+    utf_16be.should_receive(:inspect).and_return(%<"utf_16be \u3042">.encode(Encoding::UTF_16BE))
+    expected = ruby_version_is("3.4") ? '{a: "utf_16be \u3042"}' : '{:a=>"utf_16be \u3042"}'
+    {a: utf_16be}.send(@method).should == expected
   end
 
   it "works for keys and values whose #inspect return a frozen String" do
-    { true => false }.to_s.should == "{true=>false}"
+    expected = ruby_version_is("3.4") ? "{true => false}" : "{true=>false}"
+    { true => false }.to_s.should == expected
+  end
+
+  ruby_version_is "3.4" do
+    it "adds quotes to symbol keys that are not valid symbol literals" do
+      { "needs-quotes": 1 }.send(@method).should == '{"needs-quotes": 1}'
+    end
   end
 end