20 files changed, 712 insertions, 240 deletions

diff --git a/spec/ruby/core/range/bsearch_spec.rb b/spec/ruby/core/range/bsearch_spec.rb
index 9c93671d85..5254ab756c 100644
--- a/spec/ruby/core/range/bsearch_spec.rb
+++ b/spec/ruby/core/range/bsearch_spec.rb
@@ -9,22 +9,30 @@ describe "Range#bsearch" do
   it_behaves_like :enumeratorized_with_unknown_size, :bsearch, (1..3)
 
   it "raises a TypeError if the block returns an Object" do
-    -> { (0..1).bsearch { Object.new } }.should raise_error(TypeError)
+    -> { (0..1).bsearch { Object.new } }.should raise_error(TypeError, "wrong argument type Object (must be numeric, true, false or nil)")
   end
 
-  it "raises a TypeError if the block returns a String" do
-    -> { (0..1).bsearch { "1" } }.should raise_error(TypeError)
+  it "raises a TypeError if the block returns a String and boundaries are Integer values" do
+    -> { (0..1).bsearch { "1" } }.should raise_error(TypeError, "wrong argument type String (must be numeric, true, false or nil)")
+  end
+
+  it "raises a TypeError if the block returns a String and boundaries are Float values" do
+    -> { (0.0..1.0).bsearch { "1" } }.should raise_error(TypeError, "wrong argument type String (must be numeric, true, false or nil)")
   end
 
   it "raises a TypeError if the Range has Object values" do
     value = mock("range bsearch")
     r = Range.new value, value
 
-    -> { r.bsearch { true } }.should raise_error(TypeError)
+    -> { r.bsearch { true } }.should raise_error(TypeError, "can't do binary search for MockObject")
   end
 
   it "raises a TypeError if the Range has String values" do
-    -> { ("a".."e").bsearch { true } }.should raise_error(TypeError)
+    -> { ("a".."e").bsearch { true } }.should raise_error(TypeError, "can't do binary search for String")
+  end
+
+  it "raises TypeError when non-Numeric begin/end and block not passed" do
+    -> { ("a".."e").bsearch }.should raise_error(TypeError, "can't do binary search for String")
   end
 
   context "with Integer values" do
@@ -94,6 +102,10 @@ describe "Range#bsearch" do
       (4..2).bsearch { 0 }.should == nil
       (4..2).bsearch { -1 }.should == nil
     end
+
+    it "returns enumerator when block not passed" do
+      (0...3).bsearch.kind_of?(Enumerator).should == true
+    end
   end
 
   context "with Float values" do
@@ -156,7 +168,6 @@ describe "Range#bsearch" do
 
       it "returns nil if the block returns greater than zero for every element" do
         (0.3..3.0).bsearch { |x| x <=> -1 }.should be_nil
-
       end
 
       it "returns nil if the block never returns zero" do
@@ -213,6 +224,10 @@ describe "Range#bsearch" do
         (0...inf).bsearch { |x| x >= Float::MAX ? 0 : 1 }.should == Float::MAX
       end
     end
+
+    it "returns enumerator when block not passed" do
+      (0.1...2.3).bsearch.kind_of?(Enumerator).should == true
+    end
   end
 
   context "with endless ranges and Integer values" do
@@ -250,6 +265,10 @@ describe "Range#bsearch" do
         [1, 2, 3].should include(result)
       end
     end
+
+    it "returns enumerator when block not passed" do
+      eval("(-2..)").bsearch.kind_of?(Enumerator).should == true
+    end
   end
 
   context "with endless ranges and Float values" do
@@ -327,8 +346,11 @@ describe "Range#bsearch" do
         eval("(0.0...)").bsearch { 0 }.should != inf
       end
     end
-  end
 
+    it "returns enumerator when block not passed" do
+      eval("(0.1..)").bsearch.kind_of?(Enumerator).should == true
+    end
+  end
 
   context "with beginless ranges and Integer values" do
     context "with a block returning true or false" do
@@ -361,6 +383,10 @@ describe "Range#bsearch" do
         [1, 2, 3].should include(result)
       end
     end
+
+    it "returns enumerator when block not passed" do
+      (..10).bsearch.kind_of?(Enumerator).should == true
+    end
   end
 
   context "with beginless ranges and Float values" do
@@ -432,5 +458,9 @@ describe "Range#bsearch" do
         (...inf).bsearch { |x| 3 - x }.should == 3
       end
     end
+
+    it "returns enumerator when block not passed" do
+      (..-0.1).bsearch.kind_of?(Enumerator).should == true
+    end
   end
 end
diff --git a/spec/ruby/core/range/case_compare_spec.rb b/spec/ruby/core/range/case_compare_spec.rb
index 4a3faa3163..c9b253f0a5 100644
--- a/spec/ruby/core/range/case_compare_spec.rb
+++ b/spec/ruby/core/range/case_compare_spec.rb
@@ -10,4 +10,10 @@ describe "Range#===" do
 
   it_behaves_like :range_cover_and_include, :===
   it_behaves_like :range_cover, :===
+
+  ruby_bug "#19533", ""..."3.3" do
+    it "returns true on any value if begin and end are both nil" do
+      (nil..nil).should === 1
+    end
+  end
 end
diff --git a/spec/ruby/core/range/cover_spec.rb b/spec/ruby/core/range/cover_spec.rb
index fa881607e9..c05bb50614 100644
--- a/spec/ruby/core/range/cover_spec.rb
+++ b/spec/ruby/core/range/cover_spec.rb
@@ -1,4 +1,4 @@
-# -*- encoding: binary -*-
+# encoding: binary
 require_relative '../../spec_helper'
 require_relative 'shared/cover_and_include'
 require_relative 'shared/cover'
@@ -7,4 +7,8 @@ describe "Range#cover?" do
   it_behaves_like :range_cover_and_include, :cover?
   it_behaves_like :range_cover, :cover?
   it_behaves_like :range_cover_subrange, :cover?
+
+  it "covers U+9995 in the range U+0999..U+9999" do
+    ("\u{999}".."\u{9999}").cover?("\u{9995}").should be_true
+  end
 end
diff --git a/spec/ruby/core/range/each_spec.rb b/spec/ruby/core/range/each_spec.rb
index ecae17c881..f10330d61d 100644
--- a/spec/ruby/core/range/each_spec.rb
+++ b/spec/ruby/core/range/each_spec.rb
@@ -40,21 +40,21 @@ describe "Range#each" do
 
   it "works with endless ranges" do
     a = []
-    eval("(-2..)").each { |x| break if x > 2; a << x }
+    (-2..).each { |x| break if x > 2; a << x }
     a.should == [-2, -1, 0, 1, 2]
 
     a = []
-    eval("(-2...)").each { |x| break if x > 2; a << x }
+    (-2...).each { |x| break if x > 2; a << x }
     a.should == [-2, -1, 0, 1, 2]
   end
 
   it "works with String endless ranges" do
     a = []
-    eval("('A'..)").each { |x| break if x > "D"; a << x }
+    ('A'..).each { |x| break if x > "D"; a << x }
     a.should == ["A", "B", "C", "D"]
 
     a = []
-    eval("('A'...)").each { |x| break if x > "D"; a << x }
+    ('A'...).each { |x| break if x > "D"; a << x }
     a.should == ["A", "B", "C", "D"]
   end
 
@@ -82,27 +82,14 @@ describe "Range#each" do
     enum.to_a.should == [1, 2, 3]
   end
 
-  ruby_version_is "3.1" do
-    it "supports Time objects that respond to #succ" do
-      t = Time.utc(1970)
-      def t.succ; self + 1 end
-      t_succ = t.succ
-      def t_succ.succ; self + 1; end
+  it "supports Time objects that respond to #succ" do
+    t = Time.utc(1970)
+    def t.succ; self + 1 end
+    t_succ = t.succ
+    def t_succ.succ; self + 1; end
 
-      (t..t_succ).to_a.should == [Time.utc(1970), Time.utc(1970, nil, nil, nil, nil, 1)]
-      (t...t_succ).to_a.should == [Time.utc(1970)]
-    end
-  end
-
-  ruby_version_is ""..."3.1" do
-    it "raises a TypeError if the first element is a Time object even if it responds to #succ" do
-      t = Time.utc(1970)
-      def t.succ; self + 1 end
-      t_succ = t.succ
-      def t_succ.succ; self + 1; end
-
-      -> { (t..t_succ).each { |i| i } }.should raise_error(TypeError)
-    end
+    (t..t_succ).to_a.should == [Time.utc(1970), Time.utc(1970, nil, nil, nil, nil, 1)]
+    (t...t_succ).to_a.should == [Time.utc(1970)]
   end
 
   it "passes each Symbol element by using #succ" do
diff --git a/spec/ruby/core/range/frozen_spec.rb b/spec/ruby/core/range/frozen_spec.rb
index 298ffc87cb..8dab5e5339 100644
--- a/spec/ruby/core/range/frozen_spec.rb
+++ b/spec/ruby/core/range/frozen_spec.rb
@@ -2,26 +2,24 @@ require_relative '../../spec_helper'
 
 # There is no Range#frozen? method but this feels like the best place for these specs
 describe "Range#frozen?" do
-  ruby_version_is "3.0" do
-    it "is true for literal ranges" do
-      (1..2).should.frozen?
-      (1..).should.frozen?
-      (..1).should.frozen?
-    end
+  it "is true for literal ranges" do
+    (1..2).should.frozen?
+    (1..).should.frozen?
+    (..1).should.frozen?
+  end
 
-    it "is true for Range.new" do
-      Range.new(1, 2).should.frozen?
-      Range.new(1, nil).should.frozen?
-      Range.new(nil, 1).should.frozen?
-    end
+  it "is true for Range.new" do
+    Range.new(1, 2).should.frozen?
+    Range.new(1, nil).should.frozen?
+    Range.new(nil, 1).should.frozen?
+  end
 
-    it "is false for instances of a subclass of Range" do
-      sub_range = Class.new(Range).new(1, 2)
-      sub_range.should_not.frozen?
-    end
+  it "is false for instances of a subclass of Range" do
+    sub_range = Class.new(Range).new(1, 2)
+    sub_range.should_not.frozen?
+  end
 
-    it "is false for Range.allocate" do
-      Range.allocate.should_not.frozen?
-    end
+  it "is false for Range.allocate" do
+    Range.allocate.should_not.frozen?
   end
 end
diff --git a/spec/ruby/core/range/include_spec.rb b/spec/ruby/core/range/include_spec.rb
index b2c7a54545..449e18985b 100644
--- a/spec/ruby/core/range/include_spec.rb
+++ b/spec/ruby/core/range/include_spec.rb
@@ -1,4 +1,4 @@
-# -*- encoding: binary -*-
+# encoding: binary
 require_relative '../../spec_helper'
 require_relative 'shared/cover_and_include'
 require_relative 'shared/include'
@@ -7,4 +7,8 @@ require_relative 'shared/cover'
 describe "Range#include?" do
   it_behaves_like :range_cover_and_include, :include?
   it_behaves_like :range_include, :include?
+
+  it "does not include U+9995 in the range U+0999..U+9999" do
+    ("\u{999}".."\u{9999}").include?("\u{9995}").should be_false
+  end
 end
diff --git a/spec/ruby/core/range/initialize_spec.rb b/spec/ruby/core/range/initialize_spec.rb
index 8a6ca65daa..c653caf0c6 100644
--- a/spec/ruby/core/range/initialize_spec.rb
+++ b/spec/ruby/core/range/initialize_spec.rb
@@ -27,18 +27,9 @@ describe "Range#initialize" do
     -> { @range.send(:initialize, 1, 3, 5, 7, 9) }.should raise_error(ArgumentError)
   end
 
-  ruby_version_is ""..."3.0" do
-    it "raises a NameError if called on an already initialized Range" do
-      -> { (0..1).send(:initialize, 1, 3) }.should raise_error(NameError)
-      -> { (0..1).send(:initialize, 1, 3, true) }.should raise_error(NameError)
-    end
-  end
-
-  ruby_version_is "3.0" do
-    it "raises a FrozenError if called on an already initialized Range" do
-      -> { (0..1).send(:initialize, 1, 3) }.should raise_error(FrozenError)
-      -> { (0..1).send(:initialize, 1, 3, true) }.should raise_error(FrozenError)
-    end
+  it "raises a FrozenError if called on an already initialized Range" do
+    -> { (0..1).send(:initialize, 1, 3) }.should raise_error(FrozenError)
+    -> { (0..1).send(:initialize, 1, 3, true) }.should raise_error(FrozenError)
   end
 
   it "raises an ArgumentError if arguments don't respond to <=>" do
diff --git a/spec/ruby/core/range/last_spec.rb b/spec/ruby/core/range/last_spec.rb
index 6698686dd5..82b3e2ff53 100644
--- a/spec/ruby/core/range/last_spec.rb
+++ b/spec/ruby/core/range/last_spec.rb
@@ -8,10 +8,8 @@ describe "Range#last" do
     (1..5).last(3).should == [3, 4, 5]
   end
 
-  ruby_bug '#18994', '2.7'...'3.2' do
-    it "returns the specified number if elements for single element inclusive range" do
-      (1..1).last(1).should == [1]
-    end
+  it "returns the specified number if elements for single element inclusive range" do
+    (1..1).last(1).should == [1]
   end
 
   it "returns an empty array for an empty Range" do
diff --git a/spec/ruby/core/range/max_spec.rb b/spec/ruby/core/range/max_spec.rb
index 6c9ada2a3c..09371f5298 100644
--- a/spec/ruby/core/range/max_spec.rb
+++ b/spec/ruby/core/range/max_spec.rb
@@ -50,18 +50,30 @@ describe "Range#max" do
     -> { eval("(1..)").max }.should raise_error(RangeError)
   end
 
-  ruby_version_is "3.0" do
-    it "returns the end point for beginless ranges" do
-      (..1).max.should == 1
-      (..1.0).max.should == 1.0
-    end
+  it "returns the end point for beginless ranges" do
+    (..1).max.should == 1
+    (..1.0).max.should == 1.0
+  end
 
-    it "raises for an exclusive beginless range" do
+  ruby_version_is ""..."4.0" do
+    it "raises for an exclusive beginless Integer range" do
       -> {
         (...1).max
       }.should raise_error(TypeError, 'cannot exclude end value with non Integer begin value')
     end
   end
+
+  ruby_version_is "4.0" do
+    it "returns the end point for exclusive beginless Integer ranges" do
+      (...1).max.should == 0
+    end
+  end
+
+  it "raises for an exclusive beginless non Integer range" do
+    -> {
+      (...1.0).max
+    }.should raise_error(TypeError, 'cannot exclude non Integer end value')
+  end
 end
 
 describe "Range#max given a block" do
diff --git a/spec/ruby/core/range/member_spec.rb b/spec/ruby/core/range/member_spec.rb
index ab61f92951..78299ae9e5 100644
--- a/spec/ruby/core/range/member_spec.rb
+++ b/spec/ruby/core/range/member_spec.rb
@@ -1,4 +1,4 @@
-# -*- encoding: binary -*-
+# encoding: binary
 require_relative '../../spec_helper'
 require_relative 'shared/cover_and_include'
 require_relative 'shared/include'
diff --git a/spec/ruby/core/range/minmax_spec.rb b/spec/ruby/core/range/minmax_spec.rb
index b2b4fd61a1..6651ae3726 100644
--- a/spec/ruby/core/range/minmax_spec.rb
+++ b/spec/ruby/core/range/minmax_spec.rb
@@ -86,24 +86,22 @@ describe 'Range#minmax' do
         /cannot get the maximum of beginless range with custom comparison method|cannot get the minimum of beginless range/)
     end
 
-    ruby_bug "#17014", ""..."3.0" do
-      it 'should return nil pair if beginning and end are equal without iterating the range' do
-        @x.should_not_receive(:succ)
+    it 'should return nil pair if beginning and end are equal without iterating the range' do
+      @x.should_not_receive(:succ)
 
-        (@x...@x).minmax.should == [nil, nil]
-      end
+      (@x...@x).minmax.should == [nil, nil]
+    end
 
-      it 'should return nil pair if beginning is greater than end without iterating the range' do
-        @y.should_not_receive(:succ)
+    it 'should return nil pair if beginning is greater than end without iterating the range' do
+      @y.should_not_receive(:succ)
 
-        (@y...@x).minmax.should == [nil, nil]
-      end
+      (@y...@x).minmax.should == [nil, nil]
+    end
 
-      it 'should return the minimum and maximum values for a non-numeric range by iterating the range' do
-        @x.should_receive(:succ).once.and_return(@y)
+    it 'should return the minimum and maximum values for a non-numeric range by iterating the range' do
+      @x.should_receive(:succ).once.and_return(@y)
 
-        (@x...@y).minmax.should == [@x, @x]
-      end
+      (@x...@y).minmax.should == [@x, @x]
     end
 
     it 'should return the minimum and maximum values for a numeric range' do
diff --git a/spec/ruby/core/range/new_spec.rb b/spec/ruby/core/range/new_spec.rb
index 40df914b83..3cab887799 100644
--- a/spec/ruby/core/range/new_spec.rb
+++ b/spec/ruby/core/range/new_spec.rb
@@ -66,14 +66,12 @@ describe "Range.new" do
       range_exclude.should_not == range_include
     end
 
-    ruby_version_is "3.0" do
-      it "creates a frozen range if the class is Range.class" do
-        Range.new(1, 2).should.frozen?
-      end
-
-      it "does not create a frozen range if the class is not Range.class" do
-        Class.new(Range).new(1, 2).should_not.frozen?
-      end
+    it "creates a frozen range if the class is Range.class" do
+      Range.new(1, 2).should.frozen?
+    end
+
+    it "does not create a frozen range if the class is not Range.class" do
+      Class.new(Range).new(1, 2).should_not.frozen?
     end
   end
 end
diff --git a/spec/ruby/core/range/overlap_spec.rb b/spec/ruby/core/range/overlap_spec.rb
new file mode 100644
index 0000000000..9b6fc13493
--- /dev/null
+++ b/spec/ruby/core/range/overlap_spec.rb
@@ -0,0 +1,89 @@
+require_relative '../../spec_helper'
+
+ruby_version_is '3.3' do
+  describe "Range#overlap?" do
+    it "returns true if other Range overlaps self" do
+      (0..2).overlap?(1..3).should == true
+      (1..3).overlap?(0..2).should == true
+      (0..2).overlap?(0..2).should == true
+      (0..3).overlap?(1..2).should == true
+      (1..2).overlap?(0..3).should == true
+
+      ('a'..'c').overlap?('b'..'d').should == true
+    end
+
+    it "returns false if other Range does not overlap self" do
+      (0..2).overlap?(3..4).should == false
+      (0..2).overlap?(-4..-1).should == false
+
+      ('a'..'c').overlap?('d'..'f').should == false
+    end
+
+    it "raises TypeError when called with non-Range argument" do
+      -> {
+        (0..2).overlap?(1)
+      }.should raise_error(TypeError, "wrong argument type Integer (expected Range)")
+    end
+
+    it "returns true when beginningless and endless Ranges overlap" do
+      (0..2).overlap?(..3).should == true
+      (0..2).overlap?(..1).should == true
+      (0..2).overlap?(..0).should == true
+
+      (..3).overlap?(0..2).should == true
+      (..1).overlap?(0..2).should == true
+      (..0).overlap?(0..2).should == true
+
+      (0..2).overlap?(-1..).should == true
+      (0..2).overlap?(1..).should == true
+      (0..2).overlap?(2..).should == true
+
+      (-1..).overlap?(0..2).should == true
+      (1..).overlap?(0..2).should == true
+      (2..).overlap?(0..2).should == true
+
+      (0..).overlap?(2..).should == true
+      (..0).overlap?(..2).should == true
+    end
+
+    it "returns false when beginningless and endless Ranges do not overlap" do
+      (0..2).overlap?(..-1).should == false
+      (0..2).overlap?(3..).should == false
+
+      (..-1).overlap?(0..2).should == false
+      (3..).overlap?(0..2).should == false
+    end
+
+    it "returns false when Ranges are not compatible" do
+      (0..2).overlap?('a'..'d').should == false
+    end
+
+    it "return false when self is empty" do
+      (2..0).overlap?(1..3).should == false
+      (2...2).overlap?(1..3).should == false
+      (1...1).overlap?(1...1).should == false
+      (2..0).overlap?(2..0).should == false
+
+      ('c'..'a').overlap?('b'..'d').should == false
+      ('a'...'a').overlap?('b'..'d').should == false
+      ('b'...'b').overlap?('b'...'b').should == false
+      ('c'...'a').overlap?('c'...'a').should == false
+    end
+
+    it "return false when other Range is empty" do
+      (1..3).overlap?(2..0).should == false
+      (1..3).overlap?(2...2).should == false
+
+      ('b'..'d').overlap?('c'..'a').should == false
+      ('b'..'d').overlap?('c'...'c').should == false
+    end
+
+    it "takes into account exclusive end" do
+      (0...2).overlap?(2..4).should == false
+      (2..4).overlap?(0...2).should == false
+
+      ('a'...'c').overlap?('c'..'e').should == false
+      ('c'..'e').overlap?('a'...'c').should == false
+    end
+  end
+end
diff --git a/spec/ruby/core/range/reverse_each_spec.rb b/spec/ruby/core/range/reverse_each_spec.rb
new file mode 100644
index 0000000000..56390cc0da
--- /dev/null
+++ b/spec/ruby/core/range/reverse_each_spec.rb
@@ -0,0 +1,103 @@
+require_relative '../../spec_helper'
+
+ruby_version_is "3.3" do
+  describe "Range#reverse_each" do
+    it "traverses the Range in reverse order and passes each element to block" do
+      a = []
+      (1..3).reverse_each { |i| a << i }
+      a.should == [3, 2, 1]
+
+      a = []
+      (1...3).reverse_each { |i| a << i }
+      a.should == [2, 1]
+    end
+
+    it "returns self" do
+      r = (1..3)
+      r.reverse_each { |x| }.should equal(r)
+    end
+
+    it "returns an Enumerator if no block given" do
+      enum = (1..3).reverse_each
+      enum.should be_an_instance_of(Enumerator)
+      enum.to_a.should == [3, 2, 1]
+    end
+
+    it "raises a TypeError for endless Ranges of Integers" do
+      -> {
+        (1..).reverse_each.take(3)
+      }.should raise_error(TypeError, "can't iterate from NilClass")
+    end
+
+    it "raises a TypeError for endless Ranges of non-Integers" do
+      -> {
+        ("a"..).reverse_each.take(3)
+      }.should raise_error(TypeError, "can't iterate from NilClass")
+    end
+
+    context "Integer boundaries" do
+      it "supports beginningless Ranges" do
+        (..5).reverse_each.take(3).should == [5, 4, 3]
+      end
+    end
+
+    context "non-Integer boundaries" do
+      it "uses #succ to iterate a Range of non-Integer elements" do
+        y = mock('y')
+        x = mock('x')
+
+        x.should_receive(:succ).any_number_of_times.and_return(y)
+        x.should_receive(:<=>).with(y).any_number_of_times.and_return(-1)
+        x.should_receive(:<=>).with(x).any_number_of_times.and_return(0)
+        y.should_receive(:<=>).with(x).any_number_of_times.and_return(1)
+        y.should_receive(:<=>).with(y).any_number_of_times.and_return(0)
+
+        a = []
+        (x..y).each { |i| a << i }
+        a.should == [x, y]
+      end
+
+      it "uses #succ to iterate a Range of Strings" do
+        a = []
+        ('A'..'D').reverse_each { |i| a << i }
+        a.should == ['D','C','B','A']
+      end
+
+      it "uses #succ to iterate a Range of Symbols" do
+        a = []
+        (:A..:D).reverse_each { |i| a << i }
+        a.should == [:D, :C, :B, :A]
+      end
+
+      it "raises a TypeError when `begin` value does not respond to #succ" do
+        -> { (Time.now..Time.now).reverse_each { |x| x } }.should raise_error(TypeError, /can't iterate from Time/)
+        -> { (//..//).reverse_each { |x| x } }.should raise_error(TypeError, /can't iterate from Regexp/)
+        -> { ([]..[]).reverse_each { |x| x } }.should raise_error(TypeError, /can't iterate from Array/)
+      end
+
+      it "does not support beginningless Ranges" do
+        -> {
+          (..'a').reverse_each { |x| x }
+        }.should raise_error(TypeError, /can't iterate from NilClass/)
+      end
+    end
+
+    context "when no block is given" do
+      describe "returned Enumerator size" do
+        it "returns the Range size when Range size is finite" do
+          (1..3).reverse_each.size.should == 3
+        end
+
+        ruby_bug "#20936", "3.4"..."4.0" do
+          it "returns Infinity when Range size is infinite" do
+            (..3).reverse_each.size.should == Float::INFINITY
+          end
+        end
+
+        it "returns nil when Range size is unknown" do
+          ('a'..'z').reverse_each.size.should == nil
+        end
+      end
+    end
+  end
+end
diff --git a/spec/ruby/core/range/shared/cover.rb b/spec/ruby/core/range/shared/cover.rb
index 0b41a26455..eaefb45942 100644
--- a/spec/ruby/core/range/shared/cover.rb
+++ b/spec/ruby/core/range/shared/cover.rb
@@ -1,4 +1,4 @@
-# -*- encoding: binary -*-
+# encoding: binary
 require_relative '../../../spec_helper'
 require_relative '../fixtures/classes'
 
diff --git a/spec/ruby/core/range/shared/cover_and_include.rb b/spec/ruby/core/range/shared/cover_and_include.rb
index 7028afaa89..13fc5e1790 100644
--- a/spec/ruby/core/range/shared/cover_and_include.rb
+++ b/spec/ruby/core/range/shared/cover_and_include.rb
@@ -1,4 +1,4 @@
-# -*- encoding: binary -*-
+# encoding: binary
 require_relative '../../../spec_helper'
 
 describe :range_cover_and_include, shared: true do
@@ -20,8 +20,8 @@ describe :range_cover_and_include, shared: true do
   end
 
   it "returns true if other is an element of self for endless ranges" do
-    eval("(1..)").send(@method, 2.4).should == true
-    eval("(0.5...)").send(@method, 2.4).should == true
+    (1..).send(@method, 2.4).should == true
+    (0.5...).send(@method, 2.4).should == true
   end
 
   it "returns true if other is an element of self for beginless ranges" do
@@ -29,6 +29,17 @@ describe :range_cover_and_include, shared: true do
     (...10.5).send(@method, 2.4).should == true
   end
 
+  it "returns false if values are not comparable" do
+    (1..10).send(@method, nil).should == false
+    (1...10).send(@method, nil).should == false
+
+    (..10).send(@method, nil).should == false
+    (...10).send(@method, nil).should == false
+
+    (1..).send(@method, nil).should == false
+    (1...).send(@method, nil).should == false
+  end
+
   it "compares values using <=>" do
     rng = (1..5)
     m = mock("int")
@@ -57,7 +68,6 @@ describe :range_cover_and_include, shared: true do
   it "returns true if argument is less than the last value of the range and greater than the first value" do
     (20..30).send(@method, 28).should be_true
     ('e'..'h').send(@method, 'g').should be_true
-    ("\u{999}".."\u{9999}").send @method, "\u{9995}"
   end
 
   it "returns true if argument is sole element in the range" do
diff --git a/spec/ruby/core/range/shared/include.rb b/spec/ruby/core/range/shared/include.rb
index c6c5c2becf..15a0e5fb9f 100644
--- a/spec/ruby/core/range/shared/include.rb
+++ b/spec/ruby/core/range/shared/include.rb
@@ -1,4 +1,4 @@
-# -*- encoding: binary -*-
+# encoding: binary
 require_relative '../../../spec_helper'
 require_relative '../fixtures/classes'
 
diff --git a/spec/ruby/core/range/size_spec.rb b/spec/ruby/core/range/size_spec.rb
index 9b625c9963..1a3ddd197e 100644
--- a/spec/ruby/core/range/size_spec.rb
+++ b/spec/ruby/core/range/size_spec.rb
@@ -4,52 +4,31 @@ describe "Range#size" do
   it "returns the number of elements in the range" do
     (1..16).size.should == 16
     (1...16).size.should == 15
-
-    (1.0..16.0).size.should == 16
-    (1.0...16.0).size.should == 15
-    (1.0..15.9).size.should == 15
-    (1.1..16.0).size.should == 15
-    (1.1..15.9).size.should == 15
   end
 
   it "returns 0 if last is less than first" do
     (16..0).size.should == 0
-    (16.0..0.0).size.should == 0
-    (Float::INFINITY..0).size.should == 0
   end
 
   it 'returns Float::INFINITY for increasing, infinite ranges' do
     (0..Float::INFINITY).size.should == Float::INFINITY
-    (-Float::INFINITY..0).size.should == Float::INFINITY
-    (-Float::INFINITY..Float::INFINITY).size.should == Float::INFINITY
   end
 
   it 'returns Float::INFINITY for endless ranges if the start is numeric' do
     eval("(1..)").size.should == Float::INFINITY
-    eval("(0.5...)").size.should == Float::INFINITY
   end
 
   it 'returns nil for endless ranges if the start is not numeric' do
     eval("('z'..)").size.should == nil
-    eval("([]...)").size.should == nil
-  end
-
-  ruby_version_is ""..."3.2" do
-    it 'returns Float::INFINITY for all beginless ranges' do
-      (..1).size.should == Float::INFINITY
-      (...0.5).size.should == Float::INFINITY
-      (..nil).size.should == Float::INFINITY
-      (...'o').size.should == Float::INFINITY
-    end
   end
 
-  ruby_version_is "3.2" do
-    it 'returns Float::INFINITY for all beginless ranges if the start is numeric' do
+  ruby_version_is ""..."3.4" do
+    it 'returns Float::INFINITY for all beginless ranges if the end is numeric' do
       (..1).size.should == Float::INFINITY
       (...0.5).size.should == Float::INFINITY
     end
 
-    it 'returns nil for all beginless ranges if the start is numeric' do
+    it 'returns nil for all beginless ranges if the end is not numeric' do
       (...'o').size.should == nil
     end
 
@@ -58,6 +37,54 @@ describe "Range#size" do
     end
   end
 
+  ruby_version_is ""..."3.4" do
+    it "returns the number of elements in the range" do
+      (1.0..16.0).size.should == 16
+      (1.0...16.0).size.should == 15
+      (1.0..15.9).size.should == 15
+      (1.1..16.0).size.should == 15
+      (1.1..15.9).size.should == 15
+    end
+
+    it "returns 0 if last is less than first" do
+      (16.0..0.0).size.should == 0
+      (Float::INFINITY..0).size.should == 0
+    end
+
+    it 'returns Float::INFINITY for increasing, infinite ranges' do
+      (-Float::INFINITY..0).size.should == Float::INFINITY
+      (-Float::INFINITY..Float::INFINITY).size.should == Float::INFINITY
+    end
+
+    it 'returns Float::INFINITY for endless ranges if the start is numeric' do
+      eval("(0.5...)").size.should == Float::INFINITY
+    end
+
+    it 'returns nil for endless ranges if the start is not numeric' do
+      eval("([]...)").size.should == nil
+    end
+  end
+
+  ruby_version_is "3.4" do
+    it 'raises TypeError if a range is not iterable' do
+      -> { (1.0..16.0).size }.should raise_error(TypeError, /can't iterate from/)
+      -> { (1.0...16.0).size }.should raise_error(TypeError, /can't iterate from/)
+      -> { (1.0..15.9).size }.should raise_error(TypeError, /can't iterate from/)
+      -> { (1.1..16.0).size }.should raise_error(TypeError, /can't iterate from/)
+      -> { (1.1..15.9).size }.should raise_error(TypeError, /can't iterate from/)
+      -> { (16.0..0.0).size }.should raise_error(TypeError, /can't iterate from/)
+      -> { (Float::INFINITY..0).size }.should raise_error(TypeError, /can't iterate from/)
+      -> { (-Float::INFINITY..0).size }.should raise_error(TypeError, /can't iterate from/)
+      -> { (-Float::INFINITY..Float::INFINITY).size }.should raise_error(TypeError, /can't iterate from/)
+      -> { (..1).size }.should raise_error(TypeError, /can't iterate from/)
+      -> { (...0.5).size }.should raise_error(TypeError, /can't iterate from/)
+      -> { (..nil).size }.should raise_error(TypeError, /can't iterate from/)
+      -> { (...'o').size }.should raise_error(TypeError, /can't iterate from/)
+      -> { eval("(0.5...)").size }.should raise_error(TypeError, /can't iterate from/)
+      -> { eval("([]...)").size }.should raise_error(TypeError, /can't iterate from/)
+    end
+  end
+
   it "returns nil if first and last are not Numeric" do
     (:a..:z).size.should be_nil
     ('a'..'z').size.should be_nil
diff --git a/spec/ruby/core/range/step_spec.rb b/spec/ruby/core/range/step_spec.rb
index 9024636d55..0d0caf746d 100644
--- a/spec/ruby/core/range/step_spec.rb
+++ b/spec/ruby/core/range/step_spec.rb
@@ -10,44 +10,50 @@ describe "Range#step" do
     r.step { }.should equal(r)
   end
 
-  it "raises TypeError if step" do
-    obj = mock("mock")
-    -> { (1..10).step(obj) { } }.should raise_error(TypeError)
-  end
+  ruby_version_is ""..."3.4" do
+    it "calls #to_int to coerce step to an Integer" do
+      obj = mock("Range#step")
+      obj.should_receive(:to_int).and_return(1)
 
-  it "calls #to_int to coerce step to an Integer" do
-    obj = mock("Range#step")
-    obj.should_receive(:to_int).and_return(1)
+      (1..2).step(obj) { |x| ScratchPad << x }
+      ScratchPad.recorded.should eql([1, 2])
+    end
 
-    (1..2).step(obj) { |x| ScratchPad << x }
-    ScratchPad.recorded.should eql([1, 2])
-  end
+    it "raises a TypeError if step does not respond to #to_int" do
+      obj = mock("Range#step non-integer")
 
-  it "raises a TypeError if step does not respond to #to_int" do
-    obj = mock("Range#step non-integer")
+      -> { (1..2).step(obj) { } }.should raise_error(TypeError)
+    end
 
-    -> { (1..2).step(obj) { } }.should raise_error(TypeError)
-  end
+    it "raises a TypeError if #to_int does not return an Integer" do
+      obj = mock("Range#step non-integer")
+      obj.should_receive(:to_int).and_return("1")
 
-  it "raises a TypeError if #to_int does not return an Integer" do
-    obj = mock("Range#step non-integer")
-    obj.should_receive(:to_int).and_return("1")
+      -> { (1..2).step(obj) { } }.should raise_error(TypeError)
+    end
 
-    -> { (1..2).step(obj) { } }.should raise_error(TypeError)
-  end
+    it "raises a TypeError if the first element does not respond to #succ" do
+      obj = mock("Range#step non-comparable")
+      obj.should_receive(:<=>).with(obj).and_return(1)
 
-  it "coerces the argument to integer by invoking to_int" do
-    (obj = mock("2")).should_receive(:to_int).and_return(2)
-    res = []
-    (1..10).step(obj) {|x| res << x}
-    res.should == [1, 3, 5, 7, 9]
+      -> { (obj..obj).step { |x| x } }.should raise_error(TypeError)
+    end
   end
 
-  it "raises a TypeError if the first element does not respond to #succ" do
-    obj = mock("Range#step non-comparable")
-    obj.should_receive(:<=>).with(obj).and_return(1)
+  ruby_version_is "3.4" do
+    it "calls #coerce to coerce step to an Integer" do
+      obj = mock("Range#step")
+      obj.should_receive(:coerce).at_least(:once).and_return([1, 2])
+
+      (1..3).step(obj) { |x| ScratchPad << x }
+      ScratchPad.recorded.should eql([1, 3])
+    end
+
+    it "raises a TypeError if step does not respond to #coerce" do
+      obj = mock("Range#step non-coercible")
 
-    -> { (obj..obj).step { |x| x } }.should raise_error(TypeError)
+      -> { (1..2).step(obj) { } }.should raise_error(TypeError)
+    end
   end
 
   it "raises an ArgumentError if step is 0" do
@@ -58,8 +64,17 @@ describe "Range#step" do
     -> { (-1..1).step(0.0) { |x| x } }.should raise_error(ArgumentError)
   end
 
-  it "raises an ArgumentError if step is negative" do
-    -> { (-1..1).step(-2) { |x| x } }.should raise_error(ArgumentError)
+  ruby_version_is "3.4" do
+    it "does not raise an ArgumentError if step is 0 for non-numeric ranges" do
+      t = Time.utc(2023, 2, 24)
+      -> { (t..t+1).step(0) { break } }.should_not raise_error(ArgumentError)
+    end
+  end
+
+  ruby_version_is ""..."3.4" do
+    it "raises an ArgumentError if step is negative" do
+      -> { (-1..1).step(-2) { |x| x } }.should raise_error(ArgumentError)
+    end
   end
 
   describe "with inclusive end" do
@@ -78,6 +93,18 @@ describe "Range#step" do
         (-2..2).step(1.5) { |x| ScratchPad << x }
         ScratchPad.recorded.should eql([-2.0, -0.5, 1.0])
       end
+
+      ruby_version_is "3.4" do
+        it "does not iterate if step is negative for forward range" do
+          (-1..1).step(-1) { |x| ScratchPad << x }
+          ScratchPad.recorded.should eql([])
+        end
+
+        it "iterates backward if step is negative for backward range" do
+          (1..-1).step(-1) { |x| ScratchPad << x }
+          ScratchPad.recorded.should eql([1, 0, -1])
+        end
+      end
     end
 
     describe "and Float values" do
@@ -162,13 +189,96 @@ describe "Range#step" do
         -> { ("A".."G").step(2.0) { } }.should raise_error(TypeError)
       end
 
-      it "calls #succ on begin and each element returned by #succ" do
-        obj = mock("Range#step String start")
-        obj.should_receive(:<=>).exactly(3).times.and_return(-1, -1, -1, 0)
-        obj.should_receive(:succ).exactly(2).times.and_return(obj)
+      ruby_version_is ""..."3.4" do
+        it "calls #succ on begin and each element returned by #succ" do
+          obj = mock("Range#step String start")
+          obj.should_receive(:<=>).exactly(3).times.and_return(-1, -1, -1, 0)
+          obj.should_receive(:succ).exactly(2).times.and_return(obj)
 
-        (obj..obj).step { |x| ScratchPad << x }
-        ScratchPad.recorded.should == [obj, obj, obj]
+          (obj..obj).step { |x| ScratchPad << x }
+          ScratchPad.recorded.should == [obj, obj, obj]
+        end
+      end
+
+      ruby_version_is "3.4" do
+        it "yields String values adjusted by step and less than or equal to end" do
+          ("A".."AAA").step("A") { |x| ScratchPad << x }
+          ScratchPad.recorded.should == ["A", "AA", "AAA"]
+        end
+
+        it "raises a TypeError when passed an incompatible type step" do
+          -> { ("A".."G").step([]) { } }.should raise_error(TypeError)
+        end
+
+        it "calls #+ on begin and each element returned by #+" do
+          start = mock("Range#step String start")
+          stop = mock("Range#step String stop")
+
+          mid1 = mock("Range#step String mid1")
+          mid2 = mock("Range#step String mid2")
+
+          step = mock("Range#step String step")
+
+          # Deciding on the direction of iteration
+          start.should_receive(:<=>).with(stop).at_least(:twice).and_return(-1)
+          # Deciding whether the step moves iteration in the right direction
+          start.should_receive(:<=>).with(mid1).and_return(-1)
+          # Iteration 1
+          start.should_receive(:+).at_least(:once).with(step).and_return(mid1)
+          # Iteration 2
+          mid1.should_receive(:<=>).with(stop).and_return(-1)
+          mid1.should_receive(:+).with(step).and_return(mid2)
+          # Iteration 3
+          mid2.should_receive(:<=>).with(stop).and_return(0)
+
+          (start..stop).step(step) { |x| ScratchPad << x }
+          ScratchPad.recorded.should == [start, mid1, mid2]
+        end
+
+        it "iterates backward if the step is decreasing values, and the range is backward" do
+          start = mock("Range#step String start")
+          stop = mock("Range#step String stop")
+
+          mid1 = mock("Range#step String mid1")
+          mid2 = mock("Range#step String mid2")
+
+          step = mock("Range#step String step")
+
+          # Deciding on the direction of iteration
+          start.should_receive(:<=>).with(stop).at_least(:twice).and_return(1)
+          # Deciding whether the step moves iteration in the right direction
+          start.should_receive(:<=>).with(mid1).and_return(1)
+          # Iteration 1
+          start.should_receive(:+).at_least(:once).with(step).and_return(mid1)
+          # Iteration 2
+          mid1.should_receive(:<=>).with(stop).and_return(1)
+          mid1.should_receive(:+).with(step).and_return(mid2)
+          # Iteration 3
+          mid2.should_receive(:<=>).with(stop).and_return(0)
+
+          (start..stop).step(step) { |x| ScratchPad << x }
+          ScratchPad.recorded.should == [start, mid1, mid2]
+        end
+
+        it "does no iteration of the direction of the range and of the step don't match" do
+          start = mock("Range#step String start")
+          stop = mock("Range#step String stop")
+
+          mid1 = mock("Range#step String mid1")
+          mid2 = mock("Range#step String mid2")
+
+          step = mock("Range#step String step")
+
+          # Deciding on the direction of iteration: stop > start
+          start.should_receive(:<=>).with(stop).at_least(:twice).and_return(1)
+          # Deciding whether the step moves iteration in the right direction
+          # start + step < start, the direction is opposite to the range's
+          start.should_receive(:+).with(step).and_return(mid1)
+          start.should_receive(:<=>).with(mid1).and_return(-1)
+
+          (start..stop).step(step) { |x| ScratchPad << x }
+          ScratchPad.recorded.should == []
+        end
       end
     end
   end
@@ -212,13 +322,11 @@ describe "Range#step" do
         ScratchPad.recorded.should eql([1.0, 2.8, 4.6])
       end
 
-      ruby_version_is '3.1' do
-        it "correctly handles values near the upper limit" do # https://bugs.ruby-lang.org/issues/16612
-          (1.0...55.6).step(18.2) { |x| ScratchPad << x }
-          ScratchPad.recorded.should eql([1.0, 19.2, 37.4, 55.599999999999994])
+      it "correctly handles values near the upper limit" do # https://bugs.ruby-lang.org/issues/16612
+        (1.0...55.6).step(18.2) { |x| ScratchPad << x }
+        ScratchPad.recorded.should eql([1.0, 19.2, 37.4, 55.599999999999994])
 
-          (1.0...55.6).step(18.2).size.should == 4
-        end
+        (1.0...55.6).step(18.2).size.should == 4
       end
 
       it "handles infinite values at either end" do
@@ -266,18 +374,31 @@ describe "Range#step" do
     end
 
     describe "and String values" do
-      it "yields String values incremented by #succ and less than or equal to end when not passed a step" do
-        ("A"..."E").step { |x| ScratchPad << x }
-        ScratchPad.recorded.should == ["A", "B", "C", "D"]
-      end
+      ruby_version_is ""..."3.4" do
+        it "yields String values incremented by #succ and less than or equal to end when not passed a step" do
+          ("A"..."E").step { |x| ScratchPad << x }
+          ScratchPad.recorded.should == ["A", "B", "C", "D"]
+        end
 
-      it "yields String values incremented by #succ called Integer step times" do
-        ("A"..."G").step(2) { |x| ScratchPad << x }
-        ScratchPad.recorded.should == ["A", "C", "E"]
+        it "yields String values incremented by #succ called Integer step times" do
+          ("A"..."G").step(2) { |x| ScratchPad << x }
+          ScratchPad.recorded.should == ["A", "C", "E"]
+        end
+
+        it "raises a TypeError when passed a Float step" do
+          -> { ("A"..."G").step(2.0) { } }.should raise_error(TypeError)
+        end
       end
 
-      it "raises a TypeError when passed a Float step" do
-        -> { ("A"..."G").step(2.0) { } }.should raise_error(TypeError)
+      ruby_version_is "3.4" do
+        it "yields String values adjusted by step and less than or equal to end" do
+          ("A"..."AAA").step("A") { |x| ScratchPad << x }
+          ScratchPad.recorded.should == ["A", "AA"]
+        end
+
+        it "raises a TypeError when passed an incompatible type step" do
+          -> { ("A".."G").step([]) { } }.should raise_error(TypeError)
+        end
       end
     end
   end
@@ -285,123 +406,121 @@ describe "Range#step" do
   describe "with an endless range" do
     describe "and Integer values" do
       it "yield Integer values incremented by 1 when not passed a step" do
-        eval("(-2..)").step { |x| break if x > 2; ScratchPad << x }
+        (-2..).step { |x| break if x > 2; ScratchPad << x }
         ScratchPad.recorded.should eql([-2, -1, 0, 1, 2])
 
         ScratchPad.record []
-        eval("(-2...)").step { |x| break if x > 2; ScratchPad << x }
+        (-2...).step { |x| break if x > 2; ScratchPad << x }
         ScratchPad.recorded.should eql([-2, -1, 0, 1, 2])
       end
 
       it "yields Integer values incremented by an Integer step" do
-        eval("(-5..)").step(2) { |x| break if x > 3; ScratchPad << x }
+        (-5..).step(2) { |x| break if x > 3; ScratchPad << x }
         ScratchPad.recorded.should eql([-5, -3, -1, 1, 3])
 
         ScratchPad.record []
-        eval("(-5...)").step(2) { |x| break if x > 3; ScratchPad << x }
+        (-5...).step(2) { |x| break if x > 3; ScratchPad << x }
         ScratchPad.recorded.should eql([-5, -3, -1, 1, 3])
       end
 
       it "yields Float values incremented by a Float step" do
-        eval("(-2..)").step(1.5) { |x| break if x > 1.0; ScratchPad << x }
+        (-2..).step(1.5) { |x| break if x > 1.0; ScratchPad << x }
         ScratchPad.recorded.should eql([-2.0, -0.5, 1.0])
 
         ScratchPad.record []
-        eval("(-2..)").step(1.5) { |x| break if x > 1.0; ScratchPad << x }
+        (-2..).step(1.5) { |x| break if x > 1.0; ScratchPad << x }
         ScratchPad.recorded.should eql([-2.0, -0.5, 1.0])
       end
     end
 
     describe "and Float values" do
       it "yields Float values incremented by 1 and less than end when not passed a step" do
-        eval("(-2.0..)").step { |x| break if x > 1.5; ScratchPad << x }
+        (-2.0..).step { |x| break if x > 1.5; ScratchPad << x }
         ScratchPad.recorded.should eql([-2.0, -1.0, 0.0, 1.0])
 
         ScratchPad.record []
-        eval("(-2.0...)").step { |x| break if x > 1.5; ScratchPad << x }
+        (-2.0...).step { |x| break if x > 1.5; ScratchPad << x }
         ScratchPad.recorded.should eql([-2.0, -1.0, 0.0, 1.0])
       end
 
       it "yields Float values incremented by an Integer step" do
-        eval("(-5.0..)").step(2) { |x| break if x > 3.5; ScratchPad << x }
+        (-5.0..).step(2) { |x| break if x > 3.5; ScratchPad << x }
         ScratchPad.recorded.should eql([-5.0, -3.0, -1.0, 1.0, 3.0])
 
         ScratchPad.record []
-        eval("(-5.0...)").step(2) { |x| break if x > 3.5; ScratchPad << x }
+        (-5.0...).step(2) { |x| break if x > 3.5; ScratchPad << x }
         ScratchPad.recorded.should eql([-5.0, -3.0, -1.0, 1.0, 3.0])
       end
 
       it "yields Float values incremented by a Float step" do
-        eval("(-1.0..)").step(0.5) { |x| break if x > 0.6; ScratchPad << x }
+        (-1.0..).step(0.5) { |x| break if x > 0.6; ScratchPad << x }
         ScratchPad.recorded.should eql([-1.0, -0.5, 0.0, 0.5])
 
         ScratchPad.record []
-        eval("(-1.0...)").step(0.5) { |x| break if x > 0.6; ScratchPad << x }
+        (-1.0...).step(0.5) { |x| break if x > 0.6; ScratchPad << x }
         ScratchPad.recorded.should eql([-1.0, -0.5, 0.0, 0.5])
       end
 
       it "handles infinite values at the start" do
-        eval("(-Float::INFINITY..)").step(2) { |x| ScratchPad << x; break if ScratchPad.recorded.size == 3 }
+        (-Float::INFINITY..).step(2) { |x| ScratchPad << x; break if ScratchPad.recorded.size == 3 }
         ScratchPad.recorded.should eql([-Float::INFINITY, -Float::INFINITY, -Float::INFINITY])
 
         ScratchPad.record []
-        eval("(-Float::INFINITY...)").step(2) { |x| ScratchPad << x; break if ScratchPad.recorded.size == 3 }
+        (-Float::INFINITY...).step(2) { |x| ScratchPad << x; break if ScratchPad.recorded.size == 3 }
         ScratchPad.recorded.should eql([-Float::INFINITY, -Float::INFINITY, -Float::INFINITY])
       end
     end
 
     describe "and String values" do
       it "yields String values incremented by #succ and less than or equal to end when not passed a step" do
-        eval("('A'..)").step { |x| break if x > "D"; ScratchPad << x }
+        ('A'..).step { |x| break if x > "D"; ScratchPad << x }
         ScratchPad.recorded.should == ["A", "B", "C", "D"]
 
         ScratchPad.record []
-        eval("('A'...)").step { |x| break if x > "D"; ScratchPad << x }
+        ('A'...).step { |x| break if x > "D"; ScratchPad << x }
         ScratchPad.recorded.should == ["A", "B", "C", "D"]
       end
 
       it "yields String values incremented by #succ called Integer step times" do
-        eval("('A'..)").step(2) { |x| break if x > "F"; ScratchPad << x }
+        ('A'..).step(2) { |x| break if x > "F"; ScratchPad << x }
         ScratchPad.recorded.should == ["A", "C", "E"]
 
         ScratchPad.record []
-        eval("('A'...)").step(2) { |x| break if x > "F"; ScratchPad << x }
+        ('A'...).step(2) { |x| break if x > "F"; ScratchPad << x }
         ScratchPad.recorded.should == ["A", "C", "E"]
       end
 
       it "raises a TypeError when passed a Float step" do
-        -> { eval("('A'..)").step(2.0) { } }.should raise_error(TypeError)
-        -> { eval("('A'...)").step(2.0) { } }.should raise_error(TypeError)
+        -> { ('A'..).step(2.0) { } }.should raise_error(TypeError)
+        -> { ('A'...).step(2.0) { } }.should raise_error(TypeError)
+      end
+
+      ruby_version_is "3.4" do
+        it "yields String values adjusted by step" do
+          ('A'..).step("A") { |x| break if x > "AAA"; ScratchPad << x }
+          ScratchPad.recorded.should == ["A", "AA", "AAA"]
+
+          ScratchPad.record []
+          ('A'...).step("A") { |x| break if x > "AAA"; ScratchPad << x }
+          ScratchPad.recorded.should == ["A", "AA", "AAA"]
+        end
+
+        it "raises a TypeError when passed an incompatible type step" do
+          -> { ('A'..).step([]) { } }.should raise_error(TypeError)
+          -> { ('A'...).step([]) { } }.should raise_error(TypeError)
+        end
       end
     end
   end
 
   describe "when no block is given" do
-    ruby_version_is "3.0" do
-      it "raises an ArgumentError if step is 0" do
-        -> { (-1..1).step(0) }.should raise_error(ArgumentError)
-      end
+    it "raises an ArgumentError if step is 0" do
+      -> { (-1..1).step(0) }.should raise_error(ArgumentError)
     end
 
     describe "returned Enumerator" do
       describe "size" do
-        ruby_version_is ""..."3.0" do
-          it "raises a TypeError if step does not respond to #to_int" do
-            obj = mock("Range#step non-integer")
-            enum = (1..2).step(obj)
-            -> { enum.size }.should raise_error(TypeError)
-          end
-
-          it "raises a TypeError if #to_int does not return an Integer" do
-            obj = mock("Range#step non-integer")
-            obj.should_receive(:to_int).and_return("1")
-            enum = (1..2).step(obj)
-
-            -> { enum.size }.should raise_error(TypeError)
-          end
-        end
-
-        ruby_version_is "3.0" do
+        ruby_version_is ""..."3.4" do
           it "raises a TypeError if step does not respond to #to_int" do
             obj = mock("Range#step non-integer")
             -> { (1..2).step(obj) }.should raise_error(TypeError)
@@ -414,10 +533,10 @@ describe "Range#step" do
           end
         end
 
-        ruby_version_is ""..."3.0" do
-          it "returns Float::INFINITY for zero step" do
-            (-1..1).step(0).size.should == Float::INFINITY
-            (-1..1).step(0.0).size.should == Float::INFINITY
+        ruby_version_is "3.4" do
+          it "does not raise if step is incompatible" do
+            obj = mock("Range#step non-integer")
+            -> { (1..2).step(obj) }.should_not raise_error
           end
         end
 
@@ -458,19 +577,36 @@ describe "Range#step" do
           (1.0...6.4).step(1.8).size.should == 3
         end
 
-        it "returns nil with begin and end are String" do
-          ("A".."E").step(2).size.should == nil
-          ("A"..."E").step(2).size.should == nil
-          ("A".."E").step.size.should == nil
-          ("A"..."E").step.size.should == nil
+        ruby_version_is ""..."3.4" do
+          it "returns nil with begin and end are String" do
+            ("A".."E").step(2).size.should == nil
+            ("A"..."E").step(2).size.should == nil
+            ("A".."E").step.size.should == nil
+            ("A"..."E").step.size.should == nil
+          end
+
+          it "return nil and not raises a TypeError if the first element does not respond to #succ" do
+            obj = mock("Range#step non-comparable")
+            obj.should_receive(:<=>).with(obj).and_return(1)
+            enum = (obj..obj).step
+            -> { enum.size }.should_not raise_error
+            enum.size.should == nil
+          end
         end
 
-        it "return nil and not raises a TypeError if the first element does not respond to #succ" do
-          obj = mock("Range#step non-comparable")
-          obj.should_receive(:<=>).with(obj).and_return(1)
-          enum = (obj..obj).step
-          -> { enum.size }.should_not raise_error
-          enum.size.should == nil
+        ruby_version_is "3.4" do
+          it "returns nil with begin and end are String" do
+            ("A".."E").step("A").size.should == nil
+            ("A"..."E").step("A").size.should == nil
+          end
+
+          it "return nil and not raises a TypeError if the first element is not of compatible type" do
+            obj = mock("Range#step non-comparable")
+            obj.should_receive(:<=>).with(obj).and_return(1)
+            enum = (obj..obj).step(obj)
+            -> { enum.size }.should_not raise_error
+            enum.size.should == nil
+          end
         end
       end
 
@@ -497,22 +633,48 @@ describe "Range#step" do
             (1..).step(2).take(3).should == [1, 3, 5]
           end
 
-          it "returns an instance of Enumerator when begin is not numeric" do
-            ("a"..).step.class.should == Enumerator
-            ("a"..).step(2).take(3).should == %w[a c e]
+          ruby_version_is ""..."3.4" do
+            it "returns an instance of Enumerator when begin is not numeric" do
+              ("a"..).step.class.should == Enumerator
+              ("a"..).step(2).take(3).should == %w[a c e]
+            end
+          end
+
+          ruby_version_is "3.4" do
+            it "returns an instance of Enumerator when begin is not numeric" do
+              ("a"..).step("a").class.should == Enumerator
+              ("a"..).step("a").take(3).should == %w[a aa aaa]
+            end
           end
         end
 
         context "when range is beginless and endless" do
-          it "returns an instance of Enumerator" do
-            Range.new(nil, nil).step.class.should == Enumerator
+          ruby_version_is ""..."3.4" do
+            it "returns an instance of Enumerator" do
+              Range.new(nil, nil).step.class.should == Enumerator
+            end
+          end
+
+          ruby_version_is "3.4" do
+            it "raises an ArgumentError" do
+              -> { Range.new(nil, nil).step(1) }.should raise_error(ArgumentError)
+            end
           end
         end
 
         context "when begin and end are not numerics" do
-          it "returns an instance of Enumerator" do
-            ("a".."z").step.class.should == Enumerator
-            ("a".."z").step(3).take(4).should == %w[a d g j]
+          ruby_version_is ""..."3.4" do
+            it "returns an instance of Enumerator" do
+              ("a".."z").step.class.should == Enumerator
+              ("a".."z").step(3).take(4).should == %w[a d g j]
+            end
+          end
+
+          ruby_version_is "3.4" do
+            it "returns an instance of Enumerator" do
+              ("a".."z").step("a").class.should == Enumerator
+              ("a".."z").step("a").take(4).should == %w[a aa aaa aaaa]
+            end
           end
         end
       end
diff --git a/spec/ruby/core/range/to_set_spec.rb b/spec/ruby/core/range/to_set_spec.rb
new file mode 100644
index 0000000000..589c0e9aed
--- /dev/null
+++ b/spec/ruby/core/range/to_set_spec.rb
@@ -0,0 +1,55 @@
+require_relative '../../spec_helper'
+require_relative '../enumerable/fixtures/classes'
+
+describe "Enumerable#to_set" do
+  it "returns a new Set created from self" do
+    (1..4).to_set.should == Set[1, 2, 3, 4]
+    (1...4).to_set.should == Set[1, 2, 3]
+  end
+
+  it "passes down passed blocks" do
+    (1..3).to_set { |x| x * x }.should == Set[1, 4, 9]
+  end
+
+  ruby_version_is "4.0" do
+    it "raises a RangeError if the range is infinite" do
+      -> { (1..).to_set }.should raise_error(RangeError, "cannot convert endless range to a set")
+      -> { (1...).to_set }.should raise_error(RangeError, "cannot convert endless range to a set")
+    end
+  end
+
+  ruby_version_is ""..."4.0" do
+    it "instantiates an object of provided as the first argument set class" do
+      set = (1..3).to_set(EnumerableSpecs::SetSubclass)
+      set.should be_kind_of(EnumerableSpecs::SetSubclass)
+      set.to_a.sort.should == [1, 2, 3]
+    end
+  end
+
+  ruby_version_is "4.0"..."4.1" do
+    it "instantiates an object of provided as the first argument set class and warns" do
+      set = nil
+      proc {
+        set = (1..3).to_set(EnumerableSpecs::SetSubclass)
+      }.should complain(/Enumerable#to_set/)
+      set.should be_kind_of(EnumerableSpecs::SetSubclass)
+      set.to_a.sort.should == [1, 2, 3]
+    end
+  end
+
+  ruby_version_is "4.1" do
+    it "does not accept any positional argument" do
+      -> {
+        (1..3).to_set(EnumerableSpecs::SetSubclass)
+      }.should raise_error(ArgumentError, 'wrong number of arguments (given 1, expected 0)')
+    end
+  end
+
+  it "does not need explicit `require 'set'`" do
+    output = ruby_exe(<<~RUBY, options: '--disable-gems', args: '2>&1')
+      puts (1..3).to_set.to_a.inspect
+    RUBY
+
+    output.chomp.should == "[1, 2, 3]"
+  end
+end