Update to ruby/spec@30e1c35

184 files changed, 2347 insertions, 3306 deletions

diff --git a/spec/ruby/core/argf/bytes_spec.rb b/spec/ruby/core/argf/bytes_spec.rb
deleted file mode 100644
index bf35ded1db..0000000000
--- a/spec/ruby/core/argf/bytes_spec.rb
+++ /dev/null
@@ -1,16 +0,0 @@
-require_relative '../../spec_helper'
-require_relative 'shared/each_byte'
-
-ruby_version_is ''...'3.0' do
-  describe "ARGF.bytes" do
-    before :each do
-      @verbose, $VERBOSE = $VERBOSE, nil
-    end
-
-    after :each do
-      $VERBOSE = @verbose
-    end
-
-    it_behaves_like :argf_each_byte, :bytes
-  end
-end
diff --git a/spec/ruby/core/argf/chars_spec.rb b/spec/ruby/core/argf/chars_spec.rb
deleted file mode 100644
index 6af73cdabb..0000000000
--- a/spec/ruby/core/argf/chars_spec.rb
+++ /dev/null
@@ -1,16 +0,0 @@
-require_relative '../../spec_helper'
-require_relative 'shared/each_char'
-
-ruby_version_is ''...'3.0' do
-  describe "ARGF.chars" do
-    before :each do
-      @verbose, $VERBOSE = $VERBOSE, nil
-    end
-
-    after :each do
-      $VERBOSE = @verbose
-    end
-
-    it_behaves_like :argf_each_char, :chars
-  end
-end
diff --git a/spec/ruby/core/argf/codepoints_spec.rb b/spec/ruby/core/argf/codepoints_spec.rb
deleted file mode 100644
index bb28c17fbb..0000000000
--- a/spec/ruby/core/argf/codepoints_spec.rb
+++ /dev/null
@@ -1,16 +0,0 @@
-require_relative '../../spec_helper'
-require_relative 'shared/each_codepoint'
-
-ruby_version_is ''...'3.0' do
-  describe "ARGF.codepoints" do
-    before :each do
-      @verbose, $VERBOSE = $VERBOSE, nil
-    end
-
-    after :each do
-      $VERBOSE = @verbose
-    end
-
-    it_behaves_like :argf_each_codepoint, :codepoints
-  end
-end
diff --git a/spec/ruby/core/argf/lines_spec.rb b/spec/ruby/core/argf/lines_spec.rb
deleted file mode 100644
index e964dbd0d3..0000000000
--- a/spec/ruby/core/argf/lines_spec.rb
+++ /dev/null
@@ -1,16 +0,0 @@
-require_relative '../../spec_helper'
-require_relative 'shared/each_line'
-
-ruby_version_is ''...'3.0' do
-  describe "ARGF.lines" do
-    before :each do
-      @verbose, $VERBOSE = $VERBOSE, nil
-    end
-
-    after :each do
-      $VERBOSE = @verbose
-    end
-
-    it_behaves_like :argf_each_line, :lines
-  end
-end
diff --git a/spec/ruby/core/array/drop_spec.rb b/spec/ruby/core/array/drop_spec.rb
index f911fd9018..0ea748e47d 100644
--- a/spec/ruby/core/array/drop_spec.rb
+++ b/spec/ruby/core/array/drop_spec.rb
@@ -50,15 +50,7 @@ describe "Array#drop" do
     -> { [1, 2].drop(obj) }.should raise_error(TypeError)
   end
 
-  ruby_version_is ''...'3.0' do
-    it 'returns a subclass instance for Array subclasses' do
-      ArraySpecs::MyArray[1, 2, 3, 4, 5].drop(1).should be_an_instance_of(ArraySpecs::MyArray)
-    end
-  end
-
-  ruby_version_is '3.0' do
-    it 'returns a Array instance for Array subclasses' do
-      ArraySpecs::MyArray[1, 2, 3, 4, 5].drop(1).should be_an_instance_of(Array)
-    end
+  it 'returns a Array instance for Array subclasses' do
+    ArraySpecs::MyArray[1, 2, 3, 4, 5].drop(1).should be_an_instance_of(Array)
   end
 end
diff --git a/spec/ruby/core/array/drop_while_spec.rb b/spec/ruby/core/array/drop_while_spec.rb
index 94064528aa..bd46e8b882 100644
--- a/spec/ruby/core/array/drop_while_spec.rb
+++ b/spec/ruby/core/array/drop_while_spec.rb
@@ -18,15 +18,7 @@ describe "Array#drop_while" do
     [1, 2, 3, false, 5].drop_while { |n| n }.should == [false, 5]
   end
 
-  ruby_version_is ''...'3.0' do
-    it 'returns a subclass instance for Array subclasses' do
-      ArraySpecs::MyArray[1, 2, 3, 4, 5].drop_while { |n| n < 4 }.should be_an_instance_of(ArraySpecs::MyArray)
-    end
-  end
-
-  ruby_version_is '3.0' do
-    it 'returns a Array instance for Array subclasses' do
-      ArraySpecs::MyArray[1, 2, 3, 4, 5].drop_while { |n| n < 4 }.should be_an_instance_of(Array)
-    end
+  it 'returns a Array instance for Array subclasses' do
+    ArraySpecs::MyArray[1, 2, 3, 4, 5].drop_while { |n| n < 4 }.should be_an_instance_of(Array)
   end
 end
diff --git a/spec/ruby/core/array/flatten_spec.rb b/spec/ruby/core/array/flatten_spec.rb
index 1770b5389a..8c97000c79 100644
--- a/spec/ruby/core/array/flatten_spec.rb
+++ b/spec/ruby/core/array/flatten_spec.rb
@@ -75,24 +75,12 @@ describe "Array#flatten" do
     [[obj]].flatten(1)
   end
 
-  ruby_version_is ''...'3.0' do
-    it "returns subclass instance for Array subclasses" do
-      ArraySpecs::MyArray[].flatten.should be_an_instance_of(ArraySpecs::MyArray)
-      ArraySpecs::MyArray[1, 2, 3].flatten.should be_an_instance_of(ArraySpecs::MyArray)
-      ArraySpecs::MyArray[1, [2], 3].flatten.should be_an_instance_of(ArraySpecs::MyArray)
-      ArraySpecs::MyArray[1, [2, 3], 4].flatten.should == ArraySpecs::MyArray[1, 2, 3, 4]
-      [ArraySpecs::MyArray[1, 2, 3]].flatten.should be_an_instance_of(Array)
-    end
-  end
-
-  ruby_version_is '3.0' do
-    it "returns Array instance for Array subclasses" do
-      ArraySpecs::MyArray[].flatten.should be_an_instance_of(Array)
-      ArraySpecs::MyArray[1, 2, 3].flatten.should be_an_instance_of(Array)
-      ArraySpecs::MyArray[1, [2], 3].flatten.should be_an_instance_of(Array)
-      ArraySpecs::MyArray[1, [2, 3], 4].flatten.should == [1, 2, 3, 4]
-      [ArraySpecs::MyArray[1, 2, 3]].flatten.should be_an_instance_of(Array)
-    end
+  it "returns Array instance for Array subclasses" do
+    ArraySpecs::MyArray[].flatten.should be_an_instance_of(Array)
+    ArraySpecs::MyArray[1, 2, 3].flatten.should be_an_instance_of(Array)
+    ArraySpecs::MyArray[1, [2], 3].flatten.should be_an_instance_of(Array)
+    ArraySpecs::MyArray[1, [2, 3], 4].flatten.should == [1, 2, 3, 4]
+    [ArraySpecs::MyArray[1, 2, 3]].flatten.should be_an_instance_of(Array)
   end
 
   it "is not destructive" do
diff --git a/spec/ruby/core/array/multiply_spec.rb b/spec/ruby/core/array/multiply_spec.rb
index 23d5c99f3a..eca51142fb 100644
--- a/spec/ruby/core/array/multiply_spec.rb
+++ b/spec/ruby/core/array/multiply_spec.rb
@@ -76,20 +76,10 @@ describe "Array#* with an integer" do
       @array = ArraySpecs::MyArray[1, 2, 3, 4, 5]
     end
 
-    ruby_version_is ''...'3.0' do
-      it "returns a subclass instance" do
-        (@array * 0).should be_an_instance_of(ArraySpecs::MyArray)
-        (@array * 1).should be_an_instance_of(ArraySpecs::MyArray)
-        (@array * 2).should be_an_instance_of(ArraySpecs::MyArray)
-      end
-    end
-
-    ruby_version_is '3.0' do
-      it "returns an Array instance" do
-        (@array * 0).should be_an_instance_of(Array)
-        (@array * 1).should be_an_instance_of(Array)
-        (@array * 2).should be_an_instance_of(Array)
-      end
+    it "returns an Array instance" do
+      (@array * 0).should be_an_instance_of(Array)
+      (@array * 1).should be_an_instance_of(Array)
+      (@array * 2).should be_an_instance_of(Array)
     end
 
     it "does not call #initialize on the subclass instance" do
diff --git a/spec/ruby/core/array/shared/slice.rb b/spec/ruby/core/array/shared/slice.rb
index 8fb33738b9..d2866970a5 100644
--- a/spec/ruby/core/array/shared/slice.rb
+++ b/spec/ruby/core/array/shared/slice.rb
@@ -397,56 +397,28 @@ describe :array_slice, shared: true do
       @array = ArraySpecs::MyArray[1, 2, 3, 4, 5]
     end
 
-    ruby_version_is ''...'3.0' do
-      it "returns a subclass instance with [n, m]" do
-        @array.send(@method, 0, 2).should be_an_instance_of(ArraySpecs::MyArray)
-      end
-
-      it "returns a subclass instance with [-n, m]" do
-        @array.send(@method, -3, 2).should be_an_instance_of(ArraySpecs::MyArray)
-      end
-
-      it "returns a subclass instance with [n..m]" do
-        @array.send(@method, 1..3).should be_an_instance_of(ArraySpecs::MyArray)
-      end
-
-      it "returns a subclass instance with [n...m]" do
-        @array.send(@method, 1...3).should be_an_instance_of(ArraySpecs::MyArray)
-      end
-
-      it "returns a subclass instance with [-n..-m]" do
-        @array.send(@method, -3..-1).should be_an_instance_of(ArraySpecs::MyArray)
-      end
-
-      it "returns a subclass instance with [-n...-m]" do
-        @array.send(@method, -3...-1).should be_an_instance_of(ArraySpecs::MyArray)
-      end
+    it "returns a Array instance with [n, m]" do
+      @array.send(@method, 0, 2).should be_an_instance_of(Array)
     end
 
-    ruby_version_is '3.0' do
-      it "returns a Array instance with [n, m]" do
-        @array.send(@method, 0, 2).should be_an_instance_of(Array)
-      end
-
-      it "returns a Array instance with [-n, m]" do
-        @array.send(@method, -3, 2).should be_an_instance_of(Array)
-      end
+    it "returns a Array instance with [-n, m]" do
+      @array.send(@method, -3, 2).should be_an_instance_of(Array)
+    end
 
-      it "returns a Array instance with [n..m]" do
-        @array.send(@method, 1..3).should be_an_instance_of(Array)
-      end
+    it "returns a Array instance with [n..m]" do
+      @array.send(@method, 1..3).should be_an_instance_of(Array)
+    end
 
-      it "returns a Array instance with [n...m]" do
-        @array.send(@method, 1...3).should be_an_instance_of(Array)
-      end
+    it "returns a Array instance with [n...m]" do
+      @array.send(@method, 1...3).should be_an_instance_of(Array)
+    end
 
-      it "returns a Array instance with [-n..-m]" do
-        @array.send(@method, -3..-1).should be_an_instance_of(Array)
-      end
+    it "returns a Array instance with [-n..-m]" do
+      @array.send(@method, -3..-1).should be_an_instance_of(Array)
+    end
 
-      it "returns a Array instance with [-n...-m]" do
-        @array.send(@method, -3...-1).should be_an_instance_of(Array)
-      end
+    it "returns a Array instance with [-n...-m]" do
+      @array.send(@method, -3...-1).should be_an_instance_of(Array)
     end
 
     it "returns an empty array when m == n with [m...n]" do
@@ -534,239 +506,237 @@ describe :array_slice, shared: true do
     a.send(@method, eval("(-9...)")).should == nil
   end
 
-  ruby_version_is "3.0" do
-    describe "can be sliced with Enumerator::ArithmeticSequence" do
-      before :each do
-        @array = [0, 1, 2, 3, 4, 5]
-      end
+  describe "can be sliced with Enumerator::ArithmeticSequence" do
+    before :each do
+      @array = [0, 1, 2, 3, 4, 5]
+    end
 
-      it "has endless range and positive steps" do
-        @array.send(@method, eval("(0..).step(1)")).should == [0, 1, 2, 3, 4, 5]
-        @array.send(@method, eval("(0..).step(2)")).should == [0, 2, 4]
-        @array.send(@method, eval("(0..).step(10)")).should == [0]
+    it "has endless range and positive steps" do
+      @array.send(@method, eval("(0..).step(1)")).should == [0, 1, 2, 3, 4, 5]
+      @array.send(@method, eval("(0..).step(2)")).should == [0, 2, 4]
+      @array.send(@method, eval("(0..).step(10)")).should == [0]
 
-        @array.send(@method, eval("(2..).step(1)")).should == [2, 3, 4, 5]
-        @array.send(@method, eval("(2..).step(2)")).should == [2, 4]
-        @array.send(@method, eval("(2..).step(10)")).should == [2]
+      @array.send(@method, eval("(2..).step(1)")).should == [2, 3, 4, 5]
+      @array.send(@method, eval("(2..).step(2)")).should == [2, 4]
+      @array.send(@method, eval("(2..).step(10)")).should == [2]
 
-        @array.send(@method, eval("(-3..).step(1)")).should == [3, 4, 5]
-        @array.send(@method, eval("(-3..).step(2)")).should == [3, 5]
-        @array.send(@method, eval("(-3..).step(10)")).should == [3]
-      end
+      @array.send(@method, eval("(-3..).step(1)")).should == [3, 4, 5]
+      @array.send(@method, eval("(-3..).step(2)")).should == [3, 5]
+      @array.send(@method, eval("(-3..).step(10)")).should == [3]
+    end
 
-      it "has beginless range and positive steps" do
-        # end with zero index
-        @array.send(@method, (..0).step(1)).should == [0]
-        @array.send(@method, (...0).step(1)).should == []
+    it "has beginless range and positive steps" do
+      # end with zero index
+      @array.send(@method, (..0).step(1)).should == [0]
+      @array.send(@method, (...0).step(1)).should == []
 
-        @array.send(@method, (..0).step(2)).should == [0]
-        @array.send(@method, (...0).step(2)).should == []
+      @array.send(@method, (..0).step(2)).should == [0]
+      @array.send(@method, (...0).step(2)).should == []
 
-        @array.send(@method, (..0).step(10)).should == [0]
-        @array.send(@method, (...0).step(10)).should == []
+      @array.send(@method, (..0).step(10)).should == [0]
+      @array.send(@method, (...0).step(10)).should == []
 
-        # end with positive index
-        @array.send(@method, (..3).step(1)).should == [0, 1, 2, 3]
-        @array.send(@method, (...3).step(1)).should == [0, 1, 2]
+      # end with positive index
+      @array.send(@method, (..3).step(1)).should == [0, 1, 2, 3]
+      @array.send(@method, (...3).step(1)).should == [0, 1, 2]
 
-        @array.send(@method, (..3).step(2)).should == [0, 2]
-        @array.send(@method, (...3).step(2)).should == [0, 2]
+      @array.send(@method, (..3).step(2)).should == [0, 2]
+      @array.send(@method, (...3).step(2)).should == [0, 2]
 
-        @array.send(@method, (..3).step(10)).should == [0]
-        @array.send(@method, (...3).step(10)).should == [0]
+      @array.send(@method, (..3).step(10)).should == [0]
+      @array.send(@method, (...3).step(10)).should == [0]
 
-        # end with negative index
-        @array.send(@method, (..-2).step(1)).should == [0, 1, 2, 3, 4,]
-        @array.send(@method, (...-2).step(1)).should == [0, 1, 2, 3]
+      # end with negative index
+      @array.send(@method, (..-2).step(1)).should == [0, 1, 2, 3, 4,]
+      @array.send(@method, (...-2).step(1)).should == [0, 1, 2, 3]
 
-        @array.send(@method, (..-2).step(2)).should == [0, 2, 4]
-        @array.send(@method, (...-2).step(2)).should == [0, 2]
+      @array.send(@method, (..-2).step(2)).should == [0, 2, 4]
+      @array.send(@method, (...-2).step(2)).should == [0, 2]
 
-        @array.send(@method, (..-2).step(10)).should == [0]
-        @array.send(@method, (...-2).step(10)).should == [0]
-      end
+      @array.send(@method, (..-2).step(10)).should == [0]
+      @array.send(@method, (...-2).step(10)).should == [0]
+    end
 
-      it "has endless range and negative steps" do
-        @array.send(@method, eval("(0..).step(-1)")).should == [0]
-        @array.send(@method, eval("(0..).step(-2)")).should == [0]
-        @array.send(@method, eval("(0..).step(-10)")).should == [0]
+    it "has endless range and negative steps" do
+      @array.send(@method, eval("(0..).step(-1)")).should == [0]
+      @array.send(@method, eval("(0..).step(-2)")).should == [0]
+      @array.send(@method, eval("(0..).step(-10)")).should == [0]
 
-        @array.send(@method, eval("(2..).step(-1)")).should == [2, 1, 0]
-        @array.send(@method, eval("(2..).step(-2)")).should == [2, 0]
+      @array.send(@method, eval("(2..).step(-1)")).should == [2, 1, 0]
+      @array.send(@method, eval("(2..).step(-2)")).should == [2, 0]
 
-        @array.send(@method, eval("(-3..).step(-1)")).should == [3, 2, 1, 0]
-        @array.send(@method, eval("(-3..).step(-2)")).should == [3, 1]
-      end
+      @array.send(@method, eval("(-3..).step(-1)")).should == [3, 2, 1, 0]
+      @array.send(@method, eval("(-3..).step(-2)")).should == [3, 1]
+    end
 
-      it "has closed range and positive steps" do
-        # start and end with 0
-        @array.send(@method, eval("(0..0).step(1)")).should == [0]
-        @array.send(@method, eval("(0...0).step(1)")).should == []
+    it "has closed range and positive steps" do
+      # start and end with 0
+      @array.send(@method, eval("(0..0).step(1)")).should == [0]
+      @array.send(@method, eval("(0...0).step(1)")).should == []
 
-        @array.send(@method, eval("(0..0).step(2)")).should == [0]
-        @array.send(@method, eval("(0...0).step(2)")).should == []
+      @array.send(@method, eval("(0..0).step(2)")).should == [0]
+      @array.send(@method, eval("(0...0).step(2)")).should == []
 
-        @array.send(@method, eval("(0..0).step(10)")).should == [0]
-        @array.send(@method, eval("(0...0).step(10)")).should == []
+      @array.send(@method, eval("(0..0).step(10)")).should == [0]
+      @array.send(@method, eval("(0...0).step(10)")).should == []
 
-        # start and end with positive index
-        @array.send(@method, eval("(1..3).step(1)")).should == [1, 2, 3]
-        @array.send(@method, eval("(1...3).step(1)")).should == [1, 2]
+      # start and end with positive index
+      @array.send(@method, eval("(1..3).step(1)")).should == [1, 2, 3]
+      @array.send(@method, eval("(1...3).step(1)")).should == [1, 2]
 
-        @array.send(@method, eval("(1..3).step(2)")).should == [1, 3]
-        @array.send(@method, eval("(1...3).step(2)")).should == [1]
+      @array.send(@method, eval("(1..3).step(2)")).should == [1, 3]
+      @array.send(@method, eval("(1...3).step(2)")).should == [1]
 
-        @array.send(@method, eval("(1..3).step(10)")).should == [1]
-        @array.send(@method, eval("(1...3).step(10)")).should == [1]
+      @array.send(@method, eval("(1..3).step(10)")).should == [1]
+      @array.send(@method, eval("(1...3).step(10)")).should == [1]
 
-        # start with positive index, end with negative index
-        @array.send(@method, eval("(1..-2).step(1)")).should == [1, 2, 3, 4]
-        @array.send(@method, eval("(1...-2).step(1)")).should == [1, 2, 3]
+      # start with positive index, end with negative index
+      @array.send(@method, eval("(1..-2).step(1)")).should == [1, 2, 3, 4]
+      @array.send(@method, eval("(1...-2).step(1)")).should == [1, 2, 3]
 
-        @array.send(@method, eval("(1..-2).step(2)")).should ==  [1, 3]
-        @array.send(@method, eval("(1...-2).step(2)")).should ==  [1, 3]
+      @array.send(@method, eval("(1..-2).step(2)")).should ==  [1, 3]
+      @array.send(@method, eval("(1...-2).step(2)")).should ==  [1, 3]
 
-        @array.send(@method, eval("(1..-2).step(10)")).should == [1]
-        @array.send(@method, eval("(1...-2).step(10)")).should == [1]
+      @array.send(@method, eval("(1..-2).step(10)")).should == [1]
+      @array.send(@method, eval("(1...-2).step(10)")).should == [1]
 
-        # start with negative index, end with positive index
-        @array.send(@method, eval("(-4..4).step(1)")).should == [2, 3, 4]
-        @array.send(@method, eval("(-4...4).step(1)")).should == [2, 3]
+      # start with negative index, end with positive index
+      @array.send(@method, eval("(-4..4).step(1)")).should == [2, 3, 4]
+      @array.send(@method, eval("(-4...4).step(1)")).should == [2, 3]
 
-        @array.send(@method, eval("(-4..4).step(2)")).should == [2, 4]
-        @array.send(@method, eval("(-4...4).step(2)")).should == [2]
+      @array.send(@method, eval("(-4..4).step(2)")).should == [2, 4]
+      @array.send(@method, eval("(-4...4).step(2)")).should == [2]
 
-        @array.send(@method, eval("(-4..4).step(10)")).should == [2]
-        @array.send(@method, eval("(-4...4).step(10)")).should == [2]
+      @array.send(@method, eval("(-4..4).step(10)")).should == [2]
+      @array.send(@method, eval("(-4...4).step(10)")).should == [2]
 
-        # start with negative index, end with negative index
-        @array.send(@method, eval("(-4..-2).step(1)")).should == [2, 3, 4]
-        @array.send(@method, eval("(-4...-2).step(1)")).should == [2, 3]
+      # start with negative index, end with negative index
+      @array.send(@method, eval("(-4..-2).step(1)")).should == [2, 3, 4]
+      @array.send(@method, eval("(-4...-2).step(1)")).should == [2, 3]
 
-        @array.send(@method, eval("(-4..-2).step(2)")).should == [2, 4]
-        @array.send(@method, eval("(-4...-2).step(2)")).should == [2]
+      @array.send(@method, eval("(-4..-2).step(2)")).should == [2, 4]
+      @array.send(@method, eval("(-4...-2).step(2)")).should == [2]
 
-        @array.send(@method, eval("(-4..-2).step(10)")).should == [2]
-        @array.send(@method, eval("(-4...-2).step(10)")).should == [2]
-      end
+      @array.send(@method, eval("(-4..-2).step(10)")).should == [2]
+      @array.send(@method, eval("(-4...-2).step(10)")).should == [2]
+    end
 
-      it "has closed range and negative steps" do
-        # start and end with 0
-        @array.send(@method, eval("(0..0).step(-1)")).should == [0]
-        @array.send(@method, eval("(0...0).step(-1)")).should == []
+    it "has closed range and negative steps" do
+      # start and end with 0
+      @array.send(@method, eval("(0..0).step(-1)")).should == [0]
+      @array.send(@method, eval("(0...0).step(-1)")).should == []
 
-        @array.send(@method, eval("(0..0).step(-2)")).should == [0]
-        @array.send(@method, eval("(0...0).step(-2)")).should == []
+      @array.send(@method, eval("(0..0).step(-2)")).should == [0]
+      @array.send(@method, eval("(0...0).step(-2)")).should == []
 
-        @array.send(@method, eval("(0..0).step(-10)")).should == [0]
-        @array.send(@method, eval("(0...0).step(-10)")).should == []
+      @array.send(@method, eval("(0..0).step(-10)")).should == [0]
+      @array.send(@method, eval("(0...0).step(-10)")).should == []
 
-        # start and end with positive index
-        @array.send(@method, eval("(1..3).step(-1)")).should == []
-        @array.send(@method, eval("(1...3).step(-1)")).should == []
+      # start and end with positive index
+      @array.send(@method, eval("(1..3).step(-1)")).should == []
+      @array.send(@method, eval("(1...3).step(-1)")).should == []
 
-        @array.send(@method, eval("(1..3).step(-2)")).should == []
-        @array.send(@method, eval("(1...3).step(-2)")).should == []
+      @array.send(@method, eval("(1..3).step(-2)")).should == []
+      @array.send(@method, eval("(1...3).step(-2)")).should == []
 
-        @array.send(@method, eval("(1..3).step(-10)")).should == []
-        @array.send(@method, eval("(1...3).step(-10)")).should == []
+      @array.send(@method, eval("(1..3).step(-10)")).should == []
+      @array.send(@method, eval("(1...3).step(-10)")).should == []
 
-        # start with positive index, end with negative index
-        @array.send(@method, eval("(1..-2).step(-1)")).should == []
-        @array.send(@method, eval("(1...-2).step(-1)")).should == []
+      # start with positive index, end with negative index
+      @array.send(@method, eval("(1..-2).step(-1)")).should == []
+      @array.send(@method, eval("(1...-2).step(-1)")).should == []
 
-        @array.send(@method, eval("(1..-2).step(-2)")).should ==  []
-        @array.send(@method, eval("(1...-2).step(-2)")).should ==  []
+      @array.send(@method, eval("(1..-2).step(-2)")).should ==  []
+      @array.send(@method, eval("(1...-2).step(-2)")).should ==  []
 
-        @array.send(@method, eval("(1..-2).step(-10)")).should == []
-        @array.send(@method, eval("(1...-2).step(-10)")).should == []
+      @array.send(@method, eval("(1..-2).step(-10)")).should == []
+      @array.send(@method, eval("(1...-2).step(-10)")).should == []
 
-        # start with negative index, end with positive index
-        @array.send(@method, eval("(-4..4).step(-1)")).should == []
-        @array.send(@method, eval("(-4...4).step(-1)")).should == []
+      # start with negative index, end with positive index
+      @array.send(@method, eval("(-4..4).step(-1)")).should == []
+      @array.send(@method, eval("(-4...4).step(-1)")).should == []
 
-        @array.send(@method, eval("(-4..4).step(-2)")).should == []
-        @array.send(@method, eval("(-4...4).step(-2)")).should == []
+      @array.send(@method, eval("(-4..4).step(-2)")).should == []
+      @array.send(@method, eval("(-4...4).step(-2)")).should == []
 
-        @array.send(@method, eval("(-4..4).step(-10)")).should == []
-        @array.send(@method, eval("(-4...4).step(-10)")).should == []
+      @array.send(@method, eval("(-4..4).step(-10)")).should == []
+      @array.send(@method, eval("(-4...4).step(-10)")).should == []
 
-        # start with negative index, end with negative index
-        @array.send(@method, eval("(-4..-2).step(-1)")).should == []
-        @array.send(@method, eval("(-4...-2).step(-1)")).should == []
+      # start with negative index, end with negative index
+      @array.send(@method, eval("(-4..-2).step(-1)")).should == []
+      @array.send(@method, eval("(-4...-2).step(-1)")).should == []
 
-        @array.send(@method, eval("(-4..-2).step(-2)")).should == []
-        @array.send(@method, eval("(-4...-2).step(-2)")).should == []
+      @array.send(@method, eval("(-4..-2).step(-2)")).should == []
+      @array.send(@method, eval("(-4...-2).step(-2)")).should == []
 
-        @array.send(@method, eval("(-4..-2).step(-10)")).should == []
-        @array.send(@method, eval("(-4...-2).step(-10)")).should == []
-      end
+      @array.send(@method, eval("(-4..-2).step(-10)")).should == []
+      @array.send(@method, eval("(-4...-2).step(-10)")).should == []
+    end
 
-      it "has inverted closed range and positive steps" do
-        # start and end with positive index
-        @array.send(@method, eval("(3..1).step(1)")).should == []
-        @array.send(@method, eval("(3...1).step(1)")).should == []
+    it "has inverted closed range and positive steps" do
+      # start and end with positive index
+      @array.send(@method, eval("(3..1).step(1)")).should == []
+      @array.send(@method, eval("(3...1).step(1)")).should == []
 
-        @array.send(@method, eval("(3..1).step(2)")).should == []
-        @array.send(@method, eval("(3...1).step(2)")).should == []
+      @array.send(@method, eval("(3..1).step(2)")).should == []
+      @array.send(@method, eval("(3...1).step(2)")).should == []
 
-        @array.send(@method, eval("(3..1).step(10)")).should == []
-        @array.send(@method, eval("(3...1).step(10)")).should == []
+      @array.send(@method, eval("(3..1).step(10)")).should == []
+      @array.send(@method, eval("(3...1).step(10)")).should == []
 
-        # start with negative index, end with positive index
-        @array.send(@method, eval("(-2..1).step(1)")).should == []
-        @array.send(@method, eval("(-2...1).step(1)")).should == []
+      # start with negative index, end with positive index
+      @array.send(@method, eval("(-2..1).step(1)")).should == []
+      @array.send(@method, eval("(-2...1).step(1)")).should == []
 
-        @array.send(@method, eval("(-2..1).step(2)")).should ==  []
-        @array.send(@method, eval("(-2...1).step(2)")).should ==  []
+      @array.send(@method, eval("(-2..1).step(2)")).should ==  []
+      @array.send(@method, eval("(-2...1).step(2)")).should ==  []
 
-        @array.send(@method, eval("(-2..1).step(10)")).should == []
-        @array.send(@method, eval("(-2...1).step(10)")).should == []
+      @array.send(@method, eval("(-2..1).step(10)")).should == []
+      @array.send(@method, eval("(-2...1).step(10)")).should == []
 
-        # start with positive index, end with negative index
-        @array.send(@method, eval("(4..-4).step(1)")).should == []
-        @array.send(@method, eval("(4...-4).step(1)")).should == []
+      # start with positive index, end with negative index
+      @array.send(@method, eval("(4..-4).step(1)")).should == []
+      @array.send(@method, eval("(4...-4).step(1)")).should == []
 
-        @array.send(@method, eval("(4..-4).step(2)")).should == []
-        @array.send(@method, eval("(4...-4).step(2)")).should == []
+      @array.send(@method, eval("(4..-4).step(2)")).should == []
+      @array.send(@method, eval("(4...-4).step(2)")).should == []
 
-        @array.send(@method, eval("(4..-4).step(10)")).should == []
-        @array.send(@method, eval("(4...-4).step(10)")).should == []
+      @array.send(@method, eval("(4..-4).step(10)")).should == []
+      @array.send(@method, eval("(4...-4).step(10)")).should == []
 
-        # start with negative index, end with negative index
-        @array.send(@method, eval("(-2..-4).step(1)")).should == []
-        @array.send(@method, eval("(-2...-4).step(1)")).should == []
+      # start with negative index, end with negative index
+      @array.send(@method, eval("(-2..-4).step(1)")).should == []
+      @array.send(@method, eval("(-2...-4).step(1)")).should == []
 
-        @array.send(@method, eval("(-2..-4).step(2)")).should == []
-        @array.send(@method, eval("(-2...-4).step(2)")).should == []
+      @array.send(@method, eval("(-2..-4).step(2)")).should == []
+      @array.send(@method, eval("(-2...-4).step(2)")).should == []
 
-        @array.send(@method, eval("(-2..-4).step(10)")).should == []
-        @array.send(@method, eval("(-2...-4).step(10)")).should == []
-      end
+      @array.send(@method, eval("(-2..-4).step(10)")).should == []
+      @array.send(@method, eval("(-2...-4).step(10)")).should == []
+    end
 
-      it "has range with bounds outside of array" do
-        # end is equal to array's length
-        @array.send(@method, (0..6).step(1)).should == [0, 1, 2, 3, 4, 5]
-        -> { @array.send(@method, (0..6).step(2)) }.should raise_error(RangeError)
+    it "has range with bounds outside of array" do
+      # end is equal to array's length
+      @array.send(@method, (0..6).step(1)).should == [0, 1, 2, 3, 4, 5]
+      -> { @array.send(@method, (0..6).step(2)) }.should raise_error(RangeError)
 
-        # end is greater than length with positive steps
-        @array.send(@method, (1..6).step(2)).should == [1, 3, 5]
-        @array.send(@method, (2..7).step(2)).should == [2, 4]
-        -> { @array.send(@method, (2..8).step(2)) }.should raise_error(RangeError)
+      # end is greater than length with positive steps
+      @array.send(@method, (1..6).step(2)).should == [1, 3, 5]
+      @array.send(@method, (2..7).step(2)).should == [2, 4]
+      -> { @array.send(@method, (2..8).step(2)) }.should raise_error(RangeError)
 
-        # begin is greater than length with negative steps
-        @array.send(@method, (6..1).step(-2)).should == [5, 3, 1]
-        @array.send(@method, (7..2).step(-2)).should == [5, 3]
-        -> { @array.send(@method, (8..2).step(-2)) }.should raise_error(RangeError)
-      end
+      # begin is greater than length with negative steps
+      @array.send(@method, (6..1).step(-2)).should == [5, 3, 1]
+      @array.send(@method, (7..2).step(-2)).should == [5, 3]
+      -> { @array.send(@method, (8..2).step(-2)) }.should raise_error(RangeError)
+    end
 
-      it "has endless range with start outside of array's bounds" do
-        @array.send(@method, eval("(6..).step(1)")).should == []
-        @array.send(@method, eval("(7..).step(1)")).should == nil
+    it "has endless range with start outside of array's bounds" do
+      @array.send(@method, eval("(6..).step(1)")).should == []
+      @array.send(@method, eval("(7..).step(1)")).should == nil
 
-        @array.send(@method, eval("(6..).step(2)")).should == []
-        -> { @array.send(@method, eval("(7..).step(2)")) }.should raise_error(RangeError)
-      end
+      @array.send(@method, eval("(6..).step(2)")).should == []
+      -> { @array.send(@method, eval("(7..).step(2)")) }.should raise_error(RangeError)
     end
   end
 
diff --git a/spec/ruby/core/array/slice_spec.rb b/spec/ruby/core/array/slice_spec.rb
index 8e1499855a..731c129251 100644
--- a/spec/ruby/core/array/slice_spec.rb
+++ b/spec/ruby/core/array/slice_spec.rb
@@ -187,56 +187,28 @@ describe "Array#slice!" do
       @array = ArraySpecs::MyArray[1, 2, 3, 4, 5]
     end
 
-    ruby_version_is ''...'3.0' do
-      it "returns a subclass instance with [n, m]" do
-        @array.slice!(0, 2).should be_an_instance_of(ArraySpecs::MyArray)
-      end
-
-      it "returns a subclass instance with [-n, m]" do
-        @array.slice!(-3, 2).should be_an_instance_of(ArraySpecs::MyArray)
-      end
-
-      it "returns a subclass instance with [n..m]" do
-        @array.slice!(1..3).should be_an_instance_of(ArraySpecs::MyArray)
-      end
-
-      it "returns a subclass instance with [n...m]" do
-        @array.slice!(1...3).should be_an_instance_of(ArraySpecs::MyArray)
-      end
-
-      it "returns a subclass instance with [-n..-m]" do
-        @array.slice!(-3..-1).should be_an_instance_of(ArraySpecs::MyArray)
-      end
-
-      it "returns a subclass instance with [-n...-m]" do
-        @array.slice!(-3...-1).should be_an_instance_of(ArraySpecs::MyArray)
-      end
+    it "returns a Array instance with [n, m]" do
+      @array.slice!(0, 2).should be_an_instance_of(Array)
     end
 
-    ruby_version_is '3.0' do
-      it "returns a Array instance with [n, m]" do
-        @array.slice!(0, 2).should be_an_instance_of(Array)
-      end
-
-      it "returns a Array instance with [-n, m]" do
-        @array.slice!(-3, 2).should be_an_instance_of(Array)
-      end
+    it "returns a Array instance with [-n, m]" do
+      @array.slice!(-3, 2).should be_an_instance_of(Array)
+    end
 
-      it "returns a Array instance with [n..m]" do
-        @array.slice!(1..3).should be_an_instance_of(Array)
-      end
+    it "returns a Array instance with [n..m]" do
+      @array.slice!(1..3).should be_an_instance_of(Array)
+    end
 
-      it "returns a Array instance with [n...m]" do
-        @array.slice!(1...3).should be_an_instance_of(Array)
-      end
+    it "returns a Array instance with [n...m]" do
+      @array.slice!(1...3).should be_an_instance_of(Array)
+    end
 
-      it "returns a Array instance with [-n..-m]" do
-        @array.slice!(-3..-1).should be_an_instance_of(Array)
-      end
+    it "returns a Array instance with [-n..-m]" do
+      @array.slice!(-3..-1).should be_an_instance_of(Array)
+    end
 
-      it "returns a Array instance with [-n...-m]" do
-        @array.slice!(-3...-1).should be_an_instance_of(Array)
-      end
+    it "returns a Array instance with [-n...-m]" do
+      @array.slice!(-3...-1).should be_an_instance_of(Array)
     end
   end
 end
diff --git a/spec/ruby/core/array/take_spec.rb b/spec/ruby/core/array/take_spec.rb
index 4fb6f0ce75..c4f0ac9aa4 100644
--- a/spec/ruby/core/array/take_spec.rb
+++ b/spec/ruby/core/array/take_spec.rb
@@ -26,15 +26,7 @@ describe "Array#take" do
     ->{ [1].take(-3) }.should raise_error(ArgumentError)
   end
 
-  ruby_version_is ''...'3.0' do
-    it 'returns a subclass instance for Array subclasses' do
-      ArraySpecs::MyArray[1, 2, 3, 4, 5].take(1).should be_an_instance_of(ArraySpecs::MyArray)
-    end
-  end
-
-  ruby_version_is '3.0' do
-    it 'returns a Array instance for Array subclasses' do
-      ArraySpecs::MyArray[1, 2, 3, 4, 5].take(1).should be_an_instance_of(Array)
-    end
+  it 'returns a Array instance for Array subclasses' do
+    ArraySpecs::MyArray[1, 2, 3, 4, 5].take(1).should be_an_instance_of(Array)
   end
 end
diff --git a/spec/ruby/core/array/take_while_spec.rb b/spec/ruby/core/array/take_while_spec.rb
index 73f25493c8..8f50260b42 100644
--- a/spec/ruby/core/array/take_while_spec.rb
+++ b/spec/ruby/core/array/take_while_spec.rb
@@ -15,16 +15,8 @@ describe "Array#take_while" do
     [1, 2, false, 4].take_while{ |element| element }.should == [1, 2]
   end
 
-  ruby_version_is ''...'3.0' do
-    it 'returns a subclass instance for Array subclasses' do
-      ArraySpecs::MyArray[1, 2, 3, 4, 5].take_while { |n| n < 4 }.should be_an_instance_of(ArraySpecs::MyArray)
-    end
-  end
-
-  ruby_version_is '3.0' do
-    it 'returns a Array instance for Array subclasses' do
-      ArraySpecs::MyArray[1, 2, 3, 4, 5].take_while { |n| n < 4 }.should be_an_instance_of(Array)
-    end
+  it 'returns a Array instance for Array subclasses' do
+    ArraySpecs::MyArray[1, 2, 3, 4, 5].take_while { |n| n < 4 }.should be_an_instance_of(Array)
   end
 end
 
diff --git a/spec/ruby/core/array/uniq_spec.rb b/spec/ruby/core/array/uniq_spec.rb
index 905ab59634..d5d826db15 100644
--- a/spec/ruby/core/array/uniq_spec.rb
+++ b/spec/ruby/core/array/uniq_spec.rb
@@ -85,16 +85,8 @@ describe "Array#uniq" do
     [false, nil, 42].uniq { :bar }.should == [false]
   end
 
-  ruby_version_is ''...'3.0' do
-    it "returns subclass instance on Array subclasses" do
-      ArraySpecs::MyArray[1, 2, 3].uniq.should be_an_instance_of(ArraySpecs::MyArray)
-    end
-  end
-
-  ruby_version_is '3.0' do
-    it "returns Array instance on Array subclasses" do
-      ArraySpecs::MyArray[1, 2, 3].uniq.should be_an_instance_of(Array)
-    end
+  it "returns Array instance on Array subclasses" do
+    ArraySpecs::MyArray[1, 2, 3].uniq.should be_an_instance_of(Array)
   end
 
   it "properly handles an identical item even when its #eql? isn't reflexive" do
diff --git a/spec/ruby/core/binding/eval_spec.rb b/spec/ruby/core/binding/eval_spec.rb
index 4bb3da7a6c..1b3b670b5e 100644
--- a/spec/ruby/core/binding/eval_spec.rb
+++ b/spec/ruby/core/binding/eval_spec.rb
@@ -23,58 +23,29 @@ describe "Binding#eval" do
     bind2.local_variables.should == []
   end
 
-  ruby_version_is ""..."3.0" do
-    it "inherits __LINE__ from the enclosing scope" do
-      obj = BindingSpecs::Demo.new(1)
-      bind = obj.get_binding
-      suppress_warning {bind.eval("__LINE__")}.should == obj.get_line_of_binding
-    end
-
-    it "preserves __LINE__ across multiple calls to eval" do
-      obj = BindingSpecs::Demo.new(1)
-      bind = obj.get_binding
-      suppress_warning {bind.eval("__LINE__")}.should == obj.get_line_of_binding
-      suppress_warning {bind.eval("__LINE__")}.should == obj.get_line_of_binding
-    end
-
-    it "increments __LINE__ on each line of a multiline eval" do
-      obj = BindingSpecs::Demo.new(1)
-      bind = obj.get_binding
-      suppress_warning {bind.eval("#foo\n__LINE__")}.should == obj.get_line_of_binding + 1
-    end
-
-    it "inherits __LINE__ from the enclosing scope even if the Binding is created with #send" do
-      obj = BindingSpecs::Demo.new(1)
-      bind, line = obj.get_binding_with_send_and_line
-      suppress_warning {bind.eval("__LINE__")}.should == line
-    end
+  it "starts with line 1 if single argument is given" do
+    obj = BindingSpecs::Demo.new(1)
+    bind = obj.get_binding
+    bind.eval("__LINE__").should == 1
   end
 
-  ruby_version_is "3.0" do
-    it "starts with line 1 if single argument is given" do
-      obj = BindingSpecs::Demo.new(1)
-      bind = obj.get_binding
-      bind.eval("__LINE__").should == 1
-    end
-
-    it "preserves __LINE__ across multiple calls to eval" do
-      obj = BindingSpecs::Demo.new(1)
-      bind = obj.get_binding
-      bind.eval("__LINE__").should == 1
-      bind.eval("__LINE__").should == 1
-    end
+  it "preserves __LINE__ across multiple calls to eval" do
+    obj = BindingSpecs::Demo.new(1)
+    bind = obj.get_binding
+    bind.eval("__LINE__").should == 1
+    bind.eval("__LINE__").should == 1
+  end
 
-    it "increments __LINE__ on each line of a multiline eval" do
-      obj = BindingSpecs::Demo.new(1)
-      bind = obj.get_binding
-      bind.eval("#foo\n__LINE__").should == 2
-    end
+  it "increments __LINE__ on each line of a multiline eval" do
+    obj = BindingSpecs::Demo.new(1)
+    bind = obj.get_binding
+    bind.eval("#foo\n__LINE__").should == 2
+  end
 
-    it "starts with line 1 if the Binding is created with #send" do
-      obj = BindingSpecs::Demo.new(1)
-      bind, line = obj.get_binding_with_send_and_line
-      bind.eval("__LINE__").should == 1
-    end
+  it "starts with line 1 if the Binding is created with #send" do
+    obj = BindingSpecs::Demo.new(1)
+    bind, line = obj.get_binding_with_send_and_line
+    bind.eval("__LINE__").should == 1
   end
 
   it "starts with a __LINE__ of 1 if a filename is passed" do
@@ -89,32 +60,16 @@ describe "Binding#eval" do
     bind.eval("#foo\n__LINE__", "(test)", 88).should == 89
   end
 
-  ruby_version_is ""..."3.0" do
-    it "inherits __FILE__ from the enclosing scope" do
-      obj = BindingSpecs::Demo.new(1)
-      bind = obj.get_binding
-      suppress_warning { bind.eval("__FILE__") }.should == obj.get_file_of_binding
-    end
-
-    it "inherits __LINE__ from the enclosing scope" do
-      obj = BindingSpecs::Demo.new(1)
-      bind, line = obj.get_binding_and_line
-      suppress_warning { bind.eval("__LINE__") }.should == line
-    end
+  it "uses (eval) as __FILE__ if single argument given" do
+    obj = BindingSpecs::Demo.new(1)
+    bind = obj.get_binding
+    bind.eval("__FILE__").should == '(eval)'
   end
 
-  ruby_version_is "3.0" do
-    it "uses (eval) as __FILE__ if single argument given" do
-      obj = BindingSpecs::Demo.new(1)
-      bind = obj.get_binding
-      bind.eval("__FILE__").should == '(eval)'
-    end
-
-    it "uses 1 as __LINE__" do
-      obj = BindingSpecs::Demo.new(1)
-      bind = obj.get_binding
-      suppress_warning { bind.eval("__LINE__") }.should == 1
-    end
+  it "uses 1 as __LINE__" do
+    obj = BindingSpecs::Demo.new(1)
+    bind = obj.get_binding
+    suppress_warning { bind.eval("__LINE__") }.should == 1
   end
 
   it "uses the __FILE__ that is passed in" do
diff --git a/spec/ruby/core/data/constants_spec.rb b/spec/ruby/core/data/constants_spec.rb
index d9d55b50f9..2eb43d501e 100644
--- a/spec/ruby/core/data/constants_spec.rb
+++ b/spec/ruby/core/data/constants_spec.rb
@@ -1,20 +1,6 @@
 require_relative '../../spec_helper'
 
-ruby_version_is ''...'3.0' do
-  describe "Data" do
-    it "is a subclass of Object" do
-      suppress_warning do
-        Data.superclass.should == Object
-      end
-    end
-
-    it "is deprecated" do
-      -> { Data }.should complain(/constant ::Data is deprecated/)
-    end
-  end
-end
-
-ruby_version_is '3.0'...'3.2' do
+ruby_version_is ''...'3.2' do
   describe "Data" do
     it "does not exist anymore" do
       Object.should_not have_constant(:Data)
diff --git a/spec/ruby/core/dir/glob_spec.rb b/spec/ruby/core/dir/glob_spec.rb
index 72d6337e15..61115b5eec 100644
--- a/spec/ruby/core/dir/glob_spec.rb
+++ b/spec/ruby/core/dir/glob_spec.rb
@@ -260,7 +260,7 @@ describe "Dir.glob" do
     Dir.glob('**/.*', base: "deeply/nested").sort.should == expected
   end
 
-  # 2.7 and 3.0 include a "." entry for every dir: ["directory/.", "directory/structure/.", ...]
+  # < 3.1 include a "." entry for every dir: ["directory/.", "directory/structure/.", ...]
   ruby_version_is '3.1' do
     it "handles **/.* with base keyword argument and FNM_DOTMATCH" do
       expected = %w[
diff --git a/spec/ruby/core/dir/shared/glob.rb b/spec/ruby/core/dir/shared/glob.rb
index 33b2828c27..27ae0e3000 100644
--- a/spec/ruby/core/dir/shared/glob.rb
+++ b/spec/ruby/core/dir/shared/glob.rb
@@ -27,24 +27,22 @@ describe :dir_glob, shared: true do
     -> {Dir.send(@method, "file_o*\0file_t*")}.should raise_error ArgumentError, /nul-separated/
   end
 
-  ruby_version_is "3.0" do
-    it "result is sorted by default" do
-      result = Dir.send(@method, '*')
-      result.should == result.sort
-    end
+  it "result is sorted by default" do
+    result = Dir.send(@method, '*')
+    result.should == result.sort
+  end
 
-    it "result is sorted with sort: true" do
-      result = Dir.send(@method, '*', sort: true)
-      result.should == result.sort
-    end
+  it "result is sorted with sort: true" do
+    result = Dir.send(@method, '*', sort: true)
+    result.should == result.sort
+  end
 
-    it "sort: false returns same files" do
-      result = Dir.send(@method,'*', sort: false)
-      result.sort.should == Dir.send(@method, '*').sort
-    end
+  it "sort: false returns same files" do
+    result = Dir.send(@method,'*', sort: false)
+    result.sort.should == Dir.send(@method, '*').sort
   end
 
-  ruby_version_is "3.0"..."3.1" do
+  ruby_version_is ""..."3.1" do
     it "result is sorted with any non false value of sort:" do
       result = Dir.send(@method, '*', sort: 0)
       result.should == result.sort
diff --git a/spec/ruby/core/encoding/default_external_spec.rb b/spec/ruby/core/encoding/default_external_spec.rb
index 682d49d37c..9aae4976e0 100644
--- a/spec/ruby/core/encoding/default_external_spec.rb
+++ b/spec/ruby/core/encoding/default_external_spec.rb
@@ -18,11 +18,9 @@ describe "Encoding.default_external" do
     Encoding.default_external.should == Encoding::SHIFT_JIS
   end
 
-  ruby_version_is "3.0" do
-    platform_is :windows do
-      it 'is UTF-8 by default on Windows' do
-        Encoding.default_external.should == Encoding::UTF_8
-      end
+  platform_is :windows do
+    it 'is UTF-8 by default on Windows' do
+      Encoding.default_external.should == Encoding::UTF_8
     end
   end
 end
diff --git a/spec/ruby/core/enumerable/grep_spec.rb b/spec/ruby/core/enumerable/grep_spec.rb
index b81075291f..989358f01b 100644
--- a/spec/ruby/core/enumerable/grep_spec.rb
+++ b/spec/ruby/core/enumerable/grep_spec.rb
@@ -40,43 +40,28 @@ describe "Enumerable#grep" do
     $~.should == nil
   end
 
-  ruby_version_is ""..."3.0.0" do
-    it "sets $~ to the last match when given no block" do
-      "z" =~ /z/ # Reset $~
-      ["abc", "def"].grep(/b/).should == ["abc"]
-
-      # Set by the failed match of "def"
-      $~.should == nil
-
-      ["abc", "def"].grep(/e/)
-      $&.should == "e"
-    end
+  it "does not set $~ when given no block" do
+    "z" =~ /z/ # Reset $~
+    ["abc", "def"].grep(/b/).should == ["abc"]
+    $&.should == "z"
   end
 
-  ruby_version_is "3.0.0" do
-    it "does not set $~ when given no block" do
-      "z" =~ /z/ # Reset $~
-      ["abc", "def"].grep(/b/).should == ["abc"]
-      $&.should == "z"
-    end
-
-    it "does not modify Regexp.last_match without block" do
-      "z" =~ /z/ # Reset last match
-      ["abc", "def"].grep(/b/).should == ["abc"]
-      Regexp.last_match[0].should == "z"
-    end
+  it "does not modify Regexp.last_match without block" do
+    "z" =~ /z/ # Reset last match
+    ["abc", "def"].grep(/b/).should == ["abc"]
+    Regexp.last_match[0].should == "z"
+  end
 
-    it "correctly handles non-string elements" do
-      'set last match' =~ /set last (.*)/
-      [:a, 'b', 'z', :c, 42, nil].grep(/[a-d]/).should == [:a, 'b', :c]
-      $1.should == 'match'
+  it "correctly handles non-string elements" do
+    'set last match' =~ /set last (.*)/
+    [:a, 'b', 'z', :c, 42, nil].grep(/[a-d]/).should == [:a, 'b', :c]
+    $1.should == 'match'
 
-      o = Object.new
-      def o.to_str
-        'hello'
-      end
-      [o].grep(/ll/).first.should.equal?(o)
+    o = Object.new
+    def o.to_str
+      'hello'
     end
+    [o].grep(/ll/).first.should.equal?(o)
   end
 
   describe "with a block" do
diff --git a/spec/ruby/core/enumerable/grep_v_spec.rb b/spec/ruby/core/enumerable/grep_v_spec.rb
index 35fde27eb6..ba19216968 100644
--- a/spec/ruby/core/enumerable/grep_v_spec.rb
+++ b/spec/ruby/core/enumerable/grep_v_spec.rb
@@ -20,43 +20,28 @@ describe "Enumerable#grep_v" do
     $&.should == "e"
   end
 
-  ruby_version_is ""..."3.0.0" do
-    it "sets $~ to the last match when given no block" do
-      "z" =~ /z/ # Reset $~
-      ["abc", "def"].grep_v(/e/).should == ["abc"]
-
-      # Set by the match of "def"
-      $&.should == "e"
-
-      ["abc", "def"].grep_v(/b/)
-      $&.should == nil
-    end
+  it "does not set $~ when given no block" do
+    "z" =~ /z/ # Reset $~
+    ["abc", "def"].grep_v(/e/).should == ["abc"]
+    $&.should == "z"
   end
 
-  ruby_version_is "3.0.0" do
-    it "does not set $~ when given no block" do
-      "z" =~ /z/ # Reset $~
-      ["abc", "def"].grep_v(/e/).should == ["abc"]
-      $&.should == "z"
-    end
-
-    it "does not modify Regexp.last_match without block" do
-      "z" =~ /z/ # Reset last match
-      ["abc", "def"].grep_v(/e/).should == ["abc"]
-      Regexp.last_match[0].should == "z"
-    end
+  it "does not modify Regexp.last_match without block" do
+    "z" =~ /z/ # Reset last match
+    ["abc", "def"].grep_v(/e/).should == ["abc"]
+    Regexp.last_match[0].should == "z"
+  end
 
-    it "correctly handles non-string elements" do
-      'set last match' =~ /set last (.*)/
-      [:a, 'b', 'z', :c, 42, nil].grep_v(/[a-d]/).should == ['z', 42, nil]
-      $1.should == 'match'
+  it "correctly handles non-string elements" do
+    'set last match' =~ /set last (.*)/
+    [:a, 'b', 'z', :c, 42, nil].grep_v(/[a-d]/).should == ['z', 42, nil]
+    $1.should == 'match'
 
-      o = Object.new
-      def o.to_str
-        'hello'
-      end
-      [o].grep_v(/mm/).first.should.equal?(o)
+    o = Object.new
+    def o.to_str
+      'hello'
     end
+    [o].grep_v(/mm/).first.should.equal?(o)
   end
 
   describe "without block" do
diff --git a/spec/ruby/core/enumerator/initialize_spec.rb b/spec/ruby/core/enumerator/initialize_spec.rb
index 217af1d3bc..5e937aff2b 100644
--- a/spec/ruby/core/enumerator/initialize_spec.rb
+++ b/spec/ruby/core/enumerator/initialize_spec.rb
@@ -11,14 +11,6 @@ describe "Enumerator#initialize" do
     Enumerator.should have_private_instance_method(:initialize, false)
   end
 
-  ruby_version_is ''...'3.0' do
-    it "returns self when given an object" do
-      suppress_warning do
-        @uninitialized.send(:initialize, Object.new).should equal(@uninitialized)
-      end
-    end
-  end
-
   it "returns self when given a block" do
     @uninitialized.send(:initialize) {}.should equal(@uninitialized)
   end
diff --git a/spec/ruby/core/enumerator/new_spec.rb b/spec/ruby/core/enumerator/new_spec.rb
index c439469525..671912224f 100644
--- a/spec/ruby/core/enumerator/new_spec.rb
+++ b/spec/ruby/core/enumerator/new_spec.rb
@@ -2,51 +2,8 @@ require_relative '../../spec_helper'
 
 describe "Enumerator.new" do
   context "no block given" do
-    ruby_version_is '3.0' do
-      it "raises" do
-        -> { Enumerator.new(1, :upto, 3) }.should raise_error(ArgumentError)
-      end
-    end
-
-    ruby_version_is ''...'3.0' do
-      it "creates a new custom enumerator with the given object, iterator and arguments" do
-        enum = suppress_warning { Enumerator.new(1, :upto, 3) }
-        enum.should be_an_instance_of(Enumerator)
-      end
-
-      it "creates a new custom enumerator that responds to #each" do
-        enum = suppress_warning { Enumerator.new(1, :upto, 3) }
-        enum.respond_to?(:each).should == true
-      end
-
-      it "creates a new custom enumerator that runs correctly" do
-        suppress_warning { Enumerator.new(1, :upto, 3) }.map{ |x| x }.should == [1,2,3]
-      end
-
-      it "aliases the second argument to :each" do
-        suppress_warning { Enumerator.new(1..2) }.to_a.should ==
-          suppress_warning { Enumerator.new(1..2, :each) }.to_a
-      end
-
-      it "doesn't check for the presence of the iterator method" do
-        suppress_warning { Enumerator.new(nil) }.should be_an_instance_of(Enumerator)
-      end
-
-      it "uses the latest define iterator method" do
-        class StrangeEach
-          def each
-            yield :foo
-          end
-        end
-        enum = suppress_warning { Enumerator.new(StrangeEach.new) }
-        enum.to_a.should == [:foo]
-        class StrangeEach
-          def each
-            yield :bar
-          end
-        end
-        enum.to_a.should == [:bar]
-      end
+    it "raises" do
+      -> { Enumerator.new(1, :upto, 3) }.should raise_error(ArgumentError)
     end
   end
 
diff --git a/spec/ruby/core/env/delete_spec.rb b/spec/ruby/core/env/delete_spec.rb
index 5e7891f74d..3d69e4b022 100644
--- a/spec/ruby/core/env/delete_spec.rb
+++ b/spec/ruby/core/env/delete_spec.rb
@@ -30,11 +30,9 @@ describe "ENV.delete" do
     ScratchPad.recorded.should == "foo"
   end
 
-  ruby_version_is "3.0" do
-    it "returns the result of given block if the named environment variable does not exist" do
-      ENV.delete("foo")
-      ENV.delete("foo") { |name| "bar" }.should == "bar"
-    end
+  it "returns the result of given block if the named environment variable does not exist" do
+    ENV.delete("foo")
+    ENV.delete("foo") { |name| "bar" }.should == "bar"
   end
 
   it "does not evaluate the block if the environment variable exists" do
diff --git a/spec/ruby/core/env/except_spec.rb b/spec/ruby/core/env/except_spec.rb
index cfe5865abe..fb8f3b7536 100644
--- a/spec/ruby/core/env/except_spec.rb
+++ b/spec/ruby/core/env/except_spec.rb
@@ -1,36 +1,34 @@
 require_relative 'spec_helper'
 require_relative 'shared/to_hash'
 
-ruby_version_is "3.0" do
-  describe "ENV.except" do
-    before do
-      @orig_hash = ENV.to_hash
-    end
+describe "ENV.except" do
+  before do
+    @orig_hash = ENV.to_hash
+  end
 
-    after do
-      ENV.replace @orig_hash
-    end
+  after do
+    ENV.replace @orig_hash
+  end
 
-    # Testing the method without arguments is covered via
-    it_behaves_like :env_to_hash, :except
+  # Testing the method without arguments is covered via
+  it_behaves_like :env_to_hash, :except
 
-    it "returns a hash without the requested subset" do
-      ENV.clear
+  it "returns a hash without the requested subset" do
+    ENV.clear
 
-      ENV['one'] = '1'
-      ENV['two'] = '2'
-      ENV['three'] = '3'
+    ENV['one'] = '1'
+    ENV['two'] = '2'
+    ENV['three'] = '3'
 
-      ENV.except('one', 'three').should == { 'two' => '2' }
-    end
+    ENV.except('one', 'three').should == { 'two' => '2' }
+  end
 
-    it "ignores keys not present in the original hash" do
-      ENV.clear
+  it "ignores keys not present in the original hash" do
+    ENV.clear
 
-      ENV['one'] = '1'
-      ENV['two'] = '2'
+    ENV['one'] = '1'
+    ENV['two'] = '2'
 
-      ENV.except('one', 'three').should == { 'two' => '2' }
-    end
+    ENV.except('one', 'three').should == { 'two' => '2' }
   end
 end
diff --git a/spec/ruby/core/env/index_spec.rb b/spec/ruby/core/env/index_spec.rb
deleted file mode 100644
index 301a66ab4e..0000000000
--- a/spec/ruby/core/env/index_spec.rb
+++ /dev/null
@@ -1,14 +0,0 @@
-require_relative '../../spec_helper'
-require_relative 'shared/key'
-
-ruby_version_is ''...'3.0' do
-  describe "ENV.index" do
-    it_behaves_like :env_key, :index
-
-    it "warns about deprecation" do
-      -> do
-        ENV.index("foo")
-      end.should complain(/warning: ENV.index is deprecated; use ENV.key/)
-    end
-  end
-end
diff --git a/spec/ruby/core/env/indexes_spec.rb b/spec/ruby/core/env/indexes_spec.rb
deleted file mode 100644
index e724feaa39..0000000000
--- a/spec/ruby/core/env/indexes_spec.rb
+++ /dev/null
@@ -1 +0,0 @@
-require_relative '../../spec_helper'
diff --git a/spec/ruby/core/env/indices_spec.rb b/spec/ruby/core/env/indices_spec.rb
deleted file mode 100644
index e724feaa39..0000000000
--- a/spec/ruby/core/env/indices_spec.rb
+++ /dev/null
@@ -1 +0,0 @@
-require_relative '../../spec_helper'
diff --git a/spec/ruby/core/env/to_a_spec.rb b/spec/ruby/core/env/to_a_spec.rb
index 39e3877b48..2b1649281f 100644
--- a/spec/ruby/core/env/to_a_spec.rb
+++ b/spec/ruby/core/env/to_a_spec.rb
@@ -6,7 +6,10 @@ describe "ENV.to_a" do
     a = ENV.to_a
     a.is_a?(Array).should == true
     a.size.should == ENV.size
-    ENV.each_pair { |k, v| a.should include([k, v])}
+    a.each { |k,v| ENV[k].should == v }
+
+    a.first.should.is_a?(Array)
+    a.first.size.should == 2
   end
 
   it "returns the entries in the locale encoding" do
diff --git a/spec/ruby/core/exception/no_method_error_spec.rb b/spec/ruby/core/exception/no_method_error_spec.rb
index f84f3418a4..4621e36f44 100644
--- a/spec/ruby/core/exception/no_method_error_spec.rb
+++ b/spec/ruby/core/exception/no_method_error_spec.rb
@@ -125,21 +125,19 @@ describe "NoMethodError#message" do
     end
   end
 
-  ruby_version_is "3.0" do
-    it "uses #name to display the receiver if it is a class or a module" do
-      klass = Class.new { def self.name; "MyClass"; end }
-      begin
-        klass.foo
-      rescue NoMethodError => error
-        error.message.lines.first.chomp.should =~ /^undefined method `foo' for /
-      end
+  it "uses #name to display the receiver if it is a class or a module" do
+    klass = Class.new { def self.name; "MyClass"; end }
+    begin
+      klass.foo
+    rescue NoMethodError => error
+      error.message.lines.first.chomp.should =~ /^undefined method `foo' for /
+    end
 
-      mod = Module.new { def self.name; "MyModule"; end }
-      begin
-        mod.foo
-      rescue NoMethodError => error
-        error.message.lines.first.chomp.should =~ /^undefined method `foo' for /
-      end
+    mod = Module.new { def self.name; "MyModule"; end }
+    begin
+      mod.foo
+    rescue NoMethodError => error
+      error.message.lines.first.chomp.should =~ /^undefined method `foo' for /
     end
   end
 end
diff --git a/spec/ruby/core/fiber/blocking_spec.rb b/spec/ruby/core/fiber/blocking_spec.rb
index eeee5a71c1..ebefa116af 100644
--- a/spec/ruby/core/fiber/blocking_spec.rb
+++ b/spec/ruby/core/fiber/blocking_spec.rb
@@ -1,61 +1,59 @@
 require_relative '../../spec_helper'
 require_relative 'shared/blocking'
 
-ruby_version_is "3.0" do
-  require "fiber"
+require "fiber"
 
-  describe "Fiber.blocking?" do
-    it_behaves_like :non_blocking_fiber, -> { Fiber.blocking? }
+describe "Fiber.blocking?" do
+  it_behaves_like :non_blocking_fiber, -> { Fiber.blocking? }
 
-    context "when fiber is blocking" do
-      context "root Fiber of the main thread" do
-        it "returns 1 for blocking: true" do
+  context "when fiber is blocking" do
+    context "root Fiber of the main thread" do
+      it "returns 1 for blocking: true" do
+        fiber = Fiber.new(blocking: true) { Fiber.blocking? }
+        blocking = fiber.resume
+
+        blocking.should == 1
+      end
+    end
+
+    context "root Fiber of a new thread" do
+      it "returns 1 for blocking: true" do
+        thread = Thread.new do
           fiber = Fiber.new(blocking: true) { Fiber.blocking? }
           blocking = fiber.resume
 
           blocking.should == 1
         end
+
+        thread.join
       end
+    end
+  end
+end
 
-      context "root Fiber of a new thread" do
-        it "returns 1 for blocking: true" do
-          thread = Thread.new do
-            fiber = Fiber.new(blocking: true) { Fiber.blocking? }
-            blocking = fiber.resume
+describe "Fiber#blocking?" do
+  it_behaves_like :non_blocking_fiber, -> { Fiber.current.blocking? }
 
-            blocking.should == 1
-          end
+  context "when fiber is blocking" do
+    context "root Fiber of the main thread" do
+      it "returns true for blocking: true" do
+        fiber = Fiber.new(blocking: true) { Fiber.current.blocking? }
+        blocking = fiber.resume
 
-          thread.join
-        end
+        blocking.should == true
       end
     end
-  end
 
-  describe "Fiber#blocking?" do
-    it_behaves_like :non_blocking_fiber, -> { Fiber.current.blocking? }
-
-    context "when fiber is blocking" do
-      context "root Fiber of the main thread" do
-        it "returns true for blocking: true" do
+    context "root Fiber of a new thread" do
+      it "returns true for blocking: true" do
+        thread = Thread.new do
           fiber = Fiber.new(blocking: true) { Fiber.current.blocking? }
           blocking = fiber.resume
 
           blocking.should == true
         end
-      end
 
-      context "root Fiber of a new thread" do
-        it "returns true for blocking: true" do
-          thread = Thread.new do
-            fiber = Fiber.new(blocking: true) { Fiber.current.blocking? }
-            blocking = fiber.resume
-
-            blocking.should == true
-          end
-
-          thread.join
-        end
+        thread.join
       end
     end
   end
diff --git a/spec/ruby/core/fiber/inspect_spec.rb b/spec/ruby/core/fiber/inspect_spec.rb
index ee53af3a39..f20a153fc2 100644
--- a/spec/ruby/core/fiber/inspect_spec.rb
+++ b/spec/ruby/core/fiber/inspect_spec.rb
@@ -18,11 +18,9 @@ describe "Fiber#inspect" do
       inspected.should =~ /\A#<Fiber:0x\h+ .+ \(resumed\)>\z/
     end
 
-    ruby_version_is "3.0" do
-      it "is resumed for a Fiber which was transferred" do
-        inspected = Fiber.new { Fiber.current.inspect }.transfer
-        inspected.should =~ /\A#<Fiber:0x\h+ .+ \(resumed\)>\z/
-      end
+    it "is resumed for a Fiber which was transferred" do
+      inspected = Fiber.new { Fiber.current.inspect }.transfer
+      inspected.should =~ /\A#<Fiber:0x\h+ .+ \(resumed\)>\z/
     end
 
     it "is suspended for a Fiber which was resumed and yielded" do
diff --git a/spec/ruby/core/fiber/raise_spec.rb b/spec/ruby/core/fiber/raise_spec.rb
index 09c4c1b524..eb4b39c8be 100644
--- a/spec/ruby/core/fiber/raise_spec.rb
+++ b/spec/ruby/core/fiber/raise_spec.rb
@@ -94,26 +94,12 @@ describe "Fiber#raise" do
 end
 
 
-ruby_version_is ""..."3.0" do
-  describe "Fiber#raise" do
-    it "raises a FiberError if invoked on a transferring Fiber" do
-      require "fiber"
-      root = Fiber.current
-      fiber = Fiber.new { root.transfer }
-      fiber.transfer
-      -> { fiber.raise }.should raise_error(FiberError, "cannot resume transferred Fiber")
-    end
-  end
-end
-
-ruby_version_is "3.0" do
-  describe "Fiber#raise" do
-    it "transfers and raises on a transferring fiber" do
-      require "fiber"
-      root = Fiber.current
-      fiber = Fiber.new { root.transfer }
-      fiber.transfer
-      -> { fiber.raise "msg" }.should raise_error(RuntimeError, "msg")
-    end
+describe "Fiber#raise" do
+  it "transfers and raises on a transferring fiber" do
+    require "fiber"
+    root = Fiber.current
+    fiber = Fiber.new { root.transfer }
+    fiber.transfer
+    -> { fiber.raise "msg" }.should raise_error(RuntimeError, "msg")
   end
 end
diff --git a/spec/ruby/core/fiber/resume_spec.rb b/spec/ruby/core/fiber/resume_spec.rb
index 273bc866af..ab9a6799ab 100644
--- a/spec/ruby/core/fiber/resume_spec.rb
+++ b/spec/ruby/core/fiber/resume_spec.rb
@@ -28,18 +28,9 @@ describe "Fiber#resume" do
     fiber.resume :second
   end
 
-  ruby_version_is '3.0' do
-    it "raises a FiberError if the Fiber tries to resume itself" do
-      fiber = Fiber.new { fiber.resume }
-      -> { fiber.resume }.should raise_error(FiberError, /current fiber/)
-    end
-  end
-
-  ruby_version_is '' ... '3.0' do
-    it "raises a FiberError if the Fiber tries to resume itself" do
-      fiber = Fiber.new { fiber.resume }
-      -> { fiber.resume }.should raise_error(FiberError, /double resume/)
-    end
+  it "raises a FiberError if the Fiber tries to resume itself" do
+    fiber = Fiber.new { fiber.resume }
+    -> { fiber.resume }.should raise_error(FiberError, /current fiber/)
   end
 
   it "returns control to the calling Fiber if called from one" do
diff --git a/spec/ruby/core/file/new_spec.rb b/spec/ruby/core/file/new_spec.rb
index a1ca46979e..715ac1aaf3 100644
--- a/spec/ruby/core/file/new_spec.rb
+++ b/spec/ruby/core/file/new_spec.rb
@@ -168,16 +168,14 @@ describe "File.new" do
     File.should.exist?(@file)
   end
 
-  ruby_version_is "3.0" do
-    it "accepts options as a keyword argument" do
-      @fh = File.new(@file, 'w', 0755, flags: @flags)
-      @fh.should be_kind_of(File)
-      @fh.close
+  it "accepts options as a keyword argument" do
+    @fh = File.new(@file, 'w', 0755, flags: @flags)
+    @fh.should be_kind_of(File)
+    @fh.close
 
-      -> {
-        @fh = File.new(@file, 'w', 0755, {flags: @flags})
-      }.should raise_error(ArgumentError, "wrong number of arguments (given 4, expected 1..3)")
-    end
+    -> {
+      @fh = File.new(@file, 'w', 0755, {flags: @flags})
+    }.should raise_error(ArgumentError, "wrong number of arguments (given 4, expected 1..3)")
   end
 
   it "bitwise-ORs mode and flags option" do
diff --git a/spec/ruby/core/file/open_spec.rb b/spec/ruby/core/file/open_spec.rb
index 0c6d6cd19c..0346224b93 100644
--- a/spec/ruby/core/file/open_spec.rb
+++ b/spec/ruby/core/file/open_spec.rb
@@ -565,15 +565,13 @@ describe "File.open" do
     File.open(@file, 'wb+') {|f| f.external_encoding.should == Encoding::BINARY}
   end
 
-  ruby_version_is "3.0" do
-    it "accepts options as a keyword argument" do
-      @fh = File.open(@file, 'w', 0755, flags: File::CREAT)
-      @fh.should be_an_instance_of(File)
+  it "accepts options as a keyword argument" do
+    @fh = File.open(@file, 'w', 0755, flags: File::CREAT)
+    @fh.should be_an_instance_of(File)
 
-      -> {
-        File.open(@file, 'w', 0755, {flags: File::CREAT})
-      }.should raise_error(ArgumentError, "wrong number of arguments (given 4, expected 1..3)")
-    end
+    -> {
+      File.open(@file, 'w', 0755, {flags: File::CREAT})
+    }.should raise_error(ArgumentError, "wrong number of arguments (given 4, expected 1..3)")
   end
 
   it "uses the second argument as an options Hash" do
diff --git a/spec/ruby/core/gc/auto_compact_spec.rb b/spec/ruby/core/gc/auto_compact_spec.rb
index 4f9d043171..33ad1cb56c 100644
--- a/spec/ruby/core/gc/auto_compact_spec.rb
+++ b/spec/ruby/core/gc/auto_compact_spec.rb
@@ -1,26 +1,24 @@
 require_relative '../../spec_helper'
 
-ruby_version_is "3.0" do
-  describe "GC.auto_compact" do
-    it "can set and get a boolean value" do
-      begin
-        GC.auto_compact = GC.auto_compact
-      rescue NotImplementedError # platform does not support autocompact
-        skip
-      end
+describe "GC.auto_compact" do
+  it "can set and get a boolean value" do
+    begin
+      GC.auto_compact = GC.auto_compact
+    rescue NotImplementedError # platform does not support autocompact
+      skip
+    end
 
-      original = GC.auto_compact
-      begin
-        GC.auto_compact = !original
-      rescue NotImplementedError # platform does not support autocompact
-        skip
-      end
+    original = GC.auto_compact
+    begin
+      GC.auto_compact = !original
+    rescue NotImplementedError # platform does not support autocompact
+      skip
+    end
 
-      begin
-        GC.auto_compact.should == !original
-      ensure
-        GC.auto_compact = original
-      end
+    begin
+      GC.auto_compact.should == !original
+    ensure
+      GC.auto_compact = original
     end
   end
 end
diff --git a/spec/ruby/core/hash/except_spec.rb b/spec/ruby/core/hash/except_spec.rb
index 82cfced72f..ac84f9975c 100644
--- a/spec/ruby/core/hash/except_spec.rb
+++ b/spec/ruby/core/hash/except_spec.rb
@@ -1,34 +1,32 @@
 require_relative '../../spec_helper'
 
-ruby_version_is "3.0" do
-  describe "Hash#except" do
-    before :each do
-      @hash = { a: 1, b: 2, c: 3 }
-    end
+describe "Hash#except" do
+  before :each do
+    @hash = { a: 1, b: 2, c: 3 }
+  end
 
-    it "returns a new duplicate hash without arguments" do
-      ret = @hash.except
-      ret.should_not equal(@hash)
-      ret.should == @hash
-    end
+  it "returns a new duplicate hash without arguments" do
+    ret = @hash.except
+    ret.should_not equal(@hash)
+    ret.should == @hash
+  end
 
-    it "returns a hash without the requested subset" do
-      @hash.except(:c, :a).should == { b: 2 }
-    end
+  it "returns a hash without the requested subset" do
+    @hash.except(:c, :a).should == { b: 2 }
+  end
 
-    it "ignores keys not present in the original hash" do
-      @hash.except(:a, :chunky_bacon).should == { b: 2, c: 3 }
-    end
+  it "ignores keys not present in the original hash" do
+    @hash.except(:a, :chunky_bacon).should == { b: 2, c: 3 }
+  end
 
-    it "always returns a Hash without a default" do
-      klass = Class.new(Hash)
-      h = klass.new(:default)
-      h[:bar] = 12
-      h[:foo] = 42
-      r = h.except(:foo)
-      r.should == {bar: 12}
-      r.class.should == Hash
-      r.default.should == nil
-    end
+  it "always returns a Hash without a default" do
+    klass = Class.new(Hash)
+    h = klass.new(:default)
+    h[:bar] = 12
+    h[:foo] = 42
+    r = h.except(:foo)
+    r.should == {bar: 12}
+    r.class.should == Hash
+    r.default.should == nil
   end
 end
diff --git a/spec/ruby/core/hash/index_spec.rb b/spec/ruby/core/hash/index_spec.rb
deleted file mode 100644
index be4e2cc6ab..0000000000
--- a/spec/ruby/core/hash/index_spec.rb
+++ /dev/null
@@ -1,9 +0,0 @@
-require_relative '../../spec_helper'
-require_relative 'fixtures/classes'
-require_relative 'shared/index'
-
-ruby_version_is ''...'3.0' do
-  describe "Hash#index" do
-    it_behaves_like :hash_index, :index
-  end
-end
diff --git a/spec/ruby/core/hash/shared/each.rb b/spec/ruby/core/hash/shared/each.rb
index b2483c8116..f9839ff58f 100644
--- a/spec/ruby/core/hash/shared/each.rb
+++ b/spec/ruby/core/hash/shared/each.rb
@@ -21,37 +21,18 @@ describe :hash_each, shared: true do
     ary.sort.should == ["a", "b", "c"]
   end
 
-  ruby_version_is ""..."3.0" do
-    it "yields 2 values and not an Array of 2 elements when given a callable of arity 2" do
-      obj = Object.new
-      def obj.foo(key, value)
-        ScratchPad << key << value
-      end
-
-      ScratchPad.record([])
-      { "a" => 1 }.send(@method, &obj.method(:foo))
-      ScratchPad.recorded.should == ["a", 1]
-
-      ScratchPad.record([])
-      { "a" => 1 }.send(@method, &-> key, value { ScratchPad << key << value })
-      ScratchPad.recorded.should == ["a", 1]
+  it "always yields an Array of 2 elements, even when given a callable of arity 2" do
+    obj = Object.new
+    def obj.foo(key, value)
     end
-  end
-
-  ruby_version_is "3.0" do
-    it "always yields an Array of 2 elements, even when given a callable of arity 2" do
-      obj = Object.new
-      def obj.foo(key, value)
-      end
 
-      -> {
-        { "a" => 1 }.send(@method, &obj.method(:foo))
-      }.should raise_error(ArgumentError)
+    -> {
+      { "a" => 1 }.send(@method, &obj.method(:foo))
+    }.should raise_error(ArgumentError)
 
-      -> {
-        { "a" => 1 }.send(@method, &-> key, value { })
-      }.should raise_error(ArgumentError)
-    end
+    -> {
+      { "a" => 1 }.send(@method, &-> key, value { })
+    }.should raise_error(ArgumentError)
   end
 
   it "yields an Array of 2 elements when given a callable of arity 1" do
diff --git a/spec/ruby/core/hash/shared/equal.rb b/spec/ruby/core/hash/shared/equal.rb
deleted file mode 100644
index 43606437fe..0000000000
--- a/spec/ruby/core/hash/shared/equal.rb
+++ /dev/null
@@ -1,90 +0,0 @@
-describe :hash_equal, shared: true do
-  it "does not compare values when keys don't match" do
-    value = mock('x')
-    value.should_not_receive(:==)
-    value.should_not_receive(:eql?)
-    { 1 => value }.send(@method, { 2 => value }).should be_false
-  end
-
-  it "returns false when the numbers of keys differ without comparing any elements" do
-    obj = mock('x')
-    h = { obj => obj }
-
-    obj.should_not_receive(:==)
-    obj.should_not_receive(:eql?)
-
-    {}.send(@method, h).should be_false
-    h.send(@method, {}).should be_false
-  end
-
-  it "first compares keys via hash" do
-    x = mock('x')
-    x.should_receive(:hash).and_return(0)
-    y = mock('y')
-    y.should_receive(:hash).and_return(0)
-
-    { x => 1 }.send(@method, { y => 1 }).should be_false
-  end
-
-  it "does not compare keys with different hash codes via eql?" do
-    x = mock('x')
-    y = mock('y')
-    x.should_not_receive(:eql?)
-    y.should_not_receive(:eql?)
-
-    x.should_receive(:hash).and_return(0)
-    y.should_receive(:hash).and_return(1)
-
-    def x.hash() 0 end
-    def y.hash() 1 end
-
-    { x => 1 }.send(@method, { y => 1 }).should be_false
-  end
-
-  it "computes equality for recursive hashes" do
-    h = {}
-    h[:a] = h
-    h.send(@method, h[:a]).should be_true
-    (h == h[:a]).should be_true
-  end
-
-  it "computes equality for complex recursive hashes" do
-    a, b = {}, {}
-    a.merge! self: a, other: b
-    b.merge! self: b, other: a
-    a.send(@method, b).should be_true # they both have the same structure!
-
-    c = {}
-    c.merge! other: c, self: c
-    c.send(@method, a).should be_true # subtle, but they both have the same structure!
-    a[:delta] = c[:delta] = a
-    c.send(@method, a).should be_false # not quite the same structure, as a[:other][:delta] = nil
-    c[:delta] = 42
-    c.send(@method, a).should be_false
-    a[:delta] = 42
-    c.send(@method, a).should be_false
-    b[:delta] = 42
-    c.send(@method, a).should be_true
-  end
-
-  it "computes equality for recursive hashes & arrays" do
-    x, y, z = [], [], []
-    a, b, c = {foo: x, bar: 42}, {foo: y, bar: 42}, {foo: z, bar: 42}
-    x << a
-    y << c
-    z << b
-    b.send(@method, c).should be_true # they clearly have the same structure!
-    y.send(@method, z).should be_true
-    a.send(@method, b).should be_true # subtle, but they both have the same structure!
-    x.send(@method, y).should be_true
-    y << x
-    y.send(@method, z).should be_false
-    z << x
-    y.send(@method, z).should be_true
-
-    a[:foo], a[:bar] = a[:bar], a[:foo]
-    a.send(@method, b).should be_false
-    b[:bar] = b[:foo]
-    b.send(@method, c).should be_false
-  end
-end
diff --git a/spec/ruby/core/hash/to_a_spec.rb b/spec/ruby/core/hash/to_a_spec.rb
index 8b7894a2ba..5baf677929 100644
--- a/spec/ruby/core/hash/to_a_spec.rb
+++ b/spec/ruby/core/hash/to_a_spec.rb
@@ -26,14 +26,4 @@ describe "Hash#to_a" do
     ent.should be_kind_of(Array)
     ent.should == pairs
   end
-
-  ruby_version_is ''...'3.0' do
-    it "returns a not tainted array if self is tainted" do
-      {}.taint.to_a.tainted?.should be_false
-    end
-
-    it "returns a trusted array if self is untrusted" do
-      {}.untrust.to_a.untrusted?.should be_false
-    end
-  end
 end
diff --git a/spec/ruby/core/hash/to_proc_spec.rb b/spec/ruby/core/hash/to_proc_spec.rb
index 8f5d21beb5..9dbc79e5eb 100644
--- a/spec/ruby/core/hash/to_proc_spec.rb
+++ b/spec/ruby/core/hash/to_proc_spec.rb
@@ -19,20 +19,12 @@ describe "Hash#to_proc" do
       @proc = @hash.to_proc
     end
 
-    ruby_version_is ""..."3.0" do
-      it "is not a lambda" do
-        @proc.should_not.lambda?
-      end
+    it "is a lambda" do
+      @proc.should.lambda?
     end
 
-    ruby_version_is "3.0" do
-      it "is a lambda" do
-        @proc.should.lambda?
-      end
-
-      it "has an arity of 1" do
-        @proc.arity.should == 1
-      end
+    it "has an arity of 1" do
+      @proc.arity.should == 1
     end
 
     it "raises ArgumentError if not passed exactly one argument" do
diff --git a/spec/ruby/core/hash/transform_keys_spec.rb b/spec/ruby/core/hash/transform_keys_spec.rb
index 361089ca97..2fbb17a8e2 100644
--- a/spec/ruby/core/hash/transform_keys_spec.rb
+++ b/spec/ruby/core/hash/transform_keys_spec.rb
@@ -43,18 +43,16 @@ describe "Hash#transform_keys" do
     r.class.should == Hash
   end
 
-  ruby_version_is "3.0" do
-    it "allows a hash argument" do
-      @hash.transform_keys({ a: :A, b: :B, c: :C }).should == { A: 1, B: 2, C: 3 }
-    end
+  it "allows a hash argument" do
+    @hash.transform_keys({ a: :A, b: :B, c: :C }).should == { A: 1, B: 2, C: 3 }
+  end
 
-    it "allows a partial transformation of keys when using a hash argument" do
-      @hash.transform_keys({ a: :A, c: :C }).should == { A: 1, b: 2, C: 3 }
-    end
+  it "allows a partial transformation of keys when using a hash argument" do
+    @hash.transform_keys({ a: :A, c: :C }).should == { A: 1, b: 2, C: 3 }
+  end
 
-    it "allows a combination of hash and block argument" do
-      @hash.transform_keys({ a: :A }, &:to_s).should == { A: 1, 'b' => 2, 'c' => 3 }
-    end
+  it "allows a combination of hash and block argument" do
+    @hash.transform_keys({ a: :A }, &:to_s).should == { A: 1, 'b' => 2, 'c' => 3 }
   end
 end
 
@@ -111,11 +109,9 @@ describe "Hash#transform_keys!" do
     end
   end
 
-  ruby_version_is "3.0" do
-    it "allows a hash argument" do
-      @hash.transform_keys!({ a: :A, b: :B, c: :C, d: :D })
-      @hash.should == { A: 1, B: 2, C: 3, D: 4 }
-    end
+  it "allows a hash argument" do
+    @hash.transform_keys!({ a: :A, b: :B, c: :C, d: :D })
+    @hash.should == { A: 1, B: 2, C: 3, D: 4 }
   end
 
   describe "on frozen instance" do
@@ -132,10 +128,8 @@ describe "Hash#transform_keys!" do
       @hash.should == @initial_pairs
     end
 
-    ruby_version_is "3.0" do
-      it "raises a FrozenError on hash argument" do
-       ->{ @hash.transform_keys!({ a: :A, b: :B, c: :C }) }.should raise_error(FrozenError)
-      end
+    it "raises a FrozenError on hash argument" do
+     ->{ @hash.transform_keys!({ a: :A, b: :B, c: :C }) }.should raise_error(FrozenError)
     end
 
     context "when no block is given" do
diff --git a/spec/ruby/core/integer/shared/arithmetic_coerce.rb b/spec/ruby/core/integer/shared/arithmetic_coerce.rb
index 4c0cbcb999..1260192df1 100644
--- a/spec/ruby/core/integer/shared/arithmetic_coerce.rb
+++ b/spec/ruby/core/integer/shared/arithmetic_coerce.rb
@@ -1,25 +1,5 @@
 require_relative '../fixtures/classes'
 
-describe :integer_arithmetic_coerce_rescue, shared: true do
-  it "rescues exception (StandardError and subclasses) raised in other#coerce and raises TypeError" do
-    b = mock("numeric with failed #coerce")
-    b.should_receive(:coerce).and_raise(IntegerSpecs::CoerceError)
-
-    # e.g. 1 + b
-    -> { 1.send(@method, b) }.should raise_error(TypeError, /MockObject can't be coerced into Integer/)
-  end
-
-  it "does not rescue Exception and StandardError siblings raised in other#coerce" do
-    [Exception, NoMemoryError].each do |exception|
-      b = mock("numeric with failed #coerce")
-      b.should_receive(:coerce).and_raise(exception)
-
-      # e.g. 1 + b
-      -> { 1.send(@method, b) }.should raise_error(exception)
-    end
-  end
-end
-
 describe :integer_arithmetic_coerce_not_rescue, shared: true do
   it "does not rescue exception raised in other#coerce" do
     b = mock("numeric with failed #coerce")
diff --git a/spec/ruby/core/integer/zero_spec.rb b/spec/ruby/core/integer/zero_spec.rb
index 2dac50c406..bd362c4181 100644
--- a/spec/ruby/core/integer/zero_spec.rb
+++ b/spec/ruby/core/integer/zero_spec.rb
@@ -7,15 +7,7 @@ describe "Integer#zero?" do
     -1.should_not.zero?
   end
 
-  ruby_version_is "3.0" do
-    it "Integer#zero? overrides Numeric#zero?" do
-      42.method(:zero?).owner.should == Integer
-    end
-  end
-
-  ruby_version_is ""..."3.0" do
-    it "Integer#zero? uses Numeric#zero?" do
-      42.method(:zero?).owner.should == Numeric
-    end
+  it "Integer#zero? overrides Numeric#zero?" do
+    42.method(:zero?).owner.should == Integer
   end
 end
diff --git a/spec/ruby/core/io/bytes_spec.rb b/spec/ruby/core/io/bytes_spec.rb
deleted file mode 100644
index 6e328983f2..0000000000
--- a/spec/ruby/core/io/bytes_spec.rb
+++ /dev/null
@@ -1,47 +0,0 @@
-# -*- encoding: utf-8 -*-
-require_relative '../../spec_helper'
-require_relative 'fixtures/classes'
-
-ruby_version_is ''...'3.0' do
-  describe "IO#bytes" do
-    before :each do
-      @io = IOSpecs.io_fixture "lines.txt"
-      @verbose, $VERBOSE = $VERBOSE, nil
-    end
-
-    after :each do
-      $VERBOSE = @verbose
-      @io.close unless @io.closed?
-    end
-
-    it "returns an enumerator of the next bytes from the stream" do
-      enum = @io.bytes
-      enum.should be_an_instance_of(Enumerator)
-      @io.readline.should == "Voici la ligne une.\n"
-      enum.first(5).should == [81, 117, 105, 32, 195]
-    end
-
-    it "yields each byte" do
-      count = 0
-      ScratchPad.record []
-      @io.each_byte do |byte|
-        ScratchPad << byte
-        break if 4 < count += 1
-      end
-
-      ScratchPad.recorded.should == [86, 111, 105, 99, 105]
-    end
-
-    it "raises an IOError on closed stream" do
-      enum = IOSpecs.closed_io.bytes
-      -> { enum.first }.should raise_error(IOError)
-    end
-
-    it "raises an IOError on an enumerator for a stream that has been closed" do
-      enum = @io.bytes
-      enum.first.should == 86
-      @io.close
-      -> { enum.first }.should raise_error(IOError)
-    end
-  end
-end
diff --git a/spec/ruby/core/io/chars_spec.rb b/spec/ruby/core/io/chars_spec.rb
deleted file mode 100644
index 15db595aed..0000000000
--- a/spec/ruby/core/io/chars_spec.rb
+++ /dev/null
@@ -1,30 +0,0 @@
-# -*- encoding: utf-8 -*-
-require_relative '../../spec_helper'
-require_relative 'fixtures/classes'
-require_relative 'shared/chars'
-
-ruby_version_is ''...'3.0' do
-  describe "IO#chars" do
-    before :each do
-      @verbose, $VERBOSE = $VERBOSE, nil
-    end
-
-    after :each do
-      $VERBOSE = @verbose
-    end
-
-    it_behaves_like :io_chars, :chars
-  end
-
-  describe "IO#chars" do
-    before :each do
-      @verbose, $VERBOSE = $VERBOSE, nil
-    end
-
-    after :each do
-      $VERBOSE = @verbose
-    end
-
-    it_behaves_like :io_chars_empty, :chars
-  end
-end
diff --git a/spec/ruby/core/io/codepoints_spec.rb b/spec/ruby/core/io/codepoints_spec.rb
deleted file mode 100644
index 04c115dd3f..0000000000
--- a/spec/ruby/core/io/codepoints_spec.rb
+++ /dev/null
@@ -1,38 +0,0 @@
-require_relative '../../spec_helper'
-require_relative 'fixtures/classes'
-require_relative 'shared/codepoints'
-
-ruby_version_is ''...'3.0' do
-
-  # See redmine #1667
-  describe "IO#codepoints" do
-    before :each do
-      @verbose, $VERBOSE = $VERBOSE, nil
-    end
-
-    after :each do
-      $VERBOSE = @verbose
-    end
-
-    it_behaves_like :io_codepoints, :codepoints
-  end
-
-  describe "IO#codepoints" do
-    before :each do
-      @io = IOSpecs.io_fixture "lines.txt"
-      @verbose, $VERBOSE = $VERBOSE, nil
-    end
-
-    after :each do
-      $VERBOSE = @verbose
-      @io.close unless @io.closed?
-    end
-
-    it "calls the given block" do
-      r = []
-      @io.codepoints { |c| r << c }
-      r[24].should == 232
-      r.last.should == 10
-    end
-  end
-end
diff --git a/spec/ruby/core/io/gets_spec.rb b/spec/ruby/core/io/gets_spec.rb
index f38e3d3974..73d76b3abd 100644
--- a/spec/ruby/core/io/gets_spec.rb
+++ b/spec/ruby/core/io/gets_spec.rb
@@ -149,14 +149,12 @@ describe "IO#gets" do
       @io.gets(chomp: true).should == IOSpecs.lines_without_newline_characters[0]
     end
 
-    ruby_version_is "3.0" do
-      it "raises exception when options passed as Hash" do
-        -> { @io.gets({ chomp: true }) }.should raise_error(TypeError)
+    it "raises exception when options passed as Hash" do
+      -> { @io.gets({ chomp: true }) }.should raise_error(TypeError)
 
-        -> {
-          @io.gets("\n", 1, { chomp: true })
-        }.should raise_error(ArgumentError, "wrong number of arguments (given 3, expected 0..2)")
-      end
+      -> {
+        @io.gets("\n", 1, { chomp: true })
+      }.should raise_error(ArgumentError, "wrong number of arguments (given 3, expected 0..2)")
     end
   end
 end
diff --git a/spec/ruby/core/io/initialize_spec.rb b/spec/ruby/core/io/initialize_spec.rb
index 28fd7af7ab..026252a13d 100644
--- a/spec/ruby/core/io/initialize_spec.rb
+++ b/spec/ruby/core/io/initialize_spec.rb
@@ -27,17 +27,15 @@ describe "IO#initialize" do
     @io.fileno.should == fd
   end
 
-  ruby_version_is "3.0" do
-    it "accepts options as keyword arguments" do
-      fd = new_fd @name, "w:utf-8"
+  it "accepts options as keyword arguments" do
+    fd = new_fd @name, "w:utf-8"
 
-      @io.send(:initialize, fd, "w", flags: File::CREAT)
-      @io.fileno.should == fd
+    @io.send(:initialize, fd, "w", flags: File::CREAT)
+    @io.fileno.should == fd
 
-      -> {
-        @io.send(:initialize, fd, "w", {flags: File::CREAT})
-      }.should raise_error(ArgumentError, "wrong number of arguments (given 3, expected 1..2)")
-    end
+    -> {
+      @io.send(:initialize, fd, "w", {flags: File::CREAT})
+    }.should raise_error(ArgumentError, "wrong number of arguments (given 3, expected 1..2)")
   end
 
   it "raises a TypeError when passed an IO" do
diff --git a/spec/ruby/core/io/lines_spec.rb b/spec/ruby/core/io/lines_spec.rb
deleted file mode 100644
index 5b29a1d07e..0000000000
--- a/spec/ruby/core/io/lines_spec.rb
+++ /dev/null
@@ -1,46 +0,0 @@
-# -*- encoding: utf-8 -*-
-require_relative '../../spec_helper'
-require_relative 'fixtures/classes'
-
-ruby_version_is ''...'3.0' do
-  describe "IO#lines" do
-    before :each do
-      @io = IOSpecs.io_fixture "lines.txt"
-      @verbose, $VERBOSE = $VERBOSE, nil
-    end
-
-    after :each do
-      $VERBOSE = @verbose
-      @io.close if @io
-    end
-
-    it "returns an Enumerator" do
-      @io.lines.should be_an_instance_of(Enumerator)
-    end
-
-    describe "when no block is given" do
-      it "returns an Enumerator" do
-        @io.lines.should be_an_instance_of(Enumerator)
-      end
-
-      describe "returned Enumerator" do
-        describe "size" do
-          it "should return nil" do
-            @io.lines.size.should == nil
-          end
-        end
-      end
-    end
-
-    it "returns a line when accessed" do
-      enum = @io.lines
-      enum.first.should == IOSpecs.lines[0]
-    end
-
-    it "yields each line to the passed block" do
-      ScratchPad.record []
-      @io.lines { |s| ScratchPad << s }
-      ScratchPad.recorded.should == IOSpecs.lines
-    end
-  end
-end
diff --git a/spec/ruby/core/io/nonblock_spec.rb b/spec/ruby/core/io/nonblock_spec.rb
index e81ac10c58..99dc0cafd0 100644
--- a/spec/ruby/core/io/nonblock_spec.rb
+++ b/spec/ruby/core/io/nonblock_spec.rb
@@ -12,43 +12,21 @@ platform_is_not :windows do
       end
     end
 
-    ruby_version_is ""..."3.0" do
-      it "returns false for pipe by default" do
-        r, w = IO.pipe
-        begin
-          r.nonblock?.should == false
-          w.nonblock?.should == false
-        ensure
-          r.close
-          w.close
-        end
-      end
-
-      it "returns false for socket by default" do
-        require 'socket'
-        TCPServer.open(0) do |socket|
-          socket.nonblock?.should == false
-        end
+    it "returns true for pipe by default" do
+      r, w = IO.pipe
+      begin
+        r.nonblock?.should == true
+        w.nonblock?.should == true
+      ensure
+        r.close
+        w.close
       end
     end
 
-    ruby_version_is "3.0" do
-      it "returns true for pipe by default" do
-        r, w = IO.pipe
-        begin
-          r.nonblock?.should == true
-          w.nonblock?.should == true
-        ensure
-          r.close
-          w.close
-        end
-      end
-
-      it "returns true for socket by default" do
-        require 'socket'
-        TCPServer.open(0) do |socket|
-          socket.nonblock?.should == true
-        end
+    it "returns true for socket by default" do
+      require 'socket'
+      TCPServer.open(0) do |socket|
+        socket.nonblock?.should == true
       end
     end
   end
diff --git a/spec/ruby/core/io/read_spec.rb b/spec/ruby/core/io/read_spec.rb
index 8bffd50876..a829ffd18c 100644
--- a/spec/ruby/core/io/read_spec.rb
+++ b/spec/ruby/core/io/read_spec.rb
@@ -23,15 +23,13 @@ describe "IO.read" do
     IO.read(p)
   end
 
-  ruby_version_is "3.0" do
-    # https://bugs.ruby-lang.org/issues/19354
-    it "accepts options as keyword arguments" do
-      IO.read(@fname, 3, 0, mode: "r+").should == @contents[0, 3]
+  # https://bugs.ruby-lang.org/issues/19354
+  it "accepts options as keyword arguments" do
+    IO.read(@fname, 3, 0, mode: "r+").should == @contents[0, 3]
 
-      -> {
-        IO.read(@fname, 3, 0, {mode: "r+"})
-      }.should raise_error(ArgumentError, /wrong number of arguments/)
-    end
+    -> {
+      IO.read(@fname, 3, 0, {mode: "r+"})
+    }.should raise_error(ArgumentError, /wrong number of arguments/)
   end
 
   it "accepts an empty options Hash" do
diff --git a/spec/ruby/core/io/readline_spec.rb b/spec/ruby/core/io/readline_spec.rb
index cf9f0dfc11..a814c1be90 100644
--- a/spec/ruby/core/io/readline_spec.rb
+++ b/spec/ruby/core/io/readline_spec.rb
@@ -73,14 +73,12 @@ describe "IO#readline" do
       @io.readline(chomp: true).should == IOSpecs.lines_without_newline_characters[0]
     end
 
-    ruby_version_is "3.0" do
-      it "raises exception when options passed as Hash" do
-        -> { @io.readline({ chomp: true }) }.should raise_error(TypeError)
+    it "raises exception when options passed as Hash" do
+      -> { @io.readline({ chomp: true }) }.should raise_error(TypeError)
 
-        -> {
-          @io.readline("\n", 1, { chomp: true })
-        }.should raise_error(ArgumentError, "wrong number of arguments (given 3, expected 0..2)")
-      end
+      -> {
+        @io.readline("\n", 1, { chomp: true })
+      }.should raise_error(ArgumentError, "wrong number of arguments (given 3, expected 0..2)")
     end
   end
 end
diff --git a/spec/ruby/core/io/readlines_spec.rb b/spec/ruby/core/io/readlines_spec.rb
index 43d0750a72..d6c4d539cf 100644
--- a/spec/ruby/core/io/readlines_spec.rb
+++ b/spec/ruby/core/io/readlines_spec.rb
@@ -117,14 +117,12 @@ describe "IO#readlines" do
       @io.readlines(chomp: true).should == IOSpecs.lines_without_newline_characters
     end
 
-    ruby_version_is "3.0" do
-      it "raises exception when options passed as Hash" do
-        -> { @io.readlines({ chomp: true }) }.should raise_error(TypeError)
+    it "raises exception when options passed as Hash" do
+      -> { @io.readlines({ chomp: true }) }.should raise_error(TypeError)
 
-        -> {
-          @io.readlines("\n", 1, { chomp: true })
-        }.should raise_error(ArgumentError, "wrong number of arguments (given 3, expected 0..2)")
-      end
+      -> {
+        @io.readlines("\n", 1, { chomp: true })
+      }.should raise_error(ArgumentError, "wrong number of arguments (given 3, expected 0..2)")
     end
   end
 
diff --git a/spec/ruby/core/io/shared/binwrite.rb b/spec/ruby/core/io/shared/binwrite.rb
index 950a6f51ab..e51093329b 100644
--- a/spec/ruby/core/io/shared/binwrite.rb
+++ b/spec/ruby/core/io/shared/binwrite.rb
@@ -21,14 +21,12 @@ describe :io_binwrite, shared: true do
     IO.send(@method, @filename, "abcde").should == 5
   end
 
-  ruby_version_is "3.0" do
-    it "accepts options as a keyword argument" do
-      IO.send(@method, @filename, "hi", 0, flags: File::CREAT).should == 2
+  it "accepts options as a keyword argument" do
+    IO.send(@method, @filename, "hi", 0, flags: File::CREAT).should == 2
 
-      -> {
-        IO.send(@method, @filename, "hi", 0, {flags: File::CREAT})
-      }.should raise_error(ArgumentError, "wrong number of arguments (given 4, expected 2..3)")
-    end
+    -> {
+      IO.send(@method, @filename, "hi", 0, {flags: File::CREAT})
+    }.should raise_error(ArgumentError, "wrong number of arguments (given 4, expected 2..3)")
   end
 
   it "creates a file if missing" do
diff --git a/spec/ruby/core/io/shared/each.rb b/spec/ruby/core/io/shared/each.rb
index 02bbe19c1a..dbc0178dd6 100644
--- a/spec/ruby/core/io/shared/each.rb
+++ b/spec/ruby/core/io/shared/each.rb
@@ -180,16 +180,14 @@ describe :io_each, shared: true do
       ScratchPad.recorded.should == IOSpecs.lines_without_newline_characters
     end
 
-    ruby_version_is "3.0" do
-      it "raises exception when options passed as Hash" do
-        -> {
-          @io.send(@method, { chomp: true }) { |s| }
-        }.should raise_error(TypeError)
-
-        -> {
-          @io.send(@method, "\n", 1, { chomp: true }) { |s| }
-        }.should raise_error(ArgumentError, "wrong number of arguments (given 3, expected 0..2)")
-      end
+    it "raises exception when options passed as Hash" do
+      -> {
+        @io.send(@method, { chomp: true }) { |s| }
+      }.should raise_error(TypeError)
+
+      -> {
+        @io.send(@method, "\n", 1, { chomp: true }) { |s| }
+      }.should raise_error(ArgumentError, "wrong number of arguments (given 3, expected 0..2)")
     end
   end
 
diff --git a/spec/ruby/core/io/shared/new.rb b/spec/ruby/core/io/shared/new.rb
index da4c0af7a9..99b19e6a1b 100644
--- a/spec/ruby/core/io/shared/new.rb
+++ b/spec/ruby/core/io/shared/new.rb
@@ -64,15 +64,13 @@ describe :io_new, shared: true do
     @io.should be_an_instance_of(IO)
   end
 
-  ruby_version_is "3.0" do
-    it "accepts options as keyword arguments" do
-      @io = IO.send(@method, @fd, "w", flags: File::CREAT)
-      @io.write("foo").should == 3
-
-      -> {
-        IO.send(@method, @fd, "w", {flags: File::CREAT})
-      }.should raise_error(ArgumentError, "wrong number of arguments (given 3, expected 1..2)")
-    end
+  it "accepts options as keyword arguments" do
+    @io = IO.send(@method, @fd, "w", flags: File::CREAT)
+    @io.write("foo").should == 3
+
+    -> {
+      IO.send(@method, @fd, "w", {flags: File::CREAT})
+    }.should raise_error(ArgumentError, "wrong number of arguments (given 3, expected 1..2)")
   end
 
   it "accepts a :mode option" do
@@ -210,21 +208,10 @@ describe :io_new, shared: true do
     @io.internal_encoding.to_s.should == 'IBM866'
   end
 
-  ruby_version_is ''...'3.0' do
-    it "accepts nil options" do
-      @io = suppress_keyword_warning do
-        IO.send(@method, @fd, 'w', nil)
-      end
-      @io.write("foo").should == 3
-    end
-  end
-
-  ruby_version_is '3.0' do
-    it "raises ArgumentError for nil options" do
-      -> {
-        IO.send(@method, @fd, 'w', nil)
-      }.should raise_error(ArgumentError)
-    end
+  it "raises ArgumentError for nil options" do
+    -> {
+      IO.send(@method, @fd, 'w', nil)
+    }.should raise_error(ArgumentError)
   end
 
   it "coerces mode with #to_str" do
@@ -395,21 +382,9 @@ describe :io_new_errors, shared: true do
     }.should raise_error(ArgumentError)
   end
 
-  ruby_version_is ''...'3.0' do
-    it "raises TypeError if passed a hash for mode and nil for options" do
-      -> {
-        suppress_keyword_warning do
-          @io = IO.send(@method, @fd, {mode: 'w'}, nil)
-        end
-      }.should raise_error(TypeError)
-    end
-  end
-
-  ruby_version_is '3.0' do
-    it "raises ArgumentError if passed a hash for mode and nil for options" do
-      -> {
-        @io = IO.send(@method, @fd, {mode: 'w'}, nil)
-      }.should raise_error(ArgumentError)
-    end
+  it "raises ArgumentError if passed a hash for mode and nil for options" do
+    -> {
+      @io = IO.send(@method, @fd, {mode: 'w'}, nil)
+    }.should raise_error(ArgumentError)
   end
 end
diff --git a/spec/ruby/core/io/shared/readlines.rb b/spec/ruby/core/io/shared/readlines.rb
index 7681e1b5c1..d2b604bba3 100644
--- a/spec/ruby/core/io/shared/readlines.rb
+++ b/spec/ruby/core/io/shared/readlines.rb
@@ -105,12 +105,10 @@ describe :io_readlines_options_19, shared: true do
     end
 
     describe "when the object is an options Hash" do
-      ruby_version_is "3.0" do
-        it "raises TypeError exception" do
-          -> {
-            IO.send(@method, @name, { chomp: true }, &@object)
-          }.should raise_error(TypeError)
-        end
+      it "raises TypeError exception" do
+        -> {
+          IO.send(@method, @name, { chomp: true }, &@object)
+        }.should raise_error(TypeError)
       end
     end
 
@@ -179,12 +177,10 @@ describe :io_readlines_options_19, shared: true do
     end
 
     describe "when the second object is an options Hash" do
-      ruby_version_is "3.0" do
-        it "raises TypeError exception" do
-          -> {
-            IO.send(@method, @name, "", { chomp: true }, &@object)
-          }.should raise_error(TypeError)
-        end
+      it "raises TypeError exception" do
+        -> {
+          IO.send(@method, @name, "", { chomp: true }, &@object)
+        }.should raise_error(TypeError)
       end
     end
   end
diff --git a/spec/ruby/core/io/ungetc_spec.rb b/spec/ruby/core/io/ungetc_spec.rb
index 41a455c836..47a4e99ebf 100644
--- a/spec/ruby/core/io/ungetc_spec.rb
+++ b/spec/ruby/core/io/ungetc_spec.rb
@@ -103,19 +103,9 @@ describe "IO#ungetc" do
     -> { @io.sysread(1) }.should raise_error(IOError)
   end
 
-  ruby_version_is ""..."3.0" do
-    it "does not affect the stream and returns nil when passed nil" do
-      @io.getc.should == ?V
-      @io.ungetc(nil)
-      @io.getc.should == ?o
-    end
-  end
-
-  ruby_version_is "3.0" do
-    it "raises TypeError if passed nil" do
-      @io.getc.should == ?V
-      proc{@io.ungetc(nil)}.should raise_error(TypeError)
-    end
+  it "raises TypeError if passed nil" do
+    @io.getc.should == ?V
+    proc{@io.ungetc(nil)}.should raise_error(TypeError)
   end
 
   it "puts one or more characters back in the stream" do
diff --git a/spec/ruby/core/io/write_spec.rb b/spec/ruby/core/io/write_spec.rb
index bf23634372..3f04fb053f 100644
--- a/spec/ruby/core/io/write_spec.rb
+++ b/spec/ruby/core/io/write_spec.rb
@@ -259,25 +259,23 @@ platform_is :windows do
   end
 end
 
-ruby_version_is "3.0" do
-  describe "IO#write on STDOUT" do
-    # https://bugs.ruby-lang.org/issues/14413
-    platform_is_not :windows do
-      it "raises SignalException SIGPIPE if the stream is closed instead of Errno::EPIPE like other IOs" do
-        stderr_file = tmp("stderr")
-        begin
-          IO.popen([*ruby_exe, "-e", "loop { puts :ok }"], "r", err: stderr_file) do |io|
-            io.gets.should == "ok\n"
-            io.close
-          end
-          status = $?
-          status.should_not.success?
-          status.should.signaled?
-          Signal.signame(status.termsig).should == 'PIPE'
-          File.read(stderr_file).should.empty?
-        ensure
-          rm_r stderr_file
+describe "IO#write on STDOUT" do
+  # https://bugs.ruby-lang.org/issues/14413
+  platform_is_not :windows do
+    it "raises SignalException SIGPIPE if the stream is closed instead of Errno::EPIPE like other IOs" do
+      stderr_file = tmp("stderr")
+      begin
+        IO.popen([*ruby_exe, "-e", "loop { puts :ok }"], "r", err: stderr_file) do |io|
+          io.gets.should == "ok\n"
+          io.close
         end
+        status = $?
+        status.should_not.success?
+        status.should.signaled?
+        Signal.signame(status.termsig).should == 'PIPE'
+        File.read(stderr_file).should.empty?
+      ensure
+        rm_r stderr_file
       end
     end
   end
diff --git a/spec/ruby/core/kernel/Integer_spec.rb b/spec/ruby/core/kernel/Integer_spec.rb
index c691cb4c41..c37733e88d 100644
--- a/spec/ruby/core/kernel/Integer_spec.rb
+++ b/spec/ruby/core/kernel/Integer_spec.rb
@@ -145,7 +145,7 @@ describe :kernel_integer, shared: true do
   end
 end
 
-describe "Integer() given a String", shared: true do
+describe :kernel_integer_string, shared: true do
   it "raises an ArgumentError if the String is a null byte" do
     -> { Integer("\0") }.should raise_error(ArgumentError)
   end
@@ -348,7 +348,7 @@ describe "Integer() given a String", shared: true do
   end
 end
 
-describe "Integer() given a String and base", shared: true do
+describe :kernel_integer_string_base, shared: true do
   it "raises an ArgumentError if the String is a null byte" do
     -> { Integer("\0", 2) }.should raise_error(ArgumentError)
   end
@@ -784,9 +784,9 @@ describe "Kernel.Integer" do
 
   # TODO: fix these specs
   it_behaves_like :kernel_integer, :Integer, Kernel
-  it_behaves_like "Integer() given a String", :Integer
+  it_behaves_like :kernel_integer_string, :Integer
 
-  it_behaves_like "Integer() given a String and base", :Integer
+  it_behaves_like :kernel_integer_string_base, :Integer
 
   it "is a public method" do
     Kernel.Integer(10).should == 10
@@ -798,9 +798,9 @@ describe "Kernel#Integer" do
 
   # TODO: fix these specs
   it_behaves_like :kernel_integer, :Integer, Object.new
-  it_behaves_like "Integer() given a String", :Integer
+  it_behaves_like :kernel_integer_string, :Integer
 
-  it_behaves_like "Integer() given a String and base", :Integer
+  it_behaves_like :kernel_integer_string_base, :Integer
 
   it "is a private method" do
     Kernel.should have_private_instance_method(:Integer)
diff --git a/spec/ruby/core/kernel/__dir___spec.rb b/spec/ruby/core/kernel/__dir___spec.rb
index 324792a408..242adbf48b 100644
--- a/spec/ruby/core/kernel/__dir___spec.rb
+++ b/spec/ruby/core/kernel/__dir___spec.rb
@@ -19,19 +19,9 @@ describe "Kernel#__dir__" do
     end
   end
 
-  ruby_version_is ""..."3.0" do
-    context "when used in eval with top level binding" do
-      it "returns the real name of the directory containing the currently-executing file" do
-        eval("__dir__", binding).should == File.realpath(File.dirname(__FILE__))
-      end
-    end
-  end
-
-  ruby_version_is "3.0" do
-    context "when used in eval with top level binding" do
-      it "returns nil" do
-        eval("__dir__", binding).should == nil
-      end
+  context "when used in eval with top level binding" do
+    it "returns nil" do
+      eval("__dir__", binding).should == nil
     end
   end
 end
diff --git a/spec/ruby/core/kernel/clone_spec.rb b/spec/ruby/core/kernel/clone_spec.rb
index a87c7544fe..5adcbbe603 100644
--- a/spec/ruby/core/kernel/clone_spec.rb
+++ b/spec/ruby/core/kernel/clone_spec.rb
@@ -45,26 +45,18 @@ describe "Kernel#clone" do
   end
 
   describe "with freeze: nil" do
-    ruby_version_is ""..."3.0" do
-      it "raises ArgumentError" do
-        -> { @obj.clone(freeze: nil) }.should raise_error(ArgumentError, /unexpected value for freeze: NilClass/)
-      end
-    end
-
-    ruby_version_is "3.0" do
-      it "copies frozen state from the original, like #clone without arguments" do
-        o2 = @obj.clone(freeze: nil)
-        o2.should_not.frozen?
+    it "copies frozen state from the original, like #clone without arguments" do
+      o2 = @obj.clone(freeze: nil)
+      o2.should_not.frozen?
 
-        @obj.freeze
-        o3 = @obj.clone(freeze: nil)
-        o3.should.frozen?
-      end
+      @obj.freeze
+      o3 = @obj.clone(freeze: nil)
+      o3.should.frozen?
+    end
 
-      it "copies frozen?" do
-        o = "".freeze.clone(freeze: nil)
-        o.frozen?.should be_true
-      end
+    it "copies frozen?" do
+      o = "".freeze.clone(freeze: nil)
+      o.frozen?.should be_true
     end
   end
 
@@ -74,33 +66,19 @@ describe "Kernel#clone" do
       @obj.clone(freeze: true).should.frozen?
     end
 
-    ruby_version_is ''...'3.0' do
-      it 'does not freeze the copy even if the original is not frozen' do
-        @obj.clone(freeze: true).should_not.frozen?
-      end
-
-      it "calls #initialize_clone with no kwargs" do
-        obj = KernelSpecs::CloneFreeze.new
-        obj.clone(freeze: true)
-        ScratchPad.recorded.should == [obj, {}]
-      end
+    it 'freezes the copy even if the original was not frozen' do
+      @obj.clone(freeze: true).should.frozen?
     end
 
-    ruby_version_is '3.0' do
-      it 'freezes the copy even if the original was not frozen' do
-        @obj.clone(freeze: true).should.frozen?
-      end
-
-      it "calls #initialize_clone with kwargs freeze: true" do
-        obj = KernelSpecs::CloneFreeze.new
-        obj.clone(freeze: true)
-        ScratchPad.recorded.should == [obj, { freeze: true }]
-      end
+    it "calls #initialize_clone with kwargs freeze: true" do
+      obj = KernelSpecs::CloneFreeze.new
+      obj.clone(freeze: true)
+      ScratchPad.recorded.should == [obj, { freeze: true }]
+    end
 
-      it "calls #initialize_clone with kwargs freeze: true even if #initialize_clone only takes a single argument" do
-        obj = KernelSpecs::Clone.new
-        -> { obj.clone(freeze: true) }.should raise_error(ArgumentError, 'wrong number of arguments (given 2, expected 1)')
-      end
+    it "calls #initialize_clone with kwargs freeze: true even if #initialize_clone only takes a single argument" do
+      obj = KernelSpecs::Clone.new
+      -> { obj.clone(freeze: true) }.should raise_error(ArgumentError, 'wrong number of arguments (given 2, expected 1)')
     end
   end
 
@@ -114,25 +92,15 @@ describe "Kernel#clone" do
       @obj.clone(freeze: false).should_not.frozen?
     end
 
-    ruby_version_is ''...'3.0' do
-      it "calls #initialize_clone with no kwargs" do
-        obj = KernelSpecs::CloneFreeze.new
-        obj.clone(freeze: false)
-        ScratchPad.recorded.should == [obj, {}]
-      end
+    it "calls #initialize_clone with kwargs freeze: false" do
+      obj = KernelSpecs::CloneFreeze.new
+      obj.clone(freeze: false)
+      ScratchPad.recorded.should == [obj, { freeze: false }]
     end
 
-    ruby_version_is '3.0' do
-      it "calls #initialize_clone with kwargs freeze: false" do
-        obj = KernelSpecs::CloneFreeze.new
-        obj.clone(freeze: false)
-        ScratchPad.recorded.should == [obj, { freeze: false }]
-      end
-
-      it "calls #initialize_clone with kwargs freeze: false even if #initialize_clone only takes a single argument" do
-        obj = KernelSpecs::Clone.new
-        -> { obj.clone(freeze: false) }.should raise_error(ArgumentError, 'wrong number of arguments (given 2, expected 1)')
-      end
+    it "calls #initialize_clone with kwargs freeze: false even if #initialize_clone only takes a single argument" do
+      obj = KernelSpecs::Clone.new
+      -> { obj.clone(freeze: false) }.should raise_error(ArgumentError, 'wrong number of arguments (given 2, expected 1)')
     end
   end
 
diff --git a/spec/ruby/core/kernel/eval_spec.rb b/spec/ruby/core/kernel/eval_spec.rb
index 9be0f2dfd3..e6761ab789 100644
--- a/spec/ruby/core/kernel/eval_spec.rb
+++ b/spec/ruby/core/kernel/eval_spec.rb
@@ -159,37 +159,18 @@ describe "Kernel#eval" do
     end
   end
 
-  ruby_version_is ""..."3.0" do
-    it "uses the filename of the binding if none is provided" do
-      eval("__FILE__").should == "(eval)"
-      suppress_warning {eval("__FILE__", binding)}.should == __FILE__
-      eval("__FILE__", binding, "success").should == "success"
-      suppress_warning {eval("eval '__FILE__', binding")}.should == "(eval)"
-      suppress_warning {eval("eval '__FILE__', binding", binding)}.should == __FILE__
-      suppress_warning {eval("eval '__FILE__', binding", binding, 'success')}.should == 'success'
-    end
-
-    it 'uses the given binding file and line for __FILE__ and __LINE__' do
-      suppress_warning {
-        eval("[__FILE__, __LINE__]", binding).should == [__FILE__, __LINE__]
-      }
-    end
-  end
-
-  ruby_version_is "3.0" do
-    it "uses (eval) filename if none is provided" do
-      eval("__FILE__").should == "(eval)"
-      eval("__FILE__", binding).should == "(eval)"
-      eval("__FILE__", binding, "success").should == "success"
-      eval("eval '__FILE__', binding").should == "(eval)"
-      eval("eval '__FILE__', binding", binding).should == "(eval)"
-      eval("eval '__FILE__', binding", binding, 'success').should == '(eval)'
-      eval("eval '__FILE__', binding, 'success'", binding).should == 'success'
-    end
-
-    it 'uses (eval) for __FILE__ and 1 for __LINE__ with a binding argument' do
-      eval("[__FILE__, __LINE__]", binding).should == ["(eval)", 1]
-    end
+  it "uses (eval) filename if none is provided" do
+    eval("__FILE__").should == "(eval)"
+    eval("__FILE__", binding).should == "(eval)"
+    eval("__FILE__", binding, "success").should == "success"
+    eval("eval '__FILE__', binding").should == "(eval)"
+    eval("eval '__FILE__', binding", binding).should == "(eval)"
+    eval("eval '__FILE__', binding", binding, 'success').should == '(eval)'
+    eval("eval '__FILE__', binding, 'success'", binding).should == 'success'
+  end
+
+  it 'uses (eval) for __FILE__ and 1 for __LINE__ with a binding argument' do
+    eval("[__FILE__, __LINE__]", binding).should == ["(eval)", 1]
   end
 
   # Found via Rubinius bug github:#149
diff --git a/spec/ruby/core/kernel/initialize_clone_spec.rb b/spec/ruby/core/kernel/initialize_clone_spec.rb
index 2d889f5aad..21a90c19f0 100644
--- a/spec/ruby/core/kernel/initialize_clone_spec.rb
+++ b/spec/ruby/core/kernel/initialize_clone_spec.rb
@@ -18,11 +18,9 @@ describe "Kernel#initialize_clone" do
     a.send(:initialize_clone, b)
   end
 
-  ruby_version_is "3.0" do
-    it "accepts a :freeze keyword argument for obj.clone(freeze: value)" do
-      a = Object.new
-      b = Object.new
-      a.send(:initialize_clone, b, freeze: true).should == a
-    end
+  it "accepts a :freeze keyword argument for obj.clone(freeze: value)" do
+    a = Object.new
+    b = Object.new
+    a.send(:initialize_clone, b, freeze: true).should == a
   end
 end
diff --git a/spec/ruby/core/kernel/iterator_spec.rb b/spec/ruby/core/kernel/iterator_spec.rb
deleted file mode 100644
index 3fe8317f26..0000000000
--- a/spec/ruby/core/kernel/iterator_spec.rb
+++ /dev/null
@@ -1,14 +0,0 @@
-require_relative '../../spec_helper'
-require_relative 'fixtures/classes'
-
-ruby_version_is ""..."3.0" do
-  describe "Kernel#iterator?" do
-    it "is a private method" do
-      Kernel.should have_private_instance_method(:iterator?)
-    end
-  end
-
-  describe "Kernel.iterator?" do
-    it "needs to be reviewed for spec completeness"
-  end
-end
diff --git a/spec/ruby/core/kernel/lambda_spec.rb b/spec/ruby/core/kernel/lambda_spec.rb
index 2aa4d4f2fb..2f7abc749c 100644
--- a/spec/ruby/core/kernel/lambda_spec.rb
+++ b/spec/ruby/core/kernel/lambda_spec.rb
@@ -136,15 +136,13 @@ describe "Kernel.lambda" do
     klass.new.ret.should == 1
   end
 
-  ruby_version_is "3.0" do
-    context "when called without a literal block" do
-      it "warns when proc isn't a lambda" do
-        -> { lambda(&proc{}) }.should complain("#{__FILE__}:#{__LINE__}: warning: lambda without a literal block is deprecated; use the proc without lambda instead\n")
-      end
+  context "when called without a literal block" do
+    it "warns when proc isn't a lambda" do
+      -> { lambda(&proc{}) }.should complain("#{__FILE__}:#{__LINE__}: warning: lambda without a literal block is deprecated; use the proc without lambda instead\n")
+    end
 
-      it "doesn't warn when proc is lambda" do
-        -> { lambda(&lambda{}) }.should_not complain(verbose: true)
-      end
+    it "doesn't warn when proc is lambda" do
+      -> { lambda(&lambda{}) }.should_not complain(verbose: true)
     end
   end
 end
diff --git a/spec/ruby/core/kernel/open_spec.rb b/spec/ruby/core/kernel/open_spec.rb
index bad2ae9d2c..99793294c5 100644
--- a/spec/ruby/core/kernel/open_spec.rb
+++ b/spec/ruby/core/kernel/open_spec.rb
@@ -72,15 +72,13 @@ describe "Kernel#open" do
     -> { open }.should raise_error(ArgumentError)
   end
 
-  ruby_version_is "3.0" do
-    it "accepts options as keyword arguments" do
-      @file = open(@name, "r", 0666, flags: File::CREAT)
-      @file.should be_kind_of(File)
+  it "accepts options as keyword arguments" do
+    @file = open(@name, "r", 0666, flags: File::CREAT)
+    @file.should be_kind_of(File)
 
-      -> {
-        open(@name, "r", 0666, {flags: File::CREAT})
-      }.should raise_error(ArgumentError, "wrong number of arguments (given 4, expected 1..3)")
-    end
+    -> {
+      open(@name, "r", 0666, {flags: File::CREAT})
+    }.should raise_error(ArgumentError, "wrong number of arguments (given 4, expected 1..3)")
   end
 
   describe "when given an object that responds to to_open" do
@@ -158,28 +156,14 @@ describe "Kernel#open" do
     open(@name, nil, nil) { |f| f.gets }.should == @content
   end
 
-  ruby_version_is ""..."3.0" do
-    it "works correctly when redefined by open-uri" do
-      code = <<~RUBY
+  it "is not redefined by open-uri" do
+    code = <<~RUBY
+      before = Kernel.instance_method(:open)
       require 'open-uri'
-      obj = Object.new
-      def obj.to_open; self; end
-      p open(obj) == obj
-      RUBY
-      ruby_exe(code, args: "2>&1").should == "true\n"
-    end
-  end
-
-  ruby_version_is "3.0" do
-    it "is not redefined by open-uri" do
-      code = <<~RUBY
-        before = Kernel.instance_method(:open)
-        require 'open-uri'
-        after = Kernel.instance_method(:open)
-        p before == after
-      RUBY
-      ruby_exe(code, args: "2>&1").should == "true\n"
-    end
+      after = Kernel.instance_method(:open)
+      p before == after
+    RUBY
+    ruby_exe(code, args: "2>&1").should == "true\n"
   end
 end
 
diff --git a/spec/ruby/core/kernel/proc_spec.rb b/spec/ruby/core/kernel/proc_spec.rb
index 231c1f0dfb..6553b8fd04 100644
--- a/spec/ruby/core/kernel/proc_spec.rb
+++ b/spec/ruby/core/kernel/proc_spec.rb
@@ -40,19 +40,9 @@ describe "Kernel#proc" do
     proc
   end
 
-  ruby_version_is ""..."3.0" do
-    it "can be created when called with no block" do
-      -> {
-        some_method { "hello" }
-      }.should complain(/Capturing the given block using Kernel#proc is deprecated/)
-    end
-  end
-
-  ruby_version_is "3.0" do
-    it "raises an ArgumentError when passed no block" do
-      -> {
-        some_method { "hello" }
-      }.should raise_error(ArgumentError, 'tried to create Proc object without a block')
-    end
+  it "raises an ArgumentError when passed no block" do
+    -> {
+      some_method { "hello" }
+    }.should raise_error(ArgumentError, 'tried to create Proc object without a block')
   end
 end
diff --git a/spec/ruby/core/kernel/shared/require.rb b/spec/ruby/core/kernel/shared/require.rb
index 5cbc11c9ec..61081b200c 100644
--- a/spec/ruby/core/kernel/shared/require.rb
+++ b/spec/ruby/core/kernel/shared/require.rb
@@ -262,13 +262,11 @@ describe :kernel_require, shared: true do
       ScratchPad.recorded.should == [:loaded]
     end
 
-    ruby_bug "#16926", ""..."3.0" do
-      it "does not load a feature twice when $LOAD_PATH has been modified" do
-        $LOAD_PATH.replace [CODE_LOADING_DIR]
-        @object.require("load_fixture").should be_true
-        $LOAD_PATH.replace [File.expand_path("b", CODE_LOADING_DIR), CODE_LOADING_DIR]
-        @object.require("load_fixture").should be_false
-      end
+    it "does not load a feature twice when $LOAD_PATH has been modified" do
+      $LOAD_PATH.replace [CODE_LOADING_DIR]
+      @object.require("load_fixture").should be_true
+      $LOAD_PATH.replace [File.expand_path("b", CODE_LOADING_DIR), CODE_LOADING_DIR]
+      @object.require("load_fixture").should be_false
     end
   end
 
@@ -566,23 +564,21 @@ describe :kernel_require, shared: true do
       -> { @object.require("unicode_normalize") }.should raise_error(LoadError)
     end
 
-    ruby_version_is "3.0" do
-      it "does not load a file earlier on the $LOAD_PATH when other similar features were already loaded" do
-        Dir.chdir CODE_LOADING_DIR do
-          @object.send(@method, "../code/load_fixture").should be_true
-        end
-        ScratchPad.recorded.should == [:loaded]
+    it "does not load a file earlier on the $LOAD_PATH when other similar features were already loaded" do
+      Dir.chdir CODE_LOADING_DIR do
+        @object.send(@method, "../code/load_fixture").should be_true
+      end
+      ScratchPad.recorded.should == [:loaded]
 
-        $LOAD_PATH.unshift "#{CODE_LOADING_DIR}/b"
-        # This loads because the above load was not on the $LOAD_PATH
-        @object.send(@method, "load_fixture").should be_true
-        ScratchPad.recorded.should == [:loaded, :loaded]
+      $LOAD_PATH.unshift "#{CODE_LOADING_DIR}/b"
+      # This loads because the above load was not on the $LOAD_PATH
+      @object.send(@method, "load_fixture").should be_true
+      ScratchPad.recorded.should == [:loaded, :loaded]
 
-        $LOAD_PATH.unshift "#{CODE_LOADING_DIR}/c"
-        # This does not load because the above load was on the $LOAD_PATH
-        @object.send(@method, "load_fixture").should be_false
-        ScratchPad.recorded.should == [:loaded, :loaded]
-      end
+      $LOAD_PATH.unshift "#{CODE_LOADING_DIR}/c"
+      # This does not load because the above load was on the $LOAD_PATH
+      @object.send(@method, "load_fixture").should be_false
+      ScratchPad.recorded.should == [:loaded, :loaded]
     end
   end
 
diff --git a/spec/ruby/core/kernel/singleton_class_spec.rb b/spec/ruby/core/kernel/singleton_class_spec.rb
index 4865e29c10..23c400f9bd 100644
--- a/spec/ruby/core/kernel/singleton_class_spec.rb
+++ b/spec/ruby/core/kernel/singleton_class_spec.rb
@@ -1,3 +1,4 @@
+# truffleruby_primitives: true
 require_relative '../../spec_helper'
 
 describe "Kernel#singleton_class" do
@@ -42,4 +43,32 @@ describe "Kernel#singleton_class" do
     obj.freeze
     obj.singleton_class.frozen?.should be_true
   end
+
+  context "for an IO object with a replaced singleton class" do
+    it "looks up singleton methods from the fresh singleton class after an object instance got a new one" do
+      proxy = -> io { io.foo }
+      if RUBY_ENGINE == 'truffleruby'
+        # We need an inline cache with only this object seen, the best way to do that is to use a Primitive
+        sclass = -> io { Primitive.singleton_class(io) }
+      else
+        sclass = -> io { io.singleton_class }
+      end
+
+      io = File.new(__FILE__)
+      io.define_singleton_method(:foo) { "old" }
+      sclass1 = sclass.call(io)
+      proxy.call(io).should == "old"
+
+      # IO#reopen is the only method which can replace an object's singleton class
+      io2 = File.new(__FILE__)
+      io.reopen(io2)
+      io.define_singleton_method(:foo) { "new" }
+      sclass2 = sclass.call(io)
+      sclass2.should_not.equal?(sclass1)
+      proxy.call(io).should == "new"
+    ensure
+      io2.close
+      io.close
+    end
+  end
 end
diff --git a/spec/ruby/core/kernel/taint_spec.rb b/spec/ruby/core/kernel/taint_spec.rb
index eff9b4a450..0c16b1dbbf 100644
--- a/spec/ruby/core/kernel/taint_spec.rb
+++ b/spec/ruby/core/kernel/taint_spec.rb
@@ -4,9 +4,11 @@ require_relative 'fixtures/classes'
 describe "Kernel#taint" do
   ruby_version_is ""..."3.2" do
     it "is a no-op" do
-      o = Object.new
-      o.taint
-      o.should_not.tainted?
+      suppress_warning do
+        o = Object.new
+        o.taint
+        o.should_not.tainted?
+      end
     end
 
     it "warns in verbose mode" do
diff --git a/spec/ruby/core/kernel/tainted_spec.rb b/spec/ruby/core/kernel/tainted_spec.rb
index 4e81971e58..fcae433069 100644
--- a/spec/ruby/core/kernel/tainted_spec.rb
+++ b/spec/ruby/core/kernel/tainted_spec.rb
@@ -4,11 +4,13 @@ require_relative 'fixtures/classes'
 describe "Kernel#tainted?" do
   ruby_version_is ""..."3.2" do
     it "is a no-op" do
-      o = mock('o')
-      p = mock('p')
-      p.taint
-      o.should_not.tainted?
-      p.should_not.tainted?
+      suppress_warning do
+        o = mock('o')
+        p = mock('p')
+        p.taint
+        o.should_not.tainted?
+        p.should_not.tainted?
+      end
     end
 
     it "warns in verbose mode" do
diff --git a/spec/ruby/core/kernel/trust_spec.rb b/spec/ruby/core/kernel/trust_spec.rb
index 3a49ab3085..db6f17e0fb 100644
--- a/spec/ruby/core/kernel/trust_spec.rb
+++ b/spec/ruby/core/kernel/trust_spec.rb
@@ -4,10 +4,12 @@ require_relative 'fixtures/classes'
 describe "Kernel#trust" do
   ruby_version_is ""..."3.2" do
     it "is a no-op" do
-      o = Object.new.untrust
-      o.should_not.untrusted?
-      o.trust
-      o.should_not.untrusted?
+      suppress_warning do
+        o = Object.new.untrust
+        o.should_not.untrusted?
+        o.trust
+        o.should_not.untrusted?
+      end
     end
 
     it "warns in verbose mode" do
diff --git a/spec/ruby/core/kernel/untaint_spec.rb b/spec/ruby/core/kernel/untaint_spec.rb
index a543025c5d..26b2aabbe9 100644
--- a/spec/ruby/core/kernel/untaint_spec.rb
+++ b/spec/ruby/core/kernel/untaint_spec.rb
@@ -4,10 +4,12 @@ require_relative 'fixtures/classes'
 describe "Kernel#untaint" do
   ruby_version_is ""..."3.2" do
     it "is a no-op" do
-      o = Object.new.taint
-      o.should_not.tainted?
-      o.untaint
-      o.should_not.tainted?
+      suppress_warning do
+        o = Object.new.taint
+        o.should_not.tainted?
+        o.untaint
+        o.should_not.tainted?
+      end
     end
 
     it "warns in verbose mode" do
diff --git a/spec/ruby/core/kernel/untrust_spec.rb b/spec/ruby/core/kernel/untrust_spec.rb
index 6eefb624c0..5310cd8eb4 100644
--- a/spec/ruby/core/kernel/untrust_spec.rb
+++ b/spec/ruby/core/kernel/untrust_spec.rb
@@ -4,9 +4,11 @@ require_relative 'fixtures/classes'
 describe "Kernel#untrust" do
   ruby_version_is ""..."3.2" do
     it "is a no-op" do
-      o = Object.new
-      o.untrust
-      o.should_not.untrusted?
+      suppress_warning do
+        o = Object.new
+        o.untrust
+        o.should_not.untrusted?
+      end
     end
 
     it "warns in verbose mode" do
diff --git a/spec/ruby/core/kernel/untrusted_spec.rb b/spec/ruby/core/kernel/untrusted_spec.rb
index bd0bf154ed..ea36d6c98c 100644
--- a/spec/ruby/core/kernel/untrusted_spec.rb
+++ b/spec/ruby/core/kernel/untrusted_spec.rb
@@ -4,10 +4,12 @@ require_relative 'fixtures/classes'
 describe "Kernel#untrusted?" do
   ruby_version_is ""..."3.2" do
     it "is a no-op" do
-      o = mock('o')
-      o.should_not.untrusted?
-      o.untrust
-      o.should_not.untrusted?
+      suppress_warning do
+        o = mock('o')
+        o.should_not.untrusted?
+        o.untrust
+        o.should_not.untrusted?
+      end
     end
 
     it "warns in verbose mode" do
diff --git a/spec/ruby/core/kernel/warn_spec.rb b/spec/ruby/core/kernel/warn_spec.rb
index 7df6fa72d1..00164ad90b 100644
--- a/spec/ruby/core/kernel/warn_spec.rb
+++ b/spec/ruby/core/kernel/warn_spec.rb
@@ -128,36 +128,34 @@ describe "Kernel#warn" do
       end
     end
 
-    ruby_version_is "3.0" do
-      it "accepts :category keyword with a symbol" do
-        -> {
-          $VERBOSE = true
-          warn("message", category: :deprecated)
-        }.should output(nil, "message\n")
-      end
+    it "accepts :category keyword with a symbol" do
+      -> {
+        $VERBOSE = true
+        warn("message", category: :deprecated)
+      }.should output(nil, "message\n")
+    end
 
-      it "accepts :category keyword with nil" do
-        -> {
-          $VERBOSE = true
-          warn("message", category: nil)
-        }.should output(nil, "message\n")
-      end
+    it "accepts :category keyword with nil" do
+      -> {
+        $VERBOSE = true
+        warn("message", category: nil)
+      }.should output(nil, "message\n")
+    end
 
-      it "accepts :category keyword with object convertible to symbol" do
-        o = Object.new
-        def o.to_sym; :deprecated; end
-        -> {
-          $VERBOSE = true
-          warn("message", category: o)
-        }.should output(nil, "message\n")
-      end
+    it "accepts :category keyword with object convertible to symbol" do
+      o = Object.new
+      def o.to_sym; :deprecated; end
+      -> {
+        $VERBOSE = true
+        warn("message", category: o)
+      }.should output(nil, "message\n")
+    end
 
-      it "raises if :category keyword is not nil and not convertible to symbol" do
-        -> {
-          $VERBOSE = true
-          warn("message", category: Object.new)
-        }.should raise_error(TypeError)
-      end
+    it "raises if :category keyword is not nil and not convertible to symbol" do
+      -> {
+        $VERBOSE = true
+        warn("message", category: Object.new)
+      }.should raise_error(TypeError)
     end
 
     it "converts first arg using to_s" do
@@ -212,67 +210,52 @@ describe "Kernel#warn" do
     -> { warn('foo', **h) }.should complain("foo\n")
   end
 
-  ruby_version_is '3.0' do
-    it "calls Warning.warn without keyword arguments if Warning.warn does not accept keyword arguments" do
-      verbose = $VERBOSE
-      $VERBOSE = false
-      class << Warning
-        alias_method :_warn, :warn
-        def warn(message)
-          ScratchPad.record(message)
-        end
-      end
-
-      begin
-        ScratchPad.clear
-        Kernel.warn("Chunky bacon!")
-        ScratchPad.recorded.should == "Chunky bacon!\n"
-
-        Kernel.warn("Deprecated bacon!", category: :deprecated)
-        ScratchPad.recorded.should == "Deprecated bacon!\n"
-      ensure
-        class << Warning
-          remove_method :warn
-          alias_method :warn, :_warn
-          remove_method :_warn
-        end
-        $VERBOSE = verbose
+  it "calls Warning.warn without keyword arguments if Warning.warn does not accept keyword arguments" do
+    verbose = $VERBOSE
+    $VERBOSE = false
+    class << Warning
+      alias_method :_warn, :warn
+      def warn(message)
+        ScratchPad.record(message)
       end
     end
 
-    it "calls Warning.warn with category: nil if Warning.warn accepts keyword arguments" do
-      Warning.should_receive(:warn).with("Chunky bacon!\n", category: nil)
-      verbose = $VERBOSE
-      $VERBOSE = false
-      begin
-        Kernel.warn("Chunky bacon!")
-      ensure
-        $VERBOSE = verbose
+    begin
+      ScratchPad.clear
+      Kernel.warn("Chunky bacon!")
+      ScratchPad.recorded.should == "Chunky bacon!\n"
+
+      Kernel.warn("Deprecated bacon!", category: :deprecated)
+      ScratchPad.recorded.should == "Deprecated bacon!\n"
+    ensure
+      class << Warning
+        remove_method :warn
+        alias_method :warn, :_warn
+        remove_method :_warn
       end
+      $VERBOSE = verbose
     end
+  end
 
-    it "calls Warning.warn with given category keyword converted to a symbol" do
-      Warning.should_receive(:warn).with("Chunky bacon!\n", category: :deprecated)
-      verbose = $VERBOSE
-      $VERBOSE = false
-      begin
-        Kernel.warn("Chunky bacon!", category: 'deprecated')
-      ensure
-        $VERBOSE = verbose
-      end
+  it "calls Warning.warn with category: nil if Warning.warn accepts keyword arguments" do
+    Warning.should_receive(:warn).with("Chunky bacon!\n", category: nil)
+    verbose = $VERBOSE
+    $VERBOSE = false
+    begin
+      Kernel.warn("Chunky bacon!")
+    ensure
+      $VERBOSE = verbose
     end
   end
 
-  ruby_version_is ''...'3.0' do
-    it "calls Warning.warn with no keyword arguments" do
-      Warning.should_receive(:warn).with("Chunky bacon!\n")
-      verbose = $VERBOSE
-      $VERBOSE = false
-      begin
-        Kernel.warn("Chunky bacon!")
-      ensure
-        $VERBOSE = verbose
-      end
+  it "calls Warning.warn with given category keyword converted to a symbol" do
+    Warning.should_receive(:warn).with("Chunky bacon!\n", category: :deprecated)
+    verbose = $VERBOSE
+    $VERBOSE = false
+    begin
+      Kernel.warn("Chunky bacon!", category: 'deprecated')
+    ensure
+      $VERBOSE = verbose
     end
   end
 
diff --git a/spec/ruby/core/main/private_spec.rb b/spec/ruby/core/main/private_spec.rb
index cac0645b40..e8c1f3f44c 100644
--- a/spec/ruby/core/main/private_spec.rb
+++ b/spec/ruby/core/main/private_spec.rb
@@ -22,13 +22,11 @@ describe "main#private" do
     end
   end
 
-  ruby_version_is "3.0" do
-    context "when single argument is passed and is an array" do
-      it "sets the visibility of the given methods to private" do
-        eval "private [:main_public_method, :main_public_method2]", TOPLEVEL_BINDING
-        Object.should have_private_method(:main_public_method)
-        Object.should have_private_method(:main_public_method2)
-      end
+  context "when single argument is passed and is an array" do
+    it "sets the visibility of the given methods to private" do
+      eval "private [:main_public_method, :main_public_method2]", TOPLEVEL_BINDING
+      Object.should have_private_method(:main_public_method)
+      Object.should have_private_method(:main_public_method2)
     end
   end
 
diff --git a/spec/ruby/core/main/public_spec.rb b/spec/ruby/core/main/public_spec.rb
index 91f045dbab..31baad4583 100644
--- a/spec/ruby/core/main/public_spec.rb
+++ b/spec/ruby/core/main/public_spec.rb
@@ -22,13 +22,11 @@ describe "main#public" do
     end
   end
 
-  ruby_version_is "3.0" do
-    context "when single argument is passed and is an array" do
-      it "sets the visibility of the given methods to public" do
-        eval "public [:main_private_method, :main_private_method2]", TOPLEVEL_BINDING
-        Object.should_not have_private_method(:main_private_method)
-        Object.should_not have_private_method(:main_private_method2)
-      end
+  context "when single argument is passed and is an array" do
+    it "sets the visibility of the given methods to public" do
+      eval "public [:main_private_method, :main_private_method2]", TOPLEVEL_BINDING
+      Object.should_not have_private_method(:main_private_method)
+      Object.should_not have_private_method(:main_private_method2)
     end
   end
 
diff --git a/spec/ruby/core/marshal/dump_spec.rb b/spec/ruby/core/marshal/dump_spec.rb
index f38250b513..c694b48bab 100644
--- a/spec/ruby/core/marshal/dump_spec.rb
+++ b/spec/ruby/core/marshal/dump_spec.rb
@@ -626,17 +626,6 @@ describe "Marshal.dump" do
       load.should == (1...2)
     end
 
-    ruby_version_is ""..."3.0" do
-      it "dumps a Range with extra instance variables" do
-        range = (1...3)
-        range.instance_variable_set :@foo, 42
-        dump = Marshal.dump(range)
-        load = Marshal.load(dump)
-        load.should == range
-        load.instance_variable_get(:@foo).should == 42
-      end
-    end
-
     it "raises TypeError with an anonymous Range subclass" do
       -> { Marshal.dump(Class.new(Range).new(1, 2)) }.should raise_error(TypeError, /can't dump anonymous class/)
     end
diff --git a/spec/ruby/core/marshal/shared/load.rb b/spec/ruby/core/marshal/shared/load.rb
index bc094f28f2..b37e65071d 100644
--- a/spec/ruby/core/marshal/shared/load.rb
+++ b/spec/ruby/core/marshal/shared/load.rb
@@ -623,6 +623,14 @@ describe :marshal_load, shared: true do
       value.map(&:encoding).should == [Encoding::UTF_8, Encoding::UTF_8, Encoding::UTF_8]
       value.should == [*expected, expected[0]]
     end
+
+    it "raises ArgumentError when end of byte sequence reached before symbol characters end" do
+      Marshal.dump(:hello).should == "\x04\b:\nhello"
+
+      -> {
+        Marshal.send(@method, "\x04\b:\nhel")
+      }.should raise_error(ArgumentError, "marshal data too short")
+    end
   end
 
   describe "for a String" do
@@ -685,6 +693,14 @@ describe :marshal_load, shared: true do
       result.encoding.should == Encoding::BINARY
       result.should == str
     end
+
+    it "raises ArgumentError when end of byte sequence reached before string characters end" do
+      Marshal.dump("hello").should == "\x04\b\"\nhello"
+
+      -> {
+        Marshal.send(@method, "\x04\b\"\nhel")
+      }.should raise_error(ArgumentError, "marshal data too short")
+    end
   end
 
   describe "for a Struct" do
@@ -819,6 +835,14 @@ describe :marshal_load, shared: true do
         Marshal.send(@method, "\x04\bo:\tFile\001\001:\001\005@path\"\x10/etc/passwd")
       end.should raise_error(ArgumentError)
     end
+
+    it "raises ArgumentError when end of byte sequence reached before class name end" do
+      Marshal.dump(Object.new).should == "\x04\bo:\vObject\x00"
+
+      -> {
+        Marshal.send(@method, "\x04\bo:\vObj")
+      }.should raise_error(ArgumentError, "marshal data too short")
+    end
   end
 
   describe "for an object responding to #marshal_dump and #marshal_load" do
@@ -908,6 +932,14 @@ describe :marshal_load, shared: true do
       regexp.encoding.should == Encoding::UTF_32LE
       regexp.source.should == "a".encode("utf-32le")
     end
+
+    it "raises ArgumentError when end of byte sequence reached before source string end" do
+      Marshal.dump(/hello world/).should == "\x04\bI/\x10hello world\x00\x06:\x06EF"
+
+      -> {
+        Marshal.send(@method, "\x04\bI/\x10hel")
+      }.should raise_error(ArgumentError, "marshal data too short")
+    end
   end
 
   describe "for a Float" do
@@ -929,6 +961,14 @@ describe :marshal_load, shared: true do
       obj = 1.1867345e+22
       Marshal.send(@method, "\004\bf\0361.1867344999999999e+22\000\344@").should == obj
     end
+
+    it "raises ArgumentError when end of byte sequence reached before float string representation end" do
+      Marshal.dump(1.3).should == "\x04\bf\b1.3"
+
+      -> {
+        Marshal.send(@method, "\004\bf\v1")
+      }.should raise_error(ArgumentError, "marshal data too short")
+    end
   end
 
   describe "for an Integer" do
@@ -1114,6 +1154,14 @@ describe :marshal_load, shared: true do
     it "raises ArgumentError if given a nonexistent class" do
       -> { Marshal.send(@method, "\x04\bc\vStrung") }.should raise_error(ArgumentError)
     end
+
+    it "raises ArgumentError when end of byte sequence reached before class name end" do
+      Marshal.dump(String).should == "\x04\bc\vString"
+
+      -> {
+        Marshal.send(@method, "\x04\bc\vStr")
+      }.should raise_error(ArgumentError, "marshal data too short")
+    end
   end
 
   describe "for a Module" do
@@ -1128,6 +1176,14 @@ describe :marshal_load, shared: true do
     it "loads an old module" do
       Marshal.send(@method, "\x04\bM\vKernel").should == Kernel
     end
+
+    it "raises ArgumentError when end of byte sequence reached before module name end" do
+      Marshal.dump(Kernel).should == "\x04\bm\vKernel"
+
+      -> {
+        Marshal.send(@method, "\x04\bm\vKer")
+      }.should raise_error(ArgumentError, "marshal data too short")
+    end
   end
 
   describe "for a wrapped C pointer" do
diff --git a/spec/ruby/core/matchdata/element_reference_spec.rb b/spec/ruby/core/matchdata/element_reference_spec.rb
index 0e0d3991cb..1be399cfe1 100644
--- a/spec/ruby/core/matchdata/element_reference_spec.rb
+++ b/spec/ruby/core/matchdata/element_reference_spec.rb
@@ -48,11 +48,9 @@ describe "MatchData#[]" do
     /(.)(.)(\d+)(\d)/.match("THX1138.")[nil..nil].should == %w|HX1138 H X 113 8|
   end
 
-  ruby_version_is "3.0" do
-    it "returns instances of String when given a String subclass" do
-      str = MatchDataSpecs::MyString.new("THX1138.")
-      /(.)(.)(\d+)(\d)/.match(str)[0..-1].each { |m| m.should be_an_instance_of(String) }
-    end
+  it "returns instances of String when given a String subclass" do
+    str = MatchDataSpecs::MyString.new("THX1138.")
+    /(.)(.)(\d+)(\d)/.match(str)[0..-1].each { |m| m.should be_an_instance_of(String) }
   end
 end
 
diff --git a/spec/ruby/core/matchdata/post_match_spec.rb b/spec/ruby/core/matchdata/post_match_spec.rb
index d3aa4c8900..b8d1e032eb 100644
--- a/spec/ruby/core/matchdata/post_match_spec.rb
+++ b/spec/ruby/core/matchdata/post_match_spec.rb
@@ -17,10 +17,8 @@ describe "MatchData#post_match" do
     str.match(/c/).post_match.encoding.should equal(Encoding::ISO_8859_1)
   end
 
-  ruby_version_is "3.0" do
-    it "returns an instance of String when given a String subclass" do
-      str = MatchDataSpecs::MyString.new("THX1138: The Movie")
-      /(.)(.)(\d+)(\d)/.match(str).post_match.should be_an_instance_of(String)
-    end
+  it "returns an instance of String when given a String subclass" do
+    str = MatchDataSpecs::MyString.new("THX1138: The Movie")
+    /(.)(.)(\d+)(\d)/.match(str).post_match.should be_an_instance_of(String)
   end
 end
diff --git a/spec/ruby/core/matchdata/pre_match_spec.rb b/spec/ruby/core/matchdata/pre_match_spec.rb
index b43be5fb41..741cb6e923 100644
--- a/spec/ruby/core/matchdata/pre_match_spec.rb
+++ b/spec/ruby/core/matchdata/pre_match_spec.rb
@@ -17,10 +17,8 @@ describe "MatchData#pre_match" do
     str.match(/a/).pre_match.encoding.should equal(Encoding::ISO_8859_1)
   end
 
-  ruby_version_is "3.0" do
-    it "returns an instance of String when given a String subclass" do
-      str = MatchDataSpecs::MyString.new("THX1138: The Movie")
-      /(.)(.)(\d+)(\d)/.match(str).pre_match.should be_an_instance_of(String)
-    end
+  it "returns an instance of String when given a String subclass" do
+    str = MatchDataSpecs::MyString.new("THX1138: The Movie")
+    /(.)(.)(\d+)(\d)/.match(str).pre_match.should be_an_instance_of(String)
   end
 end
diff --git a/spec/ruby/core/matchdata/shared/captures.rb b/spec/ruby/core/matchdata/shared/captures.rb
index d2c85ece5a..33f834561a 100644
--- a/spec/ruby/core/matchdata/shared/captures.rb
+++ b/spec/ruby/core/matchdata/shared/captures.rb
@@ -6,10 +6,8 @@ describe :matchdata_captures, shared: true do
     /(.)(.)(\d+)(\d)/.match("THX1138.").send(@method).should == ["H","X","113","8"]
   end
 
-  ruby_version_is "3.0" do
-    it "returns instances of String when given a String subclass" do
-      str = MatchDataSpecs::MyString.new("THX1138: The Movie")
-      /(.)(.)(\d+)(\d)/.match(str).send(@method).each { |c| c.should be_an_instance_of(String) }
-    end
+  it "returns instances of String when given a String subclass" do
+    str = MatchDataSpecs::MyString.new("THX1138: The Movie")
+    /(.)(.)(\d+)(\d)/.match(str).send(@method).each { |c| c.should be_an_instance_of(String) }
   end
 end
diff --git a/spec/ruby/core/matchdata/to_a_spec.rb b/spec/ruby/core/matchdata/to_a_spec.rb
index 50f5a161a5..4fa11ff604 100644
--- a/spec/ruby/core/matchdata/to_a_spec.rb
+++ b/spec/ruby/core/matchdata/to_a_spec.rb
@@ -6,10 +6,8 @@ describe "MatchData#to_a" do
     /(.)(.)(\d+)(\d)/.match("THX1138.").to_a.should == ["HX1138", "H", "X", "113", "8"]
   end
 
-  ruby_version_is "3.0" do
-    it "returns instances of String when given a String subclass" do
-      str = MatchDataSpecs::MyString.new("THX1138.")
-      /(.)(.)(\d+)(\d)/.match(str)[0..-1].to_a.each { |m| m.should be_an_instance_of(String) }
-    end
+  it "returns instances of String when given a String subclass" do
+    str = MatchDataSpecs::MyString.new("THX1138.")
+    /(.)(.)(\d+)(\d)/.match(str)[0..-1].to_a.each { |m| m.should be_an_instance_of(String) }
   end
 end
diff --git a/spec/ruby/core/matchdata/to_s_spec.rb b/spec/ruby/core/matchdata/to_s_spec.rb
index aab0955ae1..cd1c4dbca2 100644
--- a/spec/ruby/core/matchdata/to_s_spec.rb
+++ b/spec/ruby/core/matchdata/to_s_spec.rb
@@ -6,10 +6,8 @@ describe "MatchData#to_s" do
     /(.)(.)(\d+)(\d)/.match("THX1138.").to_s.should == "HX1138"
   end
 
-  ruby_version_is "3.0" do
-    it "returns an instance of String when given a String subclass" do
-      str = MatchDataSpecs::MyString.new("THX1138.")
-      /(.)(.)(\d+)(\d)/.match(str).to_s.should be_an_instance_of(String)
-    end
+  it "returns an instance of String when given a String subclass" do
+    str = MatchDataSpecs::MyString.new("THX1138.")
+    /(.)(.)(\d+)(\d)/.match(str).to_s.should be_an_instance_of(String)
   end
 end
diff --git a/spec/ruby/core/method/compose_spec.rb b/spec/ruby/core/method/compose_spec.rb
index 87cf61f7ad..7506e33ea8 100644
--- a/spec/ruby/core/method/compose_spec.rb
+++ b/spec/ruby/core/method/compose_spec.rb
@@ -38,8 +38,7 @@ describe "Method#<<" do
       double = proc { |x| x + x }
 
       (pow_2 << double).is_a?(Proc).should == true
-      ruby_version_is(''...'3.0') { (pow_2 << double).should.lambda? }
-      ruby_version_is('3.0') { (pow_2 << double).should_not.lambda? }
+      (pow_2 << double).should_not.lambda?
     end
 
     it "may accept multiple arguments" do
diff --git a/spec/ruby/core/method/shared/to_s.rb b/spec/ruby/core/method/shared/to_s.rb
index 6fdeaaf99c..b2d27d370f 100644
--- a/spec/ruby/core/method/shared/to_s.rb
+++ b/spec/ruby/core/method/shared/to_s.rb
@@ -53,20 +53,18 @@ describe :method_to_s, shared: true do
     MethodSpecs::A.new.method(:baz).send(@method).should.start_with? "#<Method: MethodSpecs::A#baz"
   end
 
-  ruby_version_is '3.0' do
-    it "returns a String containing the Module containing the method if object has a singleton class but method is not defined in the singleton class" do
-      obj = MethodSpecs::MySub.new
-      obj.singleton_class
-      @m = obj.method(:bar)
-      @string = @m.send(@method)
-      @string.should.start_with? "#<Method: MethodSpecs::MySub(MethodSpecs::MyMod)#bar"
+  it "returns a String containing the Module containing the method if object has a singleton class but method is not defined in the singleton class" do
+    obj = MethodSpecs::MySub.new
+    obj.singleton_class
+    @m = obj.method(:bar)
+    @string = @m.send(@method)
+    @string.should.start_with? "#<Method: MethodSpecs::MySub(MethodSpecs::MyMod)#bar"
 
-      c = MethodSpecs::MySub.dup
-      m = Module.new{def bar; end}
-      c.extend(m)
-      @string = c.method(:bar).send(@method)
-      @string.should.start_with? "#<Method: #<Class:#{c.inspect}>(#{m.inspect})#bar"
-    end
+    c = MethodSpecs::MySub.dup
+    m = Module.new{def bar; end}
+    c.extend(m)
+    @string = c.method(:bar).send(@method)
+    @string.should.start_with? "#<Method: #<Class:#{c.inspect}>(#{m.inspect})#bar"
   end
 
   it "returns a String containing the singleton class if method is defined in the singleton class" do
@@ -77,9 +75,7 @@ describe :method_to_s, shared: true do
     @string.should.start_with? "#<Method: #<MethodSpecs::MySub:0xXXXXXX>.bar"
   end
 
-  ruby_bug '#17428', ''...'3.0' do
-    it "shows the metaclass and the owner for a Module instance method retrieved from a class" do
-      String.method(:include).inspect.should.start_with?("#<Method: #<Class:String>(Module)#include")
-    end
+  it "shows the metaclass and the owner for a Module instance method retrieved from a class" do
+    String.method(:include).inspect.should.start_with?("#<Method: #<Class:String>(Module)#include")
   end
 end
diff --git a/spec/ruby/core/module/alias_method_spec.rb b/spec/ruby/core/module/alias_method_spec.rb
index 391efa227a..c36dedd2d8 100644
--- a/spec/ruby/core/module/alias_method_spec.rb
+++ b/spec/ruby/core/module/alias_method_spec.rb
@@ -92,17 +92,9 @@ describe "Module#alias_method" do
   end
 
   describe "returned value" do
-    ruby_version_is ""..."3.0" do
-      it "returns self" do
-        @class.send(:alias_method, :checking_return_value, :public_one).should equal(@class)
-      end
-    end
-
-    ruby_version_is "3.0" do
-      it "returns symbol of the defined method name" do
-        @class.send(:alias_method, :checking_return_value, :public_one).should equal(:checking_return_value)
-        @class.send(:alias_method, 'checking_return_value', :public_one).should equal(:checking_return_value)
-      end
+    it "returns symbol of the defined method name" do
+      @class.send(:alias_method, :checking_return_value, :public_one).should equal(:checking_return_value)
+      @class.send(:alias_method, 'checking_return_value', :public_one).should equal(:checking_return_value)
     end
   end
 
diff --git a/spec/ruby/core/module/attr_accessor_spec.rb b/spec/ruby/core/module/attr_accessor_spec.rb
index ba5289cbea..eea5b4b64b 100644
--- a/spec/ruby/core/module/attr_accessor_spec.rb
+++ b/spec/ruby/core/module/attr_accessor_spec.rb
@@ -80,19 +80,9 @@ describe "Module#attr_accessor" do
     Module.should have_public_instance_method(:attr_accessor, false)
   end
 
-  ruby_version_is ""..."3.0" do
-    it "returns nil" do
-      Class.new do
-        (attr_accessor :foo, 'bar').should == nil
-      end
-    end
-  end
-
-  ruby_version_is "3.0" do
-    it "returns an array of defined method names as symbols" do
-      Class.new do
-        (attr_accessor :foo, 'bar').should == [:foo, :foo=, :bar, :bar=]
-      end
+  it "returns an array of defined method names as symbols" do
+    Class.new do
+      (attr_accessor :foo, 'bar').should == [:foo, :foo=, :bar, :bar=]
     end
   end
 
diff --git a/spec/ruby/core/module/attr_reader_spec.rb b/spec/ruby/core/module/attr_reader_spec.rb
index b0ae906ab5..0b6d996719 100644
--- a/spec/ruby/core/module/attr_reader_spec.rb
+++ b/spec/ruby/core/module/attr_reader_spec.rb
@@ -62,19 +62,9 @@ describe "Module#attr_reader" do
     Module.should have_public_instance_method(:attr_reader, false)
   end
 
-  ruby_version_is ""..."3.0" do
-    it "returns nil" do
-      Class.new do
-        (attr_reader :foo, 'bar').should == nil
-      end
-    end
-  end
-
-  ruby_version_is "3.0" do
-    it "returns an array of defined method names as symbols" do
-      Class.new do
-        (attr_reader :foo, 'bar').should == [:foo, :bar]
-      end
+  it "returns an array of defined method names as symbols" do
+    Class.new do
+      (attr_reader :foo, 'bar').should == [:foo, :bar]
     end
   end
 end
diff --git a/spec/ruby/core/module/attr_spec.rb b/spec/ruby/core/module/attr_spec.rb
index 33e0eb8628..72a6646b1e 100644
--- a/spec/ruby/core/module/attr_spec.rb
+++ b/spec/ruby/core/module/attr_spec.rb
@@ -146,23 +146,11 @@ describe "Module#attr" do
     Module.should have_public_instance_method(:attr, false)
   end
 
-  ruby_version_is ""..."3.0" do
-    it "returns nil" do
-      Class.new do
-        (attr :foo, 'bar').should == nil
-        (attr :baz, false).should == nil
-        (attr :qux, true).should == nil
-      end
-    end
-  end
-
-  ruby_version_is "3.0" do
-    it "returns an array of defined method names as symbols" do
-      Class.new do
-        (attr :foo, 'bar').should == [:foo, :bar]
-        (attr :baz, false).should == [:baz]
-        (attr :qux, true).should == [:qux, :qux=]
-      end
+  it "returns an array of defined method names as symbols" do
+    Class.new do
+      (attr :foo, 'bar').should == [:foo, :bar]
+      (attr :baz, false).should == [:baz]
+      (attr :qux, true).should == [:qux, :qux=]
     end
   end
 end
diff --git a/spec/ruby/core/module/attr_writer_spec.rb b/spec/ruby/core/module/attr_writer_spec.rb
index 0e9d201317..aaea0ce43f 100644
--- a/spec/ruby/core/module/attr_writer_spec.rb
+++ b/spec/ruby/core/module/attr_writer_spec.rb
@@ -72,19 +72,9 @@ describe "Module#attr_writer" do
     Module.should have_public_instance_method(:attr_writer, false)
   end
 
-  ruby_version_is ""..."3.0" do
-    it "returns nil" do
-      Class.new do
-        (attr_writer :foo, 'bar').should == nil
-      end
-    end
-  end
-
-  ruby_version_is "3.0" do
-    it "returns an array of defined method names as symbols" do
-      Class.new do
-        (attr_writer :foo, 'bar').should == [:foo=, :bar=]
-      end
+  it "returns an array of defined method names as symbols" do
+    Class.new do
+      (attr_writer :foo, 'bar').should == [:foo=, :bar=]
     end
   end
 end
diff --git a/spec/ruby/core/module/const_set_spec.rb b/spec/ruby/core/module/const_set_spec.rb
index ba7810d17b..5bdfd7b68f 100644
--- a/spec/ruby/core/module/const_set_spec.rb
+++ b/spec/ruby/core/module/const_set_spec.rb
@@ -20,20 +20,10 @@ describe "Module#const_set" do
     m.name.should == "ConstantSpecs::CS_CONST1000"
   end
 
-  ruby_version_is ""..."3.0" do
-    it "does not set the name of a module scoped by an anonymous module" do
-      a, b = Module.new, Module.new
-      a.const_set :B, b
-      b.name.should be_nil
-    end
-  end
-
-  ruby_version_is "3.0" do
-    it "sets the name of a module scoped by an anonymous module" do
-      a, b = Module.new, Module.new
-      a.const_set :B, b
-      b.name.should.end_with? '::B'
-    end
+  it "sets the name of a module scoped by an anonymous module" do
+    a, b = Module.new, Module.new
+    a.const_set :B, b
+    b.name.should.end_with? '::B'
   end
 
   it "sets the name of contained modules when assigning a toplevel anonymous module" do
diff --git a/spec/ruby/core/module/fixtures/module.rb b/spec/ruby/core/module/fixtures/module.rb
index 9050a272ec..34543ca2b4 100644
--- a/spec/ruby/core/module/fixtures/module.rb
+++ b/spec/ruby/core/module/fixtures/module.rb
@@ -1,4 +1,8 @@
 module ModuleSpecs
   module Anonymous
+    module Child
+    end
+
+    SameChild = Child
   end
 end
diff --git a/spec/ruby/core/module/name_spec.rb b/spec/ruby/core/module/name_spec.rb
index bbc1841239..bb7fa1761c 100644
--- a/spec/ruby/core/module/name_spec.rb
+++ b/spec/ruby/core/module/name_spec.rb
@@ -55,20 +55,10 @@ describe "Module#name" do
     end
   end
 
-  ruby_version_is ""..."3.0" do
-    it "is nil when assigned to a constant in an anonymous module" do
-      m = Module.new
-      m::N = Module.new
-      m::N.name.should be_nil
-    end
-  end
-
-  ruby_version_is "3.0" do
-    it "is not nil when assigned to a constant in an anonymous module" do
-      m = Module.new
-      m::N = Module.new
-      m::N.name.should.end_with? '::N'
-    end
+  it "is not nil when assigned to a constant in an anonymous module" do
+    m = Module.new
+    m::N = Module.new
+    m::N.name.should.end_with? '::N'
   end
 
   it "is not nil for a nested module created with the module keyword" do
@@ -91,6 +81,19 @@ describe "Module#name" do
     m::N.name.should == "ModuleSpecs::Anonymous::WasAnnon"
   end
 
+  it "may be the repeated in different module objects" do
+    m = Module.new
+    n = Module.new
+
+    suppress_warning do
+      ModuleSpecs::Anonymous::SameName = m
+      ModuleSpecs::Anonymous::SameName = n
+    end
+
+    m.name.should == "ModuleSpecs::Anonymous::SameName"
+    n.name.should == "ModuleSpecs::Anonymous::SameName"
+  end
+
   it "is set after it is removed from a constant" do
     module ModuleSpecs
       module ModuleToRemove
@@ -118,12 +121,18 @@ describe "Module#name" do
     ModuleSpecs::Anonymous.name.should == "ModuleSpecs::Anonymous"
   end
 
-  it "is set when assigning to a constant" do
+  it "is set when assigning to a constant (constant path matches outer module name)" do
     m = Module.new
     ModuleSpecs::Anonymous::A = m
     m.name.should == "ModuleSpecs::Anonymous::A"
   end
 
+  it "is set when assigning to a constant (constant path does not match outer module name)" do
+    m = Module.new
+    ModuleSpecs::Anonymous::SameChild::A = m
+    m.name.should == "ModuleSpecs::Anonymous::Child::A"
+  end
+
   it "is not modified when assigning to a new constant after it has been accessed" do
     m = Module.new
     ModuleSpecs::Anonymous::B = m
@@ -160,13 +169,26 @@ describe "Module#name" do
     ModuleSpecs::NameEncoding.new.name.encoding.should == Encoding::UTF_8
   end
 
-  it "is set when the anonymous outer module name is set" do
+  it "is set when the anonymous outer module name is set (module in one single constant)" do
     m = Module.new
     m::N = Module.new
     ModuleSpecs::Anonymous::E = m
     m::N.name.should == "ModuleSpecs::Anonymous::E::N"
   end
 
+  # https://bugs.ruby-lang.org/issues/19681
+  it "is set when the anonymous outer module name is set (module in several constants)" do
+    m = Module.new
+    m::N = Module.new
+    m::O = m::N
+    ModuleSpecs::Anonymous::StoredInMultiplePlaces = m
+    valid_names = [
+      "ModuleSpecs::Anonymous::StoredInMultiplePlaces::N",
+      "ModuleSpecs::Anonymous::StoredInMultiplePlaces::O"
+    ]
+    valid_names.should include(m::N.name) # You get one of the two, but you don't know which one.
+  end
+
   it "returns a frozen String" do
     ModuleSpecs.name.should.frozen?
   end
diff --git a/spec/ruby/core/module/prepend_spec.rb b/spec/ruby/core/module/prepend_spec.rb
index 976b09b105..96598e7209 100644
--- a/spec/ruby/core/module/prepend_spec.rb
+++ b/spec/ruby/core/module/prepend_spec.rb
@@ -499,34 +499,17 @@ describe "Module#prepend" do
     c.dup.new.should be_kind_of(m)
   end
 
-  ruby_version_is ''...'3.0' do
-    it "keeps the module in the chain when dupping an intermediate module" do
-      m1 = Module.new { def calc(x) x end }
-      m2 = Module.new { prepend(m1) }
-      c1 = Class.new { prepend(m2) }
-      m2dup = m2.dup
-      m2dup.ancestors.should == [m2dup,m1,m2]
-      c2 = Class.new { prepend(m2dup) }
-      c1.ancestors[0,3].should == [m1,m2,c1]
-      c1.new.should be_kind_of(m1)
-      c2.ancestors[0,4].should == [m2dup,m1,m2,c2]
-      c2.new.should be_kind_of(m1)
-    end
-  end
-
-  ruby_version_is '3.0' do
-    it "uses only new module when dupping the module" do
-      m1 = Module.new { def calc(x) x end }
-      m2 = Module.new { prepend(m1) }
-      c1 = Class.new { prepend(m2) }
-      m2dup = m2.dup
-      m2dup.ancestors.should == [m1,m2dup]
-      c2 = Class.new { prepend(m2dup) }
-      c1.ancestors[0,3].should == [m1,m2,c1]
-      c1.new.should be_kind_of(m1)
-      c2.ancestors[0,3].should == [m1,m2dup,c2]
-      c2.new.should be_kind_of(m1)
-    end
+  it "uses only new module when dupping the module" do
+    m1 = Module.new { def calc(x) x end }
+    m2 = Module.new { prepend(m1) }
+    c1 = Class.new { prepend(m2) }
+    m2dup = m2.dup
+    m2dup.ancestors.should == [m1,m2dup]
+    c2 = Class.new { prepend(m2dup) }
+    c1.ancestors[0,3].should == [m1,m2,c1]
+    c1.new.should be_kind_of(m1)
+    c2.ancestors[0,3].should == [m1,m2dup,c2]
+    c2.new.should be_kind_of(m1)
   end
 
   it "depends on prepend_features to add the module" do
diff --git a/spec/ruby/core/module/private_class_method_spec.rb b/spec/ruby/core/module/private_class_method_spec.rb
index 407779cccc..f899c71a57 100644
--- a/spec/ruby/core/module/private_class_method_spec.rb
+++ b/spec/ruby/core/module/private_class_method_spec.rb
@@ -79,15 +79,13 @@ describe "Module#private_class_method" do
     end.should raise_error(NameError)
   end
 
-  ruby_version_is "3.0" do
-    context "when single argument is passed and is an array" do
-      it "sets the visibility of the given methods to private" do
-        c = Class.new do
-          def self.foo() "foo" end
-          private_class_method [:foo]
-        end
-        -> { c.foo }.should raise_error(NoMethodError)
+  context "when single argument is passed and is an array" do
+    it "sets the visibility of the given methods to private" do
+      c = Class.new do
+        def self.foo() "foo" end
+        private_class_method [:foo]
       end
+      -> { c.foo }.should raise_error(NoMethodError)
     end
   end
 end
diff --git a/spec/ruby/core/module/public_class_method_spec.rb b/spec/ruby/core/module/public_class_method_spec.rb
index b5d76e7b7a..71b20acda5 100644
--- a/spec/ruby/core/module/public_class_method_spec.rb
+++ b/spec/ruby/core/module/public_class_method_spec.rb
@@ -78,19 +78,17 @@ describe "Module#public_class_method" do
     end.should raise_error(NameError)
   end
 
-  ruby_version_is "3.0" do
-    context "when single argument is passed and is an array" do
-      it "makes a class method public" do
-        c = Class.new do
-          class << self
-            private
-            def foo() "foo" end
-          end
-          public_class_method [:foo]
+  context "when single argument is passed and is an array" do
+    it "makes a class method public" do
+      c = Class.new do
+        class << self
+          private
+          def foo() "foo" end
         end
-
-        c.foo.should == "foo"
+        public_class_method [:foo]
       end
+
+      c.foo.should == "foo"
     end
   end
 end
diff --git a/spec/ruby/core/module/ruby2_keywords_spec.rb b/spec/ruby/core/module/ruby2_keywords_spec.rb
index 80a99e2624..dc16d712c7 100644
--- a/spec/ruby/core/module/ruby2_keywords_spec.rb
+++ b/spec/ruby/core/module/ruby2_keywords_spec.rb
@@ -22,9 +22,7 @@ describe "Module#ruby2_keywords" do
     end
 
     h = {a: 1}
-    ruby_version_is "3.0" do
-      obj.regular(**h).should.equal?(h)
-    end
+    obj.regular(**h).should.equal?(h)
 
     last = mark(**h).last
     Hash.ruby2_keywords_hash?(last).should == true
@@ -223,25 +221,6 @@ describe "Module#ruby2_keywords" do
     Hash.ruby2_keywords_hash?(last).should == true
   end
 
-  ruby_version_is ""..."3.0" do
-    it "fixes delegation warnings when calling a method accepting keywords" do
-      obj = Object.new
-
-      obj.singleton_class.class_exec do
-        def foo(*a) bar(*a) end
-        def bar(*a, **b) end
-      end
-
-      -> { obj.foo(1, 2, {a: "a"}) }.should complain(/Using the last argument as keyword parameters is deprecated/)
-
-      obj.singleton_class.class_exec do
-        ruby2_keywords :foo
-      end
-
-      -> { obj.foo(1, 2, {a: "a"}) }.should_not complain
-    end
-  end
-
   it "returns nil" do
     obj = Object.new
 
diff --git a/spec/ruby/core/module/shared/set_visibility.rb b/spec/ruby/core/module/shared/set_visibility.rb
index 9f31e230ca..a1586dd2bd 100644
--- a/spec/ruby/core/module/shared/set_visibility.rb
+++ b/spec/ruby/core/module/shared/set_visibility.rb
@@ -22,21 +22,19 @@ describe :set_visibility, shared: true do
       end
     end
 
-    ruby_version_is "3.0" do
-      describe "array as a single argument" do
-        it "sets visibility of given method names" do
-          visibility = @method
-          old_visibility = [:protected, :private].find {|vis| vis != visibility }
-
-          mod = Module.new {
-            send old_visibility
-            def test1() end
-            def test2() end
-            send visibility, [:test1, :test2]
-          }
-          mod.should send(:"have_#{visibility}_instance_method", :test1, false)
-          mod.should send(:"have_#{visibility}_instance_method", :test2, false)
-        end
+    describe "array as a single argument" do
+      it "sets visibility of given method names" do
+        visibility = @method
+        old_visibility = [:protected, :private].find {|vis| vis != visibility }
+
+        mod = Module.new {
+          send old_visibility
+          def test1() end
+          def test2() end
+          send visibility, [:test1, :test2]
+        }
+        mod.should send(:"have_#{visibility}_instance_method", :test1, false)
+        mod.should send(:"have_#{visibility}_instance_method", :test2, false)
       end
     end
 
diff --git a/spec/ruby/core/mutex/owned_spec.rb b/spec/ruby/core/mutex/owned_spec.rb
index 1f843cd576..7bfc7d8f83 100644
--- a/spec/ruby/core/mutex/owned_spec.rb
+++ b/spec/ruby/core/mutex/owned_spec.rb
@@ -41,15 +41,13 @@ describe "Mutex#owned?" do
     end
   end
 
-  ruby_version_is "3.0" do
-    it "is held per Fiber" do
-      m = Mutex.new
-      m.lock
-
-      Fiber.new do
-        m.locked?.should == true
-        m.owned?.should == false
-      end.resume
-    end
+  it "is held per Fiber" do
+    m = Mutex.new
+    m.lock
+
+    Fiber.new do
+      m.locked?.should == true
+      m.owned?.should == false
+    end.resume
   end
 end
diff --git a/spec/ruby/core/numeric/clone_spec.rb b/spec/ruby/core/numeric/clone_spec.rb
index c3b06ca0c9..5834b17089 100644
--- a/spec/ruby/core/numeric/clone_spec.rb
+++ b/spec/ruby/core/numeric/clone_spec.rb
@@ -23,10 +23,8 @@ describe "Numeric#clone" do
     -> { 1.clone(freeze: false) }.should raise_error(ArgumentError, /can't unfreeze/)
   end
 
-  ruby_version_is "3.0" do
-    it "does not change frozen status if passed freeze: nil" do
-      value = 1
-      value.clone(freeze: nil).should equal(value)
-    end
+  it "does not change frozen status if passed freeze: nil" do
+    value = 1
+    value.clone(freeze: nil).should equal(value)
   end
 end
diff --git a/spec/ruby/core/numeric/fdiv_spec.rb b/spec/ruby/core/numeric/fdiv_spec.rb
index 907e5d343c..e97fa77f79 100644
--- a/spec/ruby/core/numeric/fdiv_spec.rb
+++ b/spec/ruby/core/numeric/fdiv_spec.rb
@@ -1,5 +1,4 @@
 require_relative '../../spec_helper'
-require_relative 'shared/quo'
 
 describe "Numeric#fdiv" do
   it "coerces self with #to_f" do
diff --git a/spec/ruby/core/numeric/quo_spec.rb b/spec/ruby/core/numeric/quo_spec.rb
index 67bacee9b5..6e3ce7a374 100644
--- a/spec/ruby/core/numeric/quo_spec.rb
+++ b/spec/ruby/core/numeric/quo_spec.rb
@@ -1,6 +1,5 @@
 require_relative '../../spec_helper'
 require_relative 'fixtures/classes'
-require_relative 'shared/quo'
 
 describe "Numeric#quo" do
   it "returns the result of self divided by the given Integer as a Rational" do
diff --git a/spec/ruby/core/numeric/shared/quo.rb b/spec/ruby/core/numeric/shared/quo.rb
deleted file mode 100644
index 2392636fe7..0000000000
--- a/spec/ruby/core/numeric/shared/quo.rb
+++ /dev/null
@@ -1,7 +0,0 @@
-describe :numeric_quo_18, shared: true do
-  it "returns the result of calling self#/ with other" do
-    obj = mock_numeric('numeric')
-    obj.should_receive(:/).with(19).and_return(:result)
-    obj.send(@method, 19).should == :result
-  end
-end
diff --git a/spec/ruby/core/numeric/shared/step.rb b/spec/ruby/core/numeric/shared/step.rb
index 8b1a7bf307..977ec6de02 100644
--- a/spec/ruby/core/numeric/shared/step.rb
+++ b/spec/ruby/core/numeric/shared/step.rb
@@ -5,7 +5,7 @@ require_relative '../fixtures/classes'
 # To be able to do it, the @step ivar must contain a Proc that transforms
 # the step call arguments passed as positional arguments to the style of
 # arguments pretended to test.
-describe :numeric_step, :shared => true do
+describe :numeric_step, shared: true do
   before :each do
     ScratchPad.record []
     @prc = -> x { ScratchPad << x }
@@ -258,12 +258,6 @@ describe :numeric_step, :shared => true do
   describe "when no block is given" do
     step_enum_class = Enumerator::ArithmeticSequence
 
-    ruby_version_is ""..."3.0" do
-      it "returns an #{step_enum_class} when step is 0" do
-        @step.call(1, 2, 0).should be_an_instance_of(step_enum_class)
-      end
-    end
-
     it "returns an #{step_enum_class} when not passed a block and self > stop" do
       @step.call(1, 0, 2).should be_an_instance_of(step_enum_class)
     end
diff --git a/spec/ruby/core/numeric/step_spec.rb b/spec/ruby/core/numeric/step_spec.rb
index 095c474fec..1705fb1b4e 100644
--- a/spec/ruby/core/numeric/step_spec.rb
+++ b/spec/ruby/core/numeric/step_spec.rb
@@ -23,30 +23,8 @@ describe "Numeric#step" do
     describe "when no block is given" do
       step_enum_class = Enumerator::ArithmeticSequence
 
-      ruby_version_is ""..."3.0" do
-        it "returns an #{step_enum_class} when step is 0" do
-          1.step(5, 0).should be_an_instance_of(step_enum_class)
-        end
-
-        it "returns an #{step_enum_class} when step is 0.0" do
-          1.step(2, 0.0).should be_an_instance_of(step_enum_class)
-        end
-      end
-
       describe "returned #{step_enum_class}" do
         describe "size" do
-          ruby_version_is ""..."3.0" do
-            it "is infinity when step is 0" do
-              enum = 1.step(5, 0)
-              enum.size.should == Float::INFINITY
-            end
-
-            it "is infinity when step is 0.0" do
-              enum = 1.step(2, 0.0)
-              enum.size.should == Float::INFINITY
-            end
-          end
-
           it "defaults to an infinite size" do
             enum = 1.step
             enum.size.should == Float::INFINITY
@@ -63,22 +41,6 @@ describe "Numeric#step" do
   end
 
   describe 'with keyword arguments' do
-    ruby_version_is ""..."3.0" do
-      it "doesn't raise an error when step is 0" do
-        -> { 1.step(to: 5, by: 0) { break } }.should_not raise_error
-      end
-
-      it "doesn't raise an error when step is 0.0" do
-        -> { 1.step(to: 2, by: 0.0) { break } }.should_not raise_error
-      end
-
-      it "should loop over self when step is 0 or 0.0" do
-        1.step(to: 2, by: 0.0).take(5).should eql [1.0, 1.0, 1.0, 1.0, 1.0]
-        1.step(to: 2, by: 0).take(5).should eql [1, 1, 1, 1, 1]
-        1.1.step(to: 2, by: 0).take(5).should eql [1.1, 1.1, 1.1, 1.1, 1.1]
-      end
-    end
-
     describe "when no block is given" do
       describe "returned Enumerator" do
         describe "size" do
@@ -86,16 +48,6 @@ describe "Numeric#step" do
             1.step(by: 42).size.should == infinity_value
           end
 
-          ruby_version_is ""..."3.0" do
-            it "should return infinity_value when step is 0" do
-              1.step(to: 5, by: 0).size.should == infinity_value
-            end
-
-            it "should return infinity_value when step is 0.0" do
-              1.step(to: 2, by: 0.0).size.should == infinity_value
-            end
-          end
-
           it "should return infinity_value when ascending towards a limit of Float::INFINITY" do
             1.step(to: Float::INFINITY, by: 42).size.should == infinity_value
           end
@@ -128,24 +80,12 @@ describe "Numeric#step" do
   end
 
   describe 'with mixed arguments' do
-    ruby_version_is ""..."3.0" do
-      it "doesn't raise an error when step is 0" do
-        -> { 1.step(5, by: 0) { break } }.should_not raise_error
-      end
-
-      it "doesn't raise an error when step is 0.0" do
-        -> { 1.step(2, by: 0.0) { break } }.should_not raise_error
-      end
+    it " raises an ArgumentError when step is 0" do
+      -> { 1.step(5, by: 0) { break } }.should raise_error(ArgumentError)
     end
 
-    ruby_version_is "3.0" do
-      it " raises an ArgumentError when step is 0" do
-        -> { 1.step(5, by: 0) { break } }.should raise_error(ArgumentError)
-      end
-
-      it "raises an ArgumentError when step is 0.0" do
-        -> { 1.step(2, by: 0.0) { break } }.should raise_error(ArgumentError)
-      end
+    it "raises an ArgumentError when step is 0.0" do
+      -> { 1.step(2, by: 0.0) { break } }.should raise_error(ArgumentError)
     end
 
     it "raises a ArgumentError when limit and to are defined" do
@@ -156,26 +96,9 @@ describe "Numeric#step" do
       -> { 1.step(5, 1, by: 5) { break } }.should raise_error(ArgumentError)
     end
 
-    ruby_version_is ""..."3.0" do
-      it "should loop over self when step is 0 or 0.0" do
-        1.step(2, by: 0.0).take(5).should eql [1.0, 1.0, 1.0, 1.0, 1.0]
-        1.step(2, by: 0).take(5).should eql [1, 1, 1, 1, 1]
-        1.1.step(2, by: 0).take(5).should eql [1.1, 1.1, 1.1, 1.1, 1.1]
-      end
-    end
-
     describe "when no block is given" do
       describe "returned Enumerator" do
         describe "size" do
-          ruby_version_is ""..."3.0" do
-            it "should return infinity_value when step is 0" do
-              1.step(5, by: 0).size.should == infinity_value
-            end
-
-            it "should return infinity_value when step is 0.0" do
-              1.step(2, by: 0.0).size.should == infinity_value
-            end
-          end
         end
       end
     end
diff --git a/spec/ruby/core/objectspace/define_finalizer_spec.rb b/spec/ruby/core/objectspace/define_finalizer_spec.rb
index d9db027e0b..6be83e518e 100644
--- a/spec/ruby/core/objectspace/define_finalizer_spec.rb
+++ b/spec/ruby/core/objectspace/define_finalizer_spec.rb
@@ -60,55 +60,53 @@ describe "ObjectSpace.define_finalizer" do
     ruby_exe(code, :args => "2>&1").should include("finalizer run\n")
   end
 
-  ruby_version_is "3.0" do
-    it "warns if the finalizer has the object as the receiver" do
-      code = <<-RUBY
-        class CapturesSelf
-          def initialize
-            ObjectSpace.define_finalizer(self, proc {
-              puts "finalizer run"
-            })
-          end
+  it "warns if the finalizer has the object as the receiver" do
+    code = <<-RUBY
+      class CapturesSelf
+        def initialize
+          ObjectSpace.define_finalizer(self, proc {
+            puts "finalizer run"
+          })
         end
-        CapturesSelf.new
-        exit 0
-      RUBY
+      end
+      CapturesSelf.new
+      exit 0
+    RUBY
 
-      ruby_exe(code, :args => "2>&1").should include("warning: finalizer references object to be finalized\n")
-    end
+    ruby_exe(code, :args => "2>&1").should include("warning: finalizer references object to be finalized\n")
+  end
 
-    it "warns if the finalizer is a method bound to the receiver" do
-      code = <<-RUBY
-        class CapturesSelf
-          def initialize
-            ObjectSpace.define_finalizer(self, method(:finalize))
-          end
-          def finalize(id)
-            puts "finalizer run"
-          end
+  it "warns if the finalizer is a method bound to the receiver" do
+    code = <<-RUBY
+      class CapturesSelf
+        def initialize
+          ObjectSpace.define_finalizer(self, method(:finalize))
         end
-        CapturesSelf.new
-        exit 0
-      RUBY
+        def finalize(id)
+          puts "finalizer run"
+        end
+      end
+      CapturesSelf.new
+      exit 0
+    RUBY
 
-      ruby_exe(code, :args => "2>&1").should include("warning: finalizer references object to be finalized\n")
-    end
+    ruby_exe(code, :args => "2>&1").should include("warning: finalizer references object to be finalized\n")
+  end
 
-    it "warns if the finalizer was a block in the receiver" do
-      code = <<-RUBY
-        class CapturesSelf
-          def initialize
-            ObjectSpace.define_finalizer(self) do
-              puts "finalizer run"
-            end
+  it "warns if the finalizer was a block in the receiver" do
+    code = <<-RUBY
+      class CapturesSelf
+        def initialize
+          ObjectSpace.define_finalizer(self) do
+            puts "finalizer run"
           end
         end
-        CapturesSelf.new
-        exit 0
-      RUBY
+      end
+      CapturesSelf.new
+      exit 0
+    RUBY
 
-      ruby_exe(code, :args => "2>&1").should include("warning: finalizer references object to be finalized\n")
-    end
+    ruby_exe(code, :args => "2>&1").should include("warning: finalizer references object to be finalized\n")
   end
 
   it "calls a finalizer at exit even if it is self-referencing" do
diff --git a/spec/ruby/core/proc/compose_spec.rb b/spec/ruby/core/proc/compose_spec.rb
index 94814d11bc..9e9b57e06f 100644
--- a/spec/ruby/core/proc/compose_spec.rb
+++ b/spec/ruby/core/proc/compose_spec.rb
@@ -37,42 +37,22 @@ describe "Proc#<<" do
       (f << g).should_not.lambda?
     end
 
-    ruby_version_is(''...'3.0') do
-      it "is a Proc when other is lambda" do
-        f = proc { |x| x * x }
-        g = -> x { x + x }
-
-        (f << g).is_a?(Proc).should == true
-        (f << g).should_not.lambda?
-      end
-
-      it "is a lambda when self is lambda" do
-        f = -> x { x * x }
-        g = proc { |x| x + x }
-
-        (f << g).is_a?(Proc).should == true
-        (f << g).should.lambda?
-      end
-    end
-
-    ruby_version_is('3.0') do
-      it "is a lambda when parameter is lambda" do
-        f = -> x { x * x }
-        g = proc { |x| x + x }
-        lambda_proc = -> x { x }
+    it "is a lambda when parameter is lambda" do
+      f = -> x { x * x }
+      g = proc { |x| x + x }
+      lambda_proc = -> x { x }
 
-        # lambda << proc
-        (f << g).is_a?(Proc).should == true
-        (f << g).should_not.lambda?
+      # lambda << proc
+      (f << g).is_a?(Proc).should == true
+      (f << g).should_not.lambda?
 
-        # lambda << lambda
-        (f << lambda_proc).is_a?(Proc).should == true
-        (f << lambda_proc).should.lambda?
+      # lambda << lambda
+      (f << lambda_proc).is_a?(Proc).should == true
+      (f << lambda_proc).should.lambda?
 
-        # proc << lambda
-        (g << f).is_a?(Proc).should == true
-        (g << f).should.lambda?
-      end
+      # proc << lambda
+      (g << f).is_a?(Proc).should == true
+      (g << f).should.lambda?
     end
 
     it "may accept multiple arguments" do
diff --git a/spec/ruby/core/proc/eql_spec.rb b/spec/ruby/core/proc/eql_spec.rb
index 06aee272e5..ad8f6749fc 100644
--- a/spec/ruby/core/proc/eql_spec.rb
+++ b/spec/ruby/core/proc/eql_spec.rb
@@ -2,11 +2,5 @@ require_relative '../../spec_helper'
 require_relative 'shared/equal'
 
 describe "Proc#eql?" do
-  ruby_version_is ""..."3.0" do
-    it_behaves_like :proc_equal_undefined, :eql?
-  end
-
-  ruby_version_is "3.0" do
-    it_behaves_like :proc_equal, :eql?
-  end
+  it_behaves_like :proc_equal, :eql?
 end
diff --git a/spec/ruby/core/proc/equal_value_spec.rb b/spec/ruby/core/proc/equal_value_spec.rb
index ee88c0537d..ec7f274732 100644
--- a/spec/ruby/core/proc/equal_value_spec.rb
+++ b/spec/ruby/core/proc/equal_value_spec.rb
@@ -2,11 +2,5 @@ require_relative '../../spec_helper'
 require_relative 'shared/equal'
 
 describe "Proc#==" do
-  ruby_version_is ""..."3.0" do
-    it_behaves_like :proc_equal_undefined, :==
-  end
-
-  ruby_version_is "3.0" do
-    it_behaves_like :proc_equal, :==
-  end
+  it_behaves_like :proc_equal, :==
 end
diff --git a/spec/ruby/core/proc/new_spec.rb b/spec/ruby/core/proc/new_spec.rb
index cb52e94f44..b2b7387756 100644
--- a/spec/ruby/core/proc/new_spec.rb
+++ b/spec/ruby/core/proc/new_spec.rb
@@ -166,36 +166,13 @@ describe "Proc.new without a block" do
     -> { ProcSpecs.new_proc_subclass_in_method }.should raise_error(ArgumentError)
   end
 
-  ruby_version_is ""..."3.0" do
-    it "can be created if invoked from within a method with a block" do
-      -> { ProcSpecs.new_proc_in_method { "hello" } }.should complain(/Capturing the given block using Proc.new is deprecated/)
-    end
-
-    it "can be created if invoked on a subclass from within a method with a block" do
-      -> { ProcSpecs.new_proc_subclass_in_method { "hello" } }.should complain(/Capturing the given block using Proc.new is deprecated/)
-    end
-
-
-    it "can be create when called with no block" do
-      def some_method
-        Proc.new
-      end
-
-      -> {
-        some_method { "hello" }
-      }.should complain(/Capturing the given block using Proc.new is deprecated/)
+  it "raises an ArgumentError when passed no block" do
+    def some_method
+      Proc.new
     end
-  end
 
-  ruby_version_is "3.0" do
-    it "raises an ArgumentError when passed no block" do
-      def some_method
-        Proc.new
-      end
-
-      -> { ProcSpecs.new_proc_in_method { "hello" } }.should raise_error(ArgumentError, 'tried to create Proc object without a block')
-      -> { ProcSpecs.new_proc_subclass_in_method { "hello" } }.should raise_error(ArgumentError, 'tried to create Proc object without a block')
-      -> { some_method { "hello" } }.should raise_error(ArgumentError, 'tried to create Proc object without a block')
-    end
+    -> { ProcSpecs.new_proc_in_method { "hello" } }.should raise_error(ArgumentError, 'tried to create Proc object without a block')
+    -> { ProcSpecs.new_proc_subclass_in_method { "hello" } }.should raise_error(ArgumentError, 'tried to create Proc object without a block')
+    -> { some_method { "hello" } }.should raise_error(ArgumentError, 'tried to create Proc object without a block')
   end
 end
diff --git a/spec/ruby/core/proc/ruby2_keywords_spec.rb b/spec/ruby/core/proc/ruby2_keywords_spec.rb
index c6eb03e693..ab67302231 100644
--- a/spec/ruby/core/proc/ruby2_keywords_spec.rb
+++ b/spec/ruby/core/proc/ruby2_keywords_spec.rb
@@ -25,28 +25,6 @@ describe "Proc#ruby2_keywords" do
     Hash.ruby2_keywords_hash?(f4.call(1, 2, a: "a")).should == true
   end
 
-  ruby_version_is ""..."3.0" do
-    it "fixes delegation warnings when calling a method accepting keywords" do
-      obj = Object.new
-      def obj.foo(*a, **b) end
-
-      f = -> *a { obj.foo(*a) }
-
-      -> { f.call(1, 2, {a: "a"}) }.should complain(/Using the last argument as keyword parameters is deprecated/)
-      f.ruby2_keywords
-      -> { f.call(1, 2, {a: "a"}) }.should_not complain
-    end
-
-    it "fixes delegation warnings when calling a proc accepting keywords" do
-      g = -> *a, **b { }
-      f = -> *a { g.call(*a) }
-
-      -> { f.call(1, 2, {a: "a"}) }.should complain(/Using the last argument as keyword parameters is deprecated/)
-      f.ruby2_keywords
-      -> { f.call(1, 2, {a: "a"}) }.should_not complain
-    end
-  end
-
   it "returns self" do
     f = -> *a { }
     f.ruby2_keywords.should equal f
diff --git a/spec/ruby/core/proc/shared/equal.rb b/spec/ruby/core/proc/shared/equal.rb
index 0c0020ca7f..d0503fb064 100644
--- a/spec/ruby/core/proc/shared/equal.rb
+++ b/spec/ruby/core/proc/shared/equal.rb
@@ -81,20 +81,3 @@ describe :proc_equal, shared: true do
     p.send(@method, p2).should be_false
   end
 end
-
-describe :proc_equal_undefined, shared: true do
-  it "is not defined" do
-    Proc.should_not have_instance_method(@method, false)
-  end
-
-  it "returns false if other is a dup of the original" do
-    p = proc { :foo }
-    p.send(@method, p.dup).should be_false
-
-    p = Proc.new { :foo }
-    p.send(@method, p.dup).should be_false
-
-    p = -> { :foo }
-    p.send(@method, p.dup).should be_false
-  end
-end
diff --git a/spec/ruby/core/process/detach_spec.rb b/spec/ruby/core/process/detach_spec.rb
index 91661afcea..f13bda1f5d 100644
--- a/spec/ruby/core/process/detach_spec.rb
+++ b/spec/ruby/core/process/detach_spec.rb
@@ -44,11 +44,17 @@ describe "Process.detach" do
     end
 
     it "tolerates not existing child process pid" do
-      # ensure there is no child process with this hardcoded pid
-      # `kill 0 pid` for existing process returns "1" and raises Errno::ESRCH if process doesn't exist
-      -> {  Process.kill(0, 100500) }.should raise_error(Errno::ESRCH)
+      # Use a value that is close to the INT_MAX (pid usually is signed int).
+      # It should (at least) be greater than allowed pid limit value that depends on OS.
+      pid_not_existing = 2.pow(30)
 
-      thr = Process.detach(100500)
+      # Check that there is no a child process with this hardcoded pid.
+      # Command `kill 0 pid`:
+      # - returns "1" if a process exists and
+      # - raises Errno::ESRCH otherwise
+      -> {  Process.kill(0, pid_not_existing) }.should raise_error(Errno::ESRCH)
+
+      thr = Process.detach(pid_not_existing)
       thr.join
 
       thr.should be_kind_of(Thread)
diff --git a/spec/ruby/core/process/status/wait_spec.rb b/spec/ruby/core/process/status/wait_spec.rb
index ee9ea80ebb..57d56209a9 100644
--- a/spec/ruby/core/process/status/wait_spec.rb
+++ b/spec/ruby/core/process/status/wait_spec.rb
@@ -1,102 +1,100 @@
 require_relative '../../../spec_helper'
 require_relative '../fixtures/common'
 
-ruby_version_is "3.0" do
-  describe "Process::Status.wait" do
-    ProcessSpecs.use_system_ruby(self)
-
-    before :all do
-      begin
-        leaked = Process.waitall
-        # Ruby-space should not see PIDs used by rjit
-        raise "subprocesses leaked before wait specs: #{leaked}" unless leaked.empty?
-      rescue NotImplementedError
-      end
+describe "Process::Status.wait" do
+  ProcessSpecs.use_system_ruby(self)
+
+  before :all do
+    begin
+      leaked = Process.waitall
+      # Ruby-space should not see PIDs used by rjit
+      raise "subprocesses leaked before wait specs: #{leaked}" unless leaked.empty?
+    rescue NotImplementedError
     end
+  end
+
+  it "returns a status with pid -1 if there are no child processes" do
+    Process::Status.wait.pid.should == -1
+  end
 
-    it "returns a status with pid -1 if there are no child processes" do
-      Process::Status.wait.pid.should == -1
+  platform_is_not :windows do
+    it "returns a status with its child pid" do
+      pid = Process.spawn(ruby_cmd('exit'))
+      status = Process::Status.wait
+      status.should be_an_instance_of(Process::Status)
+      status.pid.should == pid
     end
 
-    platform_is_not :windows do
-      it "returns a status with its child pid" do
-        pid = Process.spawn(ruby_cmd('exit'))
-        status = Process::Status.wait
-        status.should be_an_instance_of(Process::Status)
-        status.pid.should == pid
-      end
+    it "should not set $? to the Process::Status" do
+      pid = Process.spawn(ruby_cmd('exit'))
+      status = Process::Status.wait
+      $?.should_not equal(status)
+    end
 
-      it "should not set $? to the Process::Status" do
-        pid = Process.spawn(ruby_cmd('exit'))
-        status = Process::Status.wait
-        $?.should_not equal(status)
-      end
+    it "should not change the value of $?" do
+      pid = Process.spawn(ruby_cmd('exit'))
+      Process.wait
+      status = $?
+      Process::Status.wait
+      status.should equal($?)
+    end
 
-      it "should not change the value of $?" do
-        pid = Process.spawn(ruby_cmd('exit'))
-        Process.wait
-        status = $?
-        Process::Status.wait
-        status.should equal($?)
-      end
+    it "waits for any child process if no pid is given" do
+      pid = Process.spawn(ruby_cmd('exit'))
+      Process::Status.wait.pid.should == pid
+      -> { Process.kill(0, pid) }.should raise_error(Errno::ESRCH)
+    end
 
-      it "waits for any child process if no pid is given" do
-        pid = Process.spawn(ruby_cmd('exit'))
-        Process::Status.wait.pid.should == pid
-        -> { Process.kill(0, pid) }.should raise_error(Errno::ESRCH)
-      end
+    it "waits for a specific child if a pid is given" do
+      pid1 = Process.spawn(ruby_cmd('exit'))
+      pid2 = Process.spawn(ruby_cmd('exit'))
+      Process::Status.wait(pid2).pid.should == pid2
+      Process::Status.wait(pid1).pid.should == pid1
+      -> { Process.kill(0, pid1) }.should raise_error(Errno::ESRCH)
+      -> { Process.kill(0, pid2) }.should raise_error(Errno::ESRCH)
+    end
 
-      it "waits for a specific child if a pid is given" do
-        pid1 = Process.spawn(ruby_cmd('exit'))
-        pid2 = Process.spawn(ruby_cmd('exit'))
-        Process::Status.wait(pid2).pid.should == pid2
-        Process::Status.wait(pid1).pid.should == pid1
-        -> { Process.kill(0, pid1) }.should raise_error(Errno::ESRCH)
-        -> { Process.kill(0, pid2) }.should raise_error(Errno::ESRCH)
-      end
+    it "coerces the pid to an Integer" do
+      pid1 = Process.spawn(ruby_cmd('exit'))
+      Process::Status.wait(mock_int(pid1)).pid.should == pid1
+      -> { Process.kill(0, pid1) }.should raise_error(Errno::ESRCH)
+    end
 
-      it "coerces the pid to an Integer" do
-        pid1 = Process.spawn(ruby_cmd('exit'))
-        Process::Status.wait(mock_int(pid1)).pid.should == pid1
-        -> { Process.kill(0, pid1) }.should raise_error(Errno::ESRCH)
-      end
+    # This spec is probably system-dependent.
+    it "waits for a child whose process group ID is that of the calling process" do
+      pid1 = Process.spawn(ruby_cmd('exit'), pgroup: true)
+      pid2 = Process.spawn(ruby_cmd('exit'))
 
-      # This spec is probably system-dependent.
-      it "waits for a child whose process group ID is that of the calling process" do
-        pid1 = Process.spawn(ruby_cmd('exit'), pgroup: true)
-        pid2 = Process.spawn(ruby_cmd('exit'))
+      Process::Status.wait(0).pid.should == pid2
+      Process::Status.wait.pid.should == pid1
+    end
 
-        Process::Status.wait(0).pid.should == pid2
-        Process::Status.wait.pid.should == pid1
+    # This spec is probably system-dependent.
+    it "doesn't block if no child is available when WNOHANG is used" do
+      read, write = IO.pipe
+      pid = Process.fork do
+        read.close
+        Signal.trap("TERM") { Process.exit! }
+        write << 1
+        write.close
+        sleep
       end
 
-      # This spec is probably system-dependent.
-      it "doesn't block if no child is available when WNOHANG is used" do
-        read, write = IO.pipe
-        pid = Process.fork do
-          read.close
-          Signal.trap("TERM") { Process.exit! }
-          write << 1
-          write.close
-          sleep
-        end
+      Process::Status.wait(pid, Process::WNOHANG).should be_nil
 
-        Process::Status.wait(pid, Process::WNOHANG).should be_nil
+      # wait for the child to setup its TERM handler
+      write.close
+      read.read(1)
+      read.close
 
-        # wait for the child to setup its TERM handler
-        write.close
-        read.read(1)
-        read.close
-
-        Process.kill("TERM", pid)
-        Process::Status.wait.pid.should == pid
-      end
+      Process.kill("TERM", pid)
+      Process::Status.wait.pid.should == pid
+    end
 
-      it "always accepts flags=0" do
-        pid = Process.spawn(ruby_cmd('exit'))
-        Process::Status.wait(-1, 0).pid.should == pid
-        -> { Process.kill(0, pid) }.should raise_error(Errno::ESRCH)
-      end
+    it "always accepts flags=0" do
+      pid = Process.spawn(ruby_cmd('exit'))
+      Process::Status.wait(-1, 0).pid.should == pid
+      -> { Process.kill(0, pid) }.should raise_error(Errno::ESRCH)
     end
   end
 end
diff --git a/spec/ruby/core/queue/deq_spec.rb b/spec/ruby/core/queue/deq_spec.rb
index 9510978eac..f84d4220ea 100644
--- a/spec/ruby/core/queue/deq_spec.rb
+++ b/spec/ruby/core/queue/deq_spec.rb
@@ -1,6 +1,13 @@
 require_relative '../../spec_helper'
 require_relative '../../shared/queue/deque'
+require_relative '../../shared/types/rb_num2dbl_fails'
 
 describe "Queue#deq" do
   it_behaves_like :queue_deq, :deq, -> { Queue.new }
 end
+
+describe "Queue operations with timeout" do
+  ruby_version_is "3.2" do
+    it_behaves_like :rb_num2dbl_fails, nil, -> v { q = Queue.new; q.push(1); q.deq(timeout: v) }
+  end
+end
diff --git a/spec/ruby/core/queue/pop_spec.rb b/spec/ruby/core/queue/pop_spec.rb
index 1ce9231685..d344740834 100644
--- a/spec/ruby/core/queue/pop_spec.rb
+++ b/spec/ruby/core/queue/pop_spec.rb
@@ -1,6 +1,13 @@
 require_relative '../../spec_helper'
 require_relative '../../shared/queue/deque'
+require_relative '../../shared/types/rb_num2dbl_fails'
 
 describe "Queue#pop" do
   it_behaves_like :queue_deq, :pop, -> { Queue.new }
 end
+
+describe "Queue operations with timeout" do
+  ruby_version_is "3.2" do
+    it_behaves_like :rb_num2dbl_fails, nil, -> v { q = Queue.new; q.push(1); q.pop(timeout: v) }
+  end
+end
diff --git a/spec/ruby/core/queue/shift_spec.rb b/spec/ruby/core/queue/shift_spec.rb
index f84058e1df..64165e0b61 100644
--- a/spec/ruby/core/queue/shift_spec.rb
+++ b/spec/ruby/core/queue/shift_spec.rb
@@ -1,6 +1,13 @@
 require_relative '../../spec_helper'
 require_relative '../../shared/queue/deque'
+require_relative '../../shared/types/rb_num2dbl_fails'
 
 describe "Queue#shift" do
   it_behaves_like :queue_deq, :shift, -> { Queue.new }
 end
+
+describe "Queue operations with timeout" do
+  ruby_version_is "3.2" do
+    it_behaves_like :rb_num2dbl_fails, nil, -> v { q = Queue.new; q.push(1); q.shift(timeout: v) }
+  end
+end
diff --git a/spec/ruby/core/random/default_spec.rb b/spec/ruby/core/random/default_spec.rb
index b4ffcb81f4..01d7430df8 100644
--- a/spec/ruby/core/random/default_spec.rb
+++ b/spec/ruby/core/random/default_spec.rb
@@ -14,26 +14,16 @@ describe "Random::DEFAULT" do
       seed1.should != seed2
     end
 
-    ruby_version_is ''...'3.0' do
-      it "returns a Random instance" do
-        suppress_warning do
-          Random::DEFAULT.should be_an_instance_of(Random)
-        end
+    it "refers to the Random class" do
+      suppress_warning do
+        Random::DEFAULT.should.equal?(Random)
       end
     end
 
-    ruby_version_is '3.0' do
-      it "refers to the Random class" do
-        suppress_warning do
-          Random::DEFAULT.should.equal?(Random)
-        end
-      end
-
-      it "is deprecated" do
-        -> {
-          Random::DEFAULT.should.equal?(Random)
-        }.should complain(/constant Random::DEFAULT is deprecated/)
-      end
+    it "is deprecated" do
+      -> {
+        Random::DEFAULT.should.equal?(Random)
+      }.should complain(/constant Random::DEFAULT is deprecated/)
     end
   end
 
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/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/max_spec.rb b/spec/ruby/core/range/max_spec.rb
index 6c9ada2a3c..a3bbc31e7d 100644
--- a/spec/ruby/core/range/max_spec.rb
+++ b/spec/ruby/core/range/max_spec.rb
@@ -50,17 +50,15 @@ 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
-      -> {
-        (...1).max
-      }.should raise_error(TypeError, 'cannot exclude end value with non Integer begin value')
-    end
+  it "raises for an exclusive beginless range" do
+    -> {
+      (...1).max
+    }.should raise_error(TypeError, 'cannot exclude end value with non Integer begin value')
   end
 end
 
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/step_spec.rb b/spec/ruby/core/range/step_spec.rb
index 9024636d55..64ea3de4ed 100644
--- a/spec/ruby/core/range/step_spec.rb
+++ b/spec/ruby/core/range/step_spec.rb
@@ -377,48 +377,21 @@ describe "Range#step" do
   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
+        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
 
-        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")
-            -> { (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")
-            -> { (1..2).step(obj) }.should raise_error(TypeError)
-          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
-          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")
+          -> { (1..2).step(obj) }.should raise_error(TypeError)
         end
 
         it "returns the ceil of range size divided by the number of steps" do
diff --git a/spec/ruby/core/regexp/initialize_spec.rb b/spec/ruby/core/regexp/initialize_spec.rb
index a1583384af..dd57292242 100644
--- a/spec/ruby/core/regexp/initialize_spec.rb
+++ b/spec/ruby/core/regexp/initialize_spec.rb
@@ -5,16 +5,8 @@ describe "Regexp#initialize" do
     Regexp.should have_private_instance_method(:initialize)
   end
 
-  ruby_version_is ""..."3.0" do
-    it "raises a SecurityError on a Regexp literal" do
-      -> { //.send(:initialize, "") }.should raise_error(SecurityError)
-    end
-  end
-
-  ruby_version_is "3.0" do
-    it "raises a FrozenError on a Regexp literal" do
-      -> { //.send(:initialize, "") }.should raise_error(FrozenError)
-    end
+  it "raises a FrozenError on a Regexp literal" do
+    -> { //.send(:initialize, "") }.should raise_error(FrozenError)
   end
 
   it "raises a TypeError on an initialized non-literal Regexp" do
diff --git a/spec/ruby/core/sizedqueue/deq_spec.rb b/spec/ruby/core/sizedqueue/deq_spec.rb
index 5e1bd9f746..985d654bb3 100644
--- a/spec/ruby/core/sizedqueue/deq_spec.rb
+++ b/spec/ruby/core/sizedqueue/deq_spec.rb
@@ -1,6 +1,13 @@
 require_relative '../../spec_helper'
 require_relative '../../shared/queue/deque'
+require_relative '../../shared/types/rb_num2dbl_fails'
 
 describe "SizedQueue#deq" do
   it_behaves_like :queue_deq, :deq, -> { SizedQueue.new(10) }
 end
+
+describe "SizedQueue operations with timeout" do
+  ruby_version_is "3.2" do
+    it_behaves_like :rb_num2dbl_fails, nil, -> v { q = SizedQueue.new(10); q.push(1); q.deq(timeout: v) }
+  end
+end
diff --git a/spec/ruby/core/sizedqueue/pop_spec.rb b/spec/ruby/core/sizedqueue/pop_spec.rb
index a0cf6f509c..5e7cfea8fb 100644
--- a/spec/ruby/core/sizedqueue/pop_spec.rb
+++ b/spec/ruby/core/sizedqueue/pop_spec.rb
@@ -1,6 +1,13 @@
 require_relative '../../spec_helper'
 require_relative '../../shared/queue/deque'
+require_relative '../../shared/types/rb_num2dbl_fails'
 
 describe "SizedQueue#pop" do
   it_behaves_like :queue_deq, :pop, -> { SizedQueue.new(10) }
 end
+
+describe "SizedQueue operations with timeout" do
+  ruby_version_is "3.2" do
+    it_behaves_like :rb_num2dbl_fails, nil, -> v { q = SizedQueue.new(10); q.push(1); q.pop(timeout: v) }
+  end
+end
diff --git a/spec/ruby/core/sizedqueue/shift_spec.rb b/spec/ruby/core/sizedqueue/shift_spec.rb
index 5138e68258..3220801f3a 100644
--- a/spec/ruby/core/sizedqueue/shift_spec.rb
+++ b/spec/ruby/core/sizedqueue/shift_spec.rb
@@ -1,6 +1,13 @@
 require_relative '../../spec_helper'
 require_relative '../../shared/queue/deque'
+require_relative '../../shared/types/rb_num2dbl_fails'
 
 describe "SizedQueue#shift" do
   it_behaves_like :queue_deq, :shift, -> { SizedQueue.new(10) }
 end
+
+describe "SizedQueue operations with timeout" do
+  ruby_version_is "3.2" do
+    it_behaves_like :rb_num2dbl_fails, nil, -> v { q = SizedQueue.new(10); q.push(1); q.shift(timeout: v) }
+  end
+end
diff --git a/spec/ruby/core/string/byteindex_spec.rb b/spec/ruby/core/string/byteindex_spec.rb
new file mode 100644
index 0000000000..7be0c7ec1e
--- /dev/null
+++ b/spec/ruby/core/string/byteindex_spec.rb
@@ -0,0 +1,304 @@
+# -*- encoding: utf-8 -*-
+require_relative '../../spec_helper'
+require_relative 'fixtures/classes'
+require_relative 'shared/byte_index_common.rb'
+
+describe "String#byteindex" do
+  ruby_version_is "3.2" do
+    it "calls #to_str to convert the first argument" do
+      char = mock("string index char")
+      char.should_receive(:to_str).and_return("b")
+      "abc".byteindex(char).should == 1
+    end
+
+    it "calls #to_int to convert the second argument" do
+      offset = mock("string index offset")
+      offset.should_receive(:to_int).and_return(1)
+      "abc".byteindex("c", offset).should == 2
+    end
+
+    it "does not raise IndexError when byte offset is correct or on string boundary" do
+      "わ".byteindex("").should == 0
+      "わ".byteindex("", 0).should == 0
+      "わ".byteindex("", 3).should == 3
+    end
+
+    it_behaves_like :byte_index_common, :byteindex
+  end
+end
+
+describe "String#byteindex with String" do
+  ruby_version_is "3.2" do
+    it "behaves the same as String#byteindex(char) for one-character strings" do
+      "blablabla hello cruel world...!".split("").uniq.each do |str|
+        chr = str[0]
+        str.byteindex(str).should == str.byteindex(chr)
+
+        0.upto(str.size + 1) do |start|
+          str.byteindex(str, start).should == str.byteindex(chr, start)
+        end
+
+        (-str.size - 1).upto(-1) do |start|
+          str.byteindex(str, start).should == str.byteindex(chr, start)
+        end
+      end
+    end
+
+    it "returns the byteindex of the first occurrence of the given substring" do
+      "blablabla".byteindex("").should == 0
+      "blablabla".byteindex("b").should == 0
+      "blablabla".byteindex("bla").should == 0
+      "blablabla".byteindex("blabla").should == 0
+      "blablabla".byteindex("blablabla").should == 0
+
+      "blablabla".byteindex("l").should == 1
+      "blablabla".byteindex("la").should == 1
+      "blablabla".byteindex("labla").should == 1
+      "blablabla".byteindex("lablabla").should == 1
+
+      "blablabla".byteindex("a").should == 2
+      "blablabla".byteindex("abla").should == 2
+      "blablabla".byteindex("ablabla").should == 2
+    end
+
+    it "treats the offset as a byteindex" do
+      "aaaaa".byteindex("a", 0).should == 0
+      "aaaaa".byteindex("a", 2).should == 2
+      "aaaaa".byteindex("a", 4).should == 4
+    end
+
+    it "ignores string subclasses" do
+      "blablabla".byteindex(StringSpecs::MyString.new("bla")).should == 0
+      StringSpecs::MyString.new("blablabla").byteindex("bla").should == 0
+      StringSpecs::MyString.new("blablabla").byteindex(StringSpecs::MyString.new("bla")).should == 0
+    end
+
+    it "starts the search at the given offset" do
+      "blablabla".byteindex("bl", 0).should == 0
+      "blablabla".byteindex("bl", 1).should == 3
+      "blablabla".byteindex("bl", 2).should == 3
+      "blablabla".byteindex("bl", 3).should == 3
+
+      "blablabla".byteindex("bla", 0).should == 0
+      "blablabla".byteindex("bla", 1).should == 3
+      "blablabla".byteindex("bla", 2).should == 3
+      "blablabla".byteindex("bla", 3).should == 3
+
+      "blablabla".byteindex("blab", 0).should == 0
+      "blablabla".byteindex("blab", 1).should == 3
+      "blablabla".byteindex("blab", 2).should == 3
+      "blablabla".byteindex("blab", 3).should == 3
+
+      "blablabla".byteindex("la", 1).should == 1
+      "blablabla".byteindex("la", 2).should == 4
+      "blablabla".byteindex("la", 3).should == 4
+      "blablabla".byteindex("la", 4).should == 4
+
+      "blablabla".byteindex("lab", 1).should == 1
+      "blablabla".byteindex("lab", 2).should == 4
+      "blablabla".byteindex("lab", 3).should == 4
+      "blablabla".byteindex("lab", 4).should == 4
+
+      "blablabla".byteindex("ab", 2).should == 2
+      "blablabla".byteindex("ab", 3).should == 5
+      "blablabla".byteindex("ab", 4).should == 5
+      "blablabla".byteindex("ab", 5).should == 5
+
+      "blablabla".byteindex("", 0).should == 0
+      "blablabla".byteindex("", 1).should == 1
+      "blablabla".byteindex("", 2).should == 2
+      "blablabla".byteindex("", 7).should == 7
+      "blablabla".byteindex("", 8).should == 8
+      "blablabla".byteindex("", 9).should == 9
+    end
+
+    it "starts the search at offset + self.length if offset is negative" do
+      str = "blablabla"
+
+      ["bl", "bla", "blab", "la", "lab", "ab", ""].each do |needle|
+        (-str.length .. -1).each do |offset|
+          str.byteindex(needle, offset).should ==
+          str.byteindex(needle, offset + str.length)
+        end
+      end
+    end
+
+    it "returns nil if the substring isn't found" do
+      "blablabla".byteindex("B").should == nil
+      "blablabla".byteindex("z").should == nil
+      "blablabla".byteindex("BLA").should == nil
+      "blablabla".byteindex("blablablabla").should == nil
+      "blablabla".byteindex("", 10).should == nil
+
+      "hello".byteindex("he", 1).should == nil
+      "hello".byteindex("he", 2).should == nil
+      "I’ve got a multibyte character.\n".byteindex("\n\n").should == nil
+    end
+
+    it "returns the character byteindex of a multibyte character" do
+      "ありがとう".byteindex("が").should == 6
+    end
+
+    it "returns the character byteindex after offset" do
+      "われわれ".byteindex("わ", 3).should == 6
+      "ありがとうありがとう".byteindex("が", 9).should == 21
+    end
+
+    it "returns the character byteindex after a partial first match" do
+      "</</h".byteindex("</h").should == 2
+    end
+
+    it "raises an Encoding::CompatibilityError if the encodings are incompatible" do
+      char = "れ".encode Encoding::EUC_JP
+      -> do
+        "あれ".byteindex(char)
+      end.should raise_error(Encoding::CompatibilityError)
+    end
+
+    it "handles a substring in a superset encoding" do
+      'abc'.force_encoding(Encoding::US_ASCII).byteindex('é').should == nil
+    end
+
+    it "handles a substring in a subset encoding" do
+      'été'.byteindex('t'.force_encoding(Encoding::US_ASCII)).should == 2
+    end
+  end
+end
+
+describe "String#byteindex with Regexp" do
+  ruby_version_is "3.2" do
+    it "behaves the same as String#byteindex(string) for escaped string regexps" do
+      ["blablabla", "hello cruel world...!"].each do |str|
+        ["", "b", "bla", "lab", "o c", "d."].each do |needle|
+          regexp = Regexp.new(Regexp.escape(needle))
+          str.byteindex(regexp).should == str.byteindex(needle)
+
+          0.upto(str.size + 1) do |start|
+            str.byteindex(regexp, start).should == str.byteindex(needle, start)
+          end
+
+          (-str.size - 1).upto(-1) do |start|
+            str.byteindex(regexp, start).should == str.byteindex(needle, start)
+          end
+        end
+      end
+    end
+
+    it "returns the byteindex of the first match of regexp" do
+      "blablabla".byteindex(/bla/).should == 0
+      "blablabla".byteindex(/BLA/i).should == 0
+
+      "blablabla".byteindex(/.{0}/).should == 0
+      "blablabla".byteindex(/.{6}/).should == 0
+      "blablabla".byteindex(/.{9}/).should == 0
+
+      "blablabla".byteindex(/.*/).should == 0
+      "blablabla".byteindex(/.+/).should == 0
+
+      "blablabla".byteindex(/lab|b/).should == 0
+
+      not_supported_on :opal do
+        "blablabla".byteindex(/\A/).should == 0
+        "blablabla".byteindex(/\Z/).should == 9
+        "blablabla".byteindex(/\z/).should == 9
+        "blablabla\n".byteindex(/\Z/).should == 9
+        "blablabla\n".byteindex(/\z/).should == 10
+      end
+
+      "blablabla".byteindex(/^/).should == 0
+      "\nblablabla".byteindex(/^/).should == 0
+      "b\nablabla".byteindex(/$/).should == 1
+      "bl\nablabla".byteindex(/$/).should == 2
+
+      "blablabla".byteindex(/.l./).should == 0
+    end
+
+    it "starts the search at the given offset" do
+      "blablabla".byteindex(/.{0}/, 5).should == 5
+      "blablabla".byteindex(/.{1}/, 5).should == 5
+      "blablabla".byteindex(/.{2}/, 5).should == 5
+      "blablabla".byteindex(/.{3}/, 5).should == 5
+      "blablabla".byteindex(/.{4}/, 5).should == 5
+
+      "blablabla".byteindex(/.{0}/, 3).should == 3
+      "blablabla".byteindex(/.{1}/, 3).should == 3
+      "blablabla".byteindex(/.{2}/, 3).should == 3
+      "blablabla".byteindex(/.{5}/, 3).should == 3
+      "blablabla".byteindex(/.{6}/, 3).should == 3
+
+      "blablabla".byteindex(/.l./, 0).should == 0
+      "blablabla".byteindex(/.l./, 1).should == 3
+      "blablabla".byteindex(/.l./, 2).should == 3
+      "blablabla".byteindex(/.l./, 3).should == 3
+
+      "xblaxbla".byteindex(/x./, 0).should == 0
+      "xblaxbla".byteindex(/x./, 1).should == 4
+      "xblaxbla".byteindex(/x./, 2).should == 4
+
+      not_supported_on :opal do
+        "blablabla\n".byteindex(/\Z/, 9).should == 9
+      end
+    end
+
+    it "starts the search at offset + self.length if offset is negative" do
+      str = "blablabla"
+
+      ["bl", "bla", "blab", "la", "lab", "ab", ""].each do |needle|
+        (-str.length .. -1).each do |offset|
+          str.byteindex(needle, offset).should ==
+          str.byteindex(needle, offset + str.length)
+        end
+      end
+    end
+
+    it "returns nil if the substring isn't found" do
+      "blablabla".byteindex(/BLA/).should == nil
+
+      "blablabla".byteindex(/.{10}/).should == nil
+      "blaxbla".byteindex(/.x/, 3).should == nil
+      "blaxbla".byteindex(/..x/, 2).should == nil
+    end
+
+    it "returns nil if the Regexp matches the empty string and the offset is out of range" do
+      "ruby".byteindex(//, 12).should be_nil
+    end
+
+    it "supports \\G which matches at the given start offset" do
+      "helloYOU.".byteindex(/\GYOU/, 5).should == 5
+      "helloYOU.".byteindex(/\GYOU/).should == nil
+
+      re = /\G.+YOU/
+      # The # marks where \G will match.
+      [
+        ["#hi!YOUall.", 0],
+        ["h#i!YOUall.", 1],
+        ["hi#!YOUall.", 2],
+        ["hi!#YOUall.", nil]
+      ].each do |spec|
+
+        start = spec[0].byteindex("#")
+        str = spec[0].delete("#")
+
+        str.byteindex(re, start).should == spec[1]
+      end
+    end
+
+    it "converts start_offset to an integer via to_int" do
+      obj = mock('1')
+      obj.should_receive(:to_int).and_return(1)
+      "RWOARW".byteindex(/R./, obj).should == 4
+    end
+
+    it "returns the character byteindex of a multibyte character" do
+      "ありがとう".byteindex(/が/).should == 6
+    end
+
+    it "returns the character byteindex after offset" do
+      "われわれ".byteindex(/わ/, 3).should == 6
+    end
+
+    it "treats the offset as a byteindex" do
+      "われわわれ".byteindex(/わ/, 6).should == 6
+    end
+  end
+end
diff --git a/spec/ruby/core/string/byterindex_spec.rb b/spec/ruby/core/string/byterindex_spec.rb
new file mode 100644
index 0000000000..717708c97d
--- /dev/null
+++ b/spec/ruby/core/string/byterindex_spec.rb
@@ -0,0 +1,359 @@
+# -*- encoding: utf-8 -*-
+require_relative '../../spec_helper'
+require_relative 'fixtures/classes'
+require_relative 'shared/byte_index_common.rb'
+
+describe "String#byterindex with object" do
+  ruby_version_is "3.2" do
+    it "tries to convert obj to a string via to_str" do
+      obj = mock('lo')
+      def obj.to_str() "lo" end
+      "hello".byterindex(obj).should == "hello".byterindex("lo")
+
+      obj = mock('o')
+      def obj.respond_to?(arg, *) true end
+      def obj.method_missing(*args) "o" end
+      "hello".byterindex(obj).should == "hello".byterindex("o")
+    end
+
+    it "calls #to_int to convert the second argument" do
+      offset = mock("string index offset")
+      offset.should_receive(:to_int).and_return(3)
+      "abc".byterindex("c", offset).should == 2
+    end
+
+    it "does not raise IndexError when byte offset is correct or on string boundary" do
+      "わ".byterindex("", 0).should == 0
+      "わ".byterindex("", 3).should == 3
+      "わ".byterindex("").should == 3
+    end
+
+    it_behaves_like :byte_index_common, :byterindex
+  end
+end
+
+describe "String#byterindex with String" do
+  ruby_version_is "3.2" do
+    it "behaves the same as String#byterindex(char) for one-character strings" do
+      "blablabla hello cruel world...!".split("").uniq.each do |str|
+        chr = str[0]
+        str.byterindex(str).should == str.byterindex(chr)
+
+        0.upto(str.size + 1) do |start|
+          str.byterindex(str, start).should == str.byterindex(chr, start)
+        end
+
+        (-str.size - 1).upto(-1) do |start|
+          str.byterindex(str, start).should == str.byterindex(chr, start)
+        end
+      end
+    end
+
+    it "behaves the same as String#byterindex(?char) for one-character strings" do
+      "blablabla hello cruel world...!".split("").uniq.each do |str|
+        chr = str[0] =~ / / ? str[0] : eval("?#{str[0]}")
+        str.byterindex(str).should == str.byterindex(chr)
+
+        0.upto(str.size + 1) do |start|
+          str.byterindex(str, start).should == str.byterindex(chr, start)
+        end
+
+        (-str.size - 1).upto(-1) do |start|
+          str.byterindex(str, start).should == str.byterindex(chr, start)
+        end
+      end
+    end
+
+    it "returns the index of the last occurrence of the given substring" do
+      "blablabla".byterindex("").should == 9
+      "blablabla".byterindex("a").should == 8
+      "blablabla".byterindex("la").should == 7
+      "blablabla".byterindex("bla").should == 6
+      "blablabla".byterindex("abla").should == 5
+      "blablabla".byterindex("labla").should == 4
+      "blablabla".byterindex("blabla").should == 3
+      "blablabla".byterindex("ablabla").should == 2
+      "blablabla".byterindex("lablabla").should == 1
+      "blablabla".byterindex("blablabla").should == 0
+
+      "blablabla".byterindex("l").should == 7
+      "blablabla".byterindex("bl").should == 6
+      "blablabla".byterindex("abl").should == 5
+      "blablabla".byterindex("labl").should == 4
+      "blablabla".byterindex("blabl").should == 3
+      "blablabla".byterindex("ablabl").should == 2
+      "blablabla".byterindex("lablabl").should == 1
+      "blablabla".byterindex("blablabl").should == 0
+
+      "blablabla".byterindex("b").should == 6
+      "blablabla".byterindex("ab").should == 5
+      "blablabla".byterindex("lab").should == 4
+      "blablabla".byterindex("blab").should == 3
+      "blablabla".byterindex("ablab").should == 2
+      "blablabla".byterindex("lablab").should == 1
+      "blablabla".byterindex("blablab").should == 0
+    end
+
+    it "ignores string subclasses" do
+      "blablabla".byterindex(StringSpecs::MyString.new("bla")).should == 6
+      StringSpecs::MyString.new("blablabla").byterindex("bla").should == 6
+      StringSpecs::MyString.new("blablabla").byterindex(StringSpecs::MyString.new("bla")).should == 6
+    end
+
+    it "starts the search at the given offset" do
+      "blablabla".byterindex("bl", 0).should == 0
+      "blablabla".byterindex("bl", 1).should == 0
+      "blablabla".byterindex("bl", 2).should == 0
+      "blablabla".byterindex("bl", 3).should == 3
+
+      "blablabla".byterindex("bla", 0).should == 0
+      "blablabla".byterindex("bla", 1).should == 0
+      "blablabla".byterindex("bla", 2).should == 0
+      "blablabla".byterindex("bla", 3).should == 3
+
+      "blablabla".byterindex("blab", 0).should == 0
+      "blablabla".byterindex("blab", 1).should == 0
+      "blablabla".byterindex("blab", 2).should == 0
+      "blablabla".byterindex("blab", 3).should == 3
+      "blablabla".byterindex("blab", 6).should == 3
+      "blablablax".byterindex("blab", 6).should == 3
+
+      "blablabla".byterindex("la", 1).should == 1
+      "blablabla".byterindex("la", 2).should == 1
+      "blablabla".byterindex("la", 3).should == 1
+      "blablabla".byterindex("la", 4).should == 4
+
+      "blablabla".byterindex("lab", 1).should == 1
+      "blablabla".byterindex("lab", 2).should == 1
+      "blablabla".byterindex("lab", 3).should == 1
+      "blablabla".byterindex("lab", 4).should == 4
+
+      "blablabla".byterindex("ab", 2).should == 2
+      "blablabla".byterindex("ab", 3).should == 2
+      "blablabla".byterindex("ab", 4).should == 2
+      "blablabla".byterindex("ab", 5).should == 5
+
+      "blablabla".byterindex("", 0).should == 0
+      "blablabla".byterindex("", 1).should == 1
+      "blablabla".byterindex("", 2).should == 2
+      "blablabla".byterindex("", 7).should == 7
+      "blablabla".byterindex("", 8).should == 8
+      "blablabla".byterindex("", 9).should == 9
+      "blablabla".byterindex("", 10).should == 9
+    end
+
+    it "starts the search at offset + self.length if offset is negative" do
+      str = "blablabla"
+
+      ["bl", "bla", "blab", "la", "lab", "ab", ""].each do |needle|
+        (-str.length .. -1).each do |offset|
+          str.byterindex(needle, offset).should ==
+          str.byterindex(needle, offset + str.length)
+        end
+      end
+    end
+
+    it "returns nil if the substring isn't found" do
+      "blablabla".byterindex("B").should == nil
+      "blablabla".byterindex("z").should == nil
+      "blablabla".byterindex("BLA").should == nil
+      "blablabla".byterindex("blablablabla").should == nil
+
+      "hello".byterindex("lo", 0).should == nil
+      "hello".byterindex("lo", 1).should == nil
+      "hello".byterindex("lo", 2).should == nil
+
+      "hello".byterindex("llo", 0).should == nil
+      "hello".byterindex("llo", 1).should == nil
+
+      "hello".byterindex("el", 0).should == nil
+      "hello".byterindex("ello", 0).should == nil
+
+      "hello".byterindex("", -6).should == nil
+      "hello".byterindex("", -7).should == nil
+
+      "hello".byterindex("h", -6).should == nil
+    end
+
+    it "tries to convert start_offset to an integer via to_int" do
+      obj = mock('5')
+      def obj.to_int() 5 end
+      "str".byterindex("st", obj).should == 0
+
+      obj = mock('5')
+      def obj.respond_to?(arg, *) true end
+      def obj.method_missing(*args) 5 end
+      "str".byterindex("st", obj).should == 0
+    end
+
+    it "raises a TypeError when given offset is nil" do
+      -> { "str".byterindex("st", nil) }.should raise_error(TypeError)
+    end
+
+    it "handles a substring in a superset encoding" do
+      'abc'.force_encoding(Encoding::US_ASCII).byterindex('é').should == nil
+    end
+
+    it "handles a substring in a subset encoding" do
+      'été'.byterindex('t'.force_encoding(Encoding::US_ASCII)).should == 2
+    end
+  end
+end
+
+describe "String#byterindex with Regexp" do
+  ruby_version_is "3.2" do
+    it "behaves the same as String#byterindex(string) for escaped string regexps" do
+      ["blablabla", "hello cruel world...!"].each do |str|
+        ["", "b", "bla", "lab", "o c", "d."].each do |needle|
+          regexp = Regexp.new(Regexp.escape(needle))
+          str.byterindex(regexp).should == str.byterindex(needle)
+
+          0.upto(str.size + 1) do |start|
+            str.byterindex(regexp, start).should == str.byterindex(needle, start)
+          end
+
+          (-str.size - 1).upto(-1) do |start|
+            str.byterindex(regexp, start).should == str.byterindex(needle, start)
+          end
+        end
+      end
+    end
+
+    it "returns the index of the first match from the end of string of regexp" do
+      "blablabla".byterindex(/bla/).should == 6
+      "blablabla".byterindex(/BLA/i).should == 6
+
+      "blablabla".byterindex(/.{0}/).should == 9
+      "blablabla".byterindex(/.{1}/).should == 8
+      "blablabla".byterindex(/.{2}/).should == 7
+      "blablabla".byterindex(/.{6}/).should == 3
+      "blablabla".byterindex(/.{9}/).should == 0
+
+      "blablabla".byterindex(/.*/).should == 9
+      "blablabla".byterindex(/.+/).should == 8
+
+      "blablabla".byterindex(/bla|a/).should == 8
+
+      not_supported_on :opal do
+        "blablabla".byterindex(/\A/).should == 0
+        "blablabla".byterindex(/\Z/).should == 9
+        "blablabla".byterindex(/\z/).should == 9
+        "blablabla\n".byterindex(/\Z/).should == 10
+        "blablabla\n".byterindex(/\z/).should == 10
+      end
+
+      "blablabla".byterindex(/^/).should == 0
+      not_supported_on :opal do
+        "\nblablabla".byterindex(/^/).should == 1
+        "b\nlablabla".byterindex(/^/).should == 2
+      end
+      "blablabla".byterindex(/$/).should == 9
+
+      "blablabla".byterindex(/.l./).should == 6
+    end
+
+    it "starts the search at the given offset" do
+      "blablabla".byterindex(/.{0}/, 5).should == 5
+      "blablabla".byterindex(/.{1}/, 5).should == 5
+      "blablabla".byterindex(/.{2}/, 5).should == 5
+      "blablabla".byterindex(/.{3}/, 5).should == 5
+      "blablabla".byterindex(/.{4}/, 5).should == 5
+
+      "blablabla".byterindex(/.{0}/, 3).should == 3
+      "blablabla".byterindex(/.{1}/, 3).should == 3
+      "blablabla".byterindex(/.{2}/, 3).should == 3
+      "blablabla".byterindex(/.{5}/, 3).should == 3
+      "blablabla".byterindex(/.{6}/, 3).should == 3
+
+      "blablabla".byterindex(/.l./, 0).should == 0
+      "blablabla".byterindex(/.l./, 1).should == 0
+      "blablabla".byterindex(/.l./, 2).should == 0
+      "blablabla".byterindex(/.l./, 3).should == 3
+
+      "blablablax".byterindex(/.x/, 10).should == 8
+      "blablablax".byterindex(/.x/, 9).should == 8
+      "blablablax".byterindex(/.x/, 8).should == 8
+
+      "blablablax".byterindex(/..x/, 10).should == 7
+      "blablablax".byterindex(/..x/, 9).should == 7
+      "blablablax".byterindex(/..x/, 8).should == 7
+      "blablablax".byterindex(/..x/, 7).should == 7
+
+      not_supported_on :opal do
+        "blablabla\n".byterindex(/\Z/, 9).should == 9
+      end
+    end
+
+    it "starts the search at offset + self.length if offset is negative" do
+      str = "blablabla"
+
+      ["bl", "bla", "blab", "la", "lab", "ab", ""].each do |needle|
+        (-str.length .. -1).each do |offset|
+          str.byterindex(needle, offset).should ==
+          str.byterindex(needle, offset + str.length)
+        end
+      end
+    end
+
+    it "returns nil if the substring isn't found" do
+      "blablabla".byterindex(/BLA/).should == nil
+      "blablabla".byterindex(/.{10}/).should == nil
+      "blablablax".byterindex(/.x/, 7).should == nil
+      "blablablax".byterindex(/..x/, 6).should == nil
+
+      not_supported_on :opal do
+        "blablabla".byterindex(/\Z/, 5).should == nil
+        "blablabla".byterindex(/\z/, 5).should == nil
+        "blablabla\n".byterindex(/\z/, 9).should == nil
+      end
+    end
+
+    not_supported_on :opal do
+      it "supports \\G which matches at the given start offset" do
+        "helloYOU.".byterindex(/YOU\G/, 8).should == 5
+        "helloYOU.".byterindex(/YOU\G/).should == nil
+
+        idx = "helloYOUall!".index("YOU")
+        re = /YOU.+\G.+/
+        # The # marks where \G will match.
+        [
+          ["helloYOU#all.", nil],
+          ["helloYOUa#ll.", idx],
+          ["helloYOUal#l.", idx],
+          ["helloYOUall#.", idx],
+          ["helloYOUall.#", nil]
+        ].each do |i|
+          start = i[0].index("#")
+          str = i[0].delete("#")
+
+          str.byterindex(re, start).should == i[1]
+        end
+      end
+    end
+
+    it "tries to convert start_offset to an integer" do
+      obj = mock('5')
+      def obj.to_int() 5 end
+      "str".byterindex(/../, obj).should == 1
+
+      obj = mock('5')
+      def obj.respond_to?(arg, *) true end
+      def obj.method_missing(*args); 5; end
+      "str".byterindex(/../, obj).should == 1
+    end
+
+    it "raises a TypeError when given offset is nil" do
+      -> { "str".byterindex(/../, nil) }.should raise_error(TypeError)
+    end
+
+    it "returns the reverse byte index of a multibyte character" do
+      "ありがりがとう".byterindex("が").should == 12
+      "ありがりがとう".byterindex(/が/).should == 12
+    end
+
+    it "returns the character index before the finish" do
+       "ありがりがとう".byterindex("が", 9).should == 6
+       "ありがりがとう".byterindex(/が/, 9).should == 6
+    end
+  end
+end
diff --git a/spec/ruby/core/string/capitalize_spec.rb b/spec/ruby/core/string/capitalize_spec.rb
index 3f85cf5ae4..b79e9cfdbd 100644
--- a/spec/ruby/core/string/capitalize_spec.rb
+++ b/spec/ruby/core/string/capitalize_spec.rb
@@ -78,18 +78,9 @@ describe "String#capitalize" do
     -> { "abc".capitalize(:invalid_option) }.should raise_error(ArgumentError)
   end
 
-  ruby_version_is ''...'3.0' do
-    it "returns subclass instances when called on a subclass" do
-      StringSpecs::MyString.new("hello").capitalize.should be_an_instance_of(StringSpecs::MyString)
-      StringSpecs::MyString.new("Hello").capitalize.should be_an_instance_of(StringSpecs::MyString)
-    end
-  end
-
-  ruby_version_is '3.0' do
-    it "returns String instances when called on a subclass" do
-      StringSpecs::MyString.new("hello").capitalize.should be_an_instance_of(String)
-      StringSpecs::MyString.new("Hello").capitalize.should be_an_instance_of(String)
-    end
+  it "returns String instances when called on a subclass" do
+    StringSpecs::MyString.new("hello").capitalize.should be_an_instance_of(String)
+    StringSpecs::MyString.new("Hello").capitalize.should be_an_instance_of(String)
   end
 
   it "returns a String in the same encoding as self" do
diff --git a/spec/ruby/core/string/center_spec.rb b/spec/ruby/core/string/center_spec.rb
index 76da6e1e09..a59dd2a91b 100644
--- a/spec/ruby/core/string/center_spec.rb
+++ b/spec/ruby/core/string/center_spec.rb
@@ -81,26 +81,13 @@ describe "String#center with length, padding" do
     -> { "hello".center(0, "")  }.should raise_error(ArgumentError)
   end
 
-  ruby_version_is ''...'3.0' do
-    it "returns subclass instances when called on subclasses" do
-      StringSpecs::MyString.new("").center(10).should be_an_instance_of(StringSpecs::MyString)
-      StringSpecs::MyString.new("foo").center(10).should be_an_instance_of(StringSpecs::MyString)
-      StringSpecs::MyString.new("foo").center(10, StringSpecs::MyString.new("x")).should be_an_instance_of(StringSpecs::MyString)
-
-      "".center(10, StringSpecs::MyString.new("x")).should be_an_instance_of(String)
-      "foo".center(10, StringSpecs::MyString.new("x")).should be_an_instance_of(String)
-    end
-  end
+  it "returns String instances when called on subclasses" do
+    StringSpecs::MyString.new("").center(10).should be_an_instance_of(String)
+    StringSpecs::MyString.new("foo").center(10).should be_an_instance_of(String)
+    StringSpecs::MyString.new("foo").center(10, StringSpecs::MyString.new("x")).should be_an_instance_of(String)
 
-  ruby_version_is '3.0' do
-    it "returns String instances when called on subclasses" do
-      StringSpecs::MyString.new("").center(10).should be_an_instance_of(String)
-      StringSpecs::MyString.new("foo").center(10).should be_an_instance_of(String)
-      StringSpecs::MyString.new("foo").center(10, StringSpecs::MyString.new("x")).should be_an_instance_of(String)
-
-      "".center(10, StringSpecs::MyString.new("x")).should be_an_instance_of(String)
-      "foo".center(10, StringSpecs::MyString.new("x")).should be_an_instance_of(String)
-    end
+    "".center(10, StringSpecs::MyString.new("x")).should be_an_instance_of(String)
+    "foo".center(10, StringSpecs::MyString.new("x")).should be_an_instance_of(String)
   end
 
   describe "with width" do
diff --git a/spec/ruby/core/string/chomp_spec.rb b/spec/ruby/core/string/chomp_spec.rb
index d0508d938f..ec0490220b 100644
--- a/spec/ruby/core/string/chomp_spec.rb
+++ b/spec/ruby/core/string/chomp_spec.rb
@@ -44,18 +44,9 @@ describe "String#chomp" do
       "abc\n\n".encode("US-ASCII").chomp.encoding.should == Encoding::US_ASCII
     end
 
-    ruby_version_is ''...'3.0' do
-      it "returns subclass instances when called on a subclass" do
-        str = StringSpecs::MyString.new("hello\n").chomp
-        str.should be_an_instance_of(StringSpecs::MyString)
-      end
-    end
-
-    ruby_version_is '3.0' do
-      it "returns String instances when called on a subclass" do
-        str = StringSpecs::MyString.new("hello\n").chomp
-        str.should be_an_instance_of(String)
-      end
+    it "returns String instances when called on a subclass" do
+      str = StringSpecs::MyString.new("hello\n").chomp
+      str.should be_an_instance_of(String)
     end
 
     it "removes trailing characters that match $/ when it has been assigned a value" do
diff --git a/spec/ruby/core/string/chop_spec.rb b/spec/ruby/core/string/chop_spec.rb
index f598d34bc8..75f25b39cd 100644
--- a/spec/ruby/core/string/chop_spec.rb
+++ b/spec/ruby/core/string/chop_spec.rb
@@ -49,16 +49,8 @@ describe "String#chop" do
     s.chop.should_not equal(s)
   end
 
-  ruby_version_is ''...'3.0' do
-    it "returns subclass instances when called on a subclass" do
-      StringSpecs::MyString.new("hello\n").chop.should be_an_instance_of(StringSpecs::MyString)
-    end
-  end
-
-  ruby_version_is '3.0' do
-    it "returns String instances when called on a subclass" do
-      StringSpecs::MyString.new("hello\n").chop.should be_an_instance_of(String)
-    end
+  it "returns String instances when called on a subclass" do
+    StringSpecs::MyString.new("hello\n").chop.should be_an_instance_of(String)
   end
 
   it "returns a String in the same encoding as self" do
diff --git a/spec/ruby/core/string/delete_prefix_spec.rb b/spec/ruby/core/string/delete_prefix_spec.rb
index 238de85f05..4214fdecce 100644
--- a/spec/ruby/core/string/delete_prefix_spec.rb
+++ b/spec/ruby/core/string/delete_prefix_spec.rb
@@ -38,18 +38,9 @@ describe "String#delete_prefix" do
     'hello'.delete_prefix(o).should == 'o'
   end
 
-  ruby_version_is ''...'3.0' do
-    it "returns a subclass instance when called on a subclass instance" do
-      s = StringSpecs::MyString.new('hello')
-      s.delete_prefix('hell').should be_an_instance_of(StringSpecs::MyString)
-    end
-  end
-
-  ruby_version_is '3.0' do
-    it "returns a String instance when called on a subclass instance" do
-      s = StringSpecs::MyString.new('hello')
-      s.delete_prefix('hell').should be_an_instance_of(String)
-    end
+  it "returns a String instance when called on a subclass instance" do
+    s = StringSpecs::MyString.new('hello')
+    s.delete_prefix('hell').should be_an_instance_of(String)
   end
 
   it "returns a String in the same encoding as self" do
diff --git a/spec/ruby/core/string/delete_spec.rb b/spec/ruby/core/string/delete_spec.rb
index 87831a9d19..3b9aa4fb75 100644
--- a/spec/ruby/core/string/delete_spec.rb
+++ b/spec/ruby/core/string/delete_spec.rb
@@ -84,16 +84,8 @@ describe "String#delete" do
     -> { "hello world".delete(mock('x')) }.should raise_error(TypeError)
   end
 
-  ruby_version_is ''...'3.0' do
-    it "returns subclass instances when called on a subclass" do
-      StringSpecs::MyString.new("oh no!!!").delete("!").should be_an_instance_of(StringSpecs::MyString)
-    end
-  end
-
-  ruby_version_is '3.0' do
-    it "returns String instances when called on a subclass" do
-      StringSpecs::MyString.new("oh no!!!").delete("!").should be_an_instance_of(String)
-    end
+  it "returns String instances when called on a subclass" do
+    StringSpecs::MyString.new("oh no!!!").delete("!").should be_an_instance_of(String)
   end
 
   it "returns a String in the same encoding as self" do
diff --git a/spec/ruby/core/string/delete_suffix_spec.rb b/spec/ruby/core/string/delete_suffix_spec.rb
index 6883d6938c..9381f4cee7 100644
--- a/spec/ruby/core/string/delete_suffix_spec.rb
+++ b/spec/ruby/core/string/delete_suffix_spec.rb
@@ -38,18 +38,9 @@ describe "String#delete_suffix" do
     'hello'.delete_suffix(o).should == 'h'
   end
 
-  ruby_version_is ''...'3.0' do
-    it "returns a subclass instance when called on a subclass instance" do
-      s = StringSpecs::MyString.new('hello')
-      s.delete_suffix('ello').should be_an_instance_of(StringSpecs::MyString)
-    end
-  end
-
-  ruby_version_is '3.0' do
-    it "returns a String instance when called on a subclass instance" do
-      s = StringSpecs::MyString.new('hello')
-      s.delete_suffix('ello').should be_an_instance_of(String)
-    end
+  it "returns a String instance when called on a subclass instance" do
+    s = StringSpecs::MyString.new('hello')
+    s.delete_suffix('ello').should be_an_instance_of(String)
   end
 
   it "returns a String in the same encoding as self" do
diff --git a/spec/ruby/core/string/downcase_spec.rb b/spec/ruby/core/string/downcase_spec.rb
index 153b4ce191..7ee9d6df1d 100644
--- a/spec/ruby/core/string/downcase_spec.rb
+++ b/spec/ruby/core/string/downcase_spec.rb
@@ -76,16 +76,8 @@ describe "String#downcase" do
     -> { "ABC".downcase(:invalid_option) }.should raise_error(ArgumentError)
   end
 
-  ruby_version_is ''...'3.0' do
-    it "returns a subclass instance for subclasses" do
-      StringSpecs::MyString.new("FOObar").downcase.should be_an_instance_of(StringSpecs::MyString)
-    end
-  end
-
-  ruby_version_is '3.0' do
-    it "returns a String instance for subclasses" do
-      StringSpecs::MyString.new("FOObar").downcase.should be_an_instance_of(String)
-    end
+  it "returns a String instance for subclasses" do
+    StringSpecs::MyString.new("FOObar").downcase.should be_an_instance_of(String)
   end
 end
 
diff --git a/spec/ruby/core/string/dump_spec.rb b/spec/ruby/core/string/dump_spec.rb
index 81de0cfae4..cab8beff5a 100644
--- a/spec/ruby/core/string/dump_spec.rb
+++ b/spec/ruby/core/string/dump_spec.rb
@@ -7,16 +7,8 @@ describe "String#dump" do
     "foo".freeze.dump.should_not.frozen?
   end
 
-  ruby_version_is ''...'3.0' do
-    it "returns a subclass instance" do
-      StringSpecs::MyString.new.dump.should be_an_instance_of(StringSpecs::MyString)
-    end
-  end
-
-  ruby_version_is '3.0' do
-    it "returns a String instance" do
-      StringSpecs::MyString.new.dump.should be_an_instance_of(String)
-    end
+  it "returns a String instance" do
+    StringSpecs::MyString.new.dump.should be_an_instance_of(String)
   end
 
   it "wraps string with \"" do
diff --git a/spec/ruby/core/string/each_grapheme_cluster_spec.rb b/spec/ruby/core/string/each_grapheme_cluster_spec.rb
index f28e24000e..e1fa4ae67b 100644
--- a/spec/ruby/core/string/each_grapheme_cluster_spec.rb
+++ b/spec/ruby/core/string/each_grapheme_cluster_spec.rb
@@ -8,11 +8,9 @@ describe "String#each_grapheme_cluster" do
   it_behaves_like :string_grapheme_clusters, :each_grapheme_cluster
   it_behaves_like :string_each_char_without_block, :each_grapheme_cluster
 
-  ruby_version_is '3.0' do
-    it "yields String instances for subclasses" do
-      a = []
-      StringSpecs::MyString.new("abc").each_grapheme_cluster { |s| a << s.class }
-      a.should == [String, String, String]
-    end
+  it "yields String instances for subclasses" do
+    a = []
+    StringSpecs::MyString.new("abc").each_grapheme_cluster { |s| a << s.class }
+    a.should == [String, String, String]
   end
 end
diff --git a/spec/ruby/core/string/gsub_spec.rb b/spec/ruby/core/string/gsub_spec.rb
index c87a566591..9e3b50322c 100644
--- a/spec/ruby/core/string/gsub_spec.rb
+++ b/spec/ruby/core/string/gsub_spec.rb
@@ -192,22 +192,11 @@ describe "String#gsub with pattern and replacement" do
     -> { "hello".gsub(/[aeiou]/, nil)           }.should raise_error(TypeError)
   end
 
-  ruby_version_is ''...'3.0' do
-    it "returns subclass instances when called on a subclass" do
-      StringSpecs::MyString.new("").gsub(//, "").should be_an_instance_of(StringSpecs::MyString)
-      StringSpecs::MyString.new("").gsub(/foo/, "").should be_an_instance_of(StringSpecs::MyString)
-      StringSpecs::MyString.new("foo").gsub(/foo/, "").should be_an_instance_of(StringSpecs::MyString)
-      StringSpecs::MyString.new("foo").gsub("foo", "").should be_an_instance_of(StringSpecs::MyString)
-    end
-  end
-
-  ruby_version_is '3.0' do
-    it "returns String instances when called on a subclass" do
-      StringSpecs::MyString.new("").gsub(//, "").should be_an_instance_of(String)
-      StringSpecs::MyString.new("").gsub(/foo/, "").should be_an_instance_of(String)
-      StringSpecs::MyString.new("foo").gsub(/foo/, "").should be_an_instance_of(String)
-      StringSpecs::MyString.new("foo").gsub("foo", "").should be_an_instance_of(String)
-    end
+  it "returns String instances when called on a subclass" do
+    StringSpecs::MyString.new("").gsub(//, "").should be_an_instance_of(String)
+    StringSpecs::MyString.new("").gsub(/foo/, "").should be_an_instance_of(String)
+    StringSpecs::MyString.new("foo").gsub(/foo/, "").should be_an_instance_of(String)
+    StringSpecs::MyString.new("foo").gsub("foo", "").should be_an_instance_of(String)
   end
 
   it "sets $~ to MatchData of last match and nil when there's none" do
diff --git a/spec/ruby/core/string/ljust_spec.rb b/spec/ruby/core/string/ljust_spec.rb
index 9a25d3abd4..9208ec5897 100644
--- a/spec/ruby/core/string/ljust_spec.rb
+++ b/spec/ruby/core/string/ljust_spec.rb
@@ -64,26 +64,13 @@ describe "String#ljust with length, padding" do
     -> { "hello".ljust(10, '') }.should raise_error(ArgumentError)
   end
 
-  ruby_version_is ''...'3.0' do
-    it "returns subclass instances when called on subclasses" do
-      StringSpecs::MyString.new("").ljust(10).should be_an_instance_of(StringSpecs::MyString)
-      StringSpecs::MyString.new("foo").ljust(10).should be_an_instance_of(StringSpecs::MyString)
-      StringSpecs::MyString.new("foo").ljust(10, StringSpecs::MyString.new("x")).should be_an_instance_of(StringSpecs::MyString)
-
-      "".ljust(10, StringSpecs::MyString.new("x")).should be_an_instance_of(String)
-      "foo".ljust(10, StringSpecs::MyString.new("x")).should be_an_instance_of(String)
-    end
-  end
+  it "returns String instances when called on subclasses" do
+    StringSpecs::MyString.new("").ljust(10).should be_an_instance_of(String)
+    StringSpecs::MyString.new("foo").ljust(10).should be_an_instance_of(String)
+    StringSpecs::MyString.new("foo").ljust(10, StringSpecs::MyString.new("x")).should be_an_instance_of(String)
 
-  ruby_version_is '3.0' do
-    it "returns String instances when called on subclasses" do
-      StringSpecs::MyString.new("").ljust(10).should be_an_instance_of(String)
-      StringSpecs::MyString.new("foo").ljust(10).should be_an_instance_of(String)
-      StringSpecs::MyString.new("foo").ljust(10, StringSpecs::MyString.new("x")).should be_an_instance_of(String)
-
-      "".ljust(10, StringSpecs::MyString.new("x")).should be_an_instance_of(String)
-      "foo".ljust(10, StringSpecs::MyString.new("x")).should be_an_instance_of(String)
-    end
+    "".ljust(10, StringSpecs::MyString.new("x")).should be_an_instance_of(String)
+    "foo".ljust(10, StringSpecs::MyString.new("x")).should be_an_instance_of(String)
   end
 
   describe "with width" do
diff --git a/spec/ruby/core/string/lstrip_spec.rb b/spec/ruby/core/string/lstrip_spec.rb
index 75434613f1..85685deb0a 100644
--- a/spec/ruby/core/string/lstrip_spec.rb
+++ b/spec/ruby/core/string/lstrip_spec.rb
@@ -20,11 +20,9 @@ describe "String#lstrip" do
     "   こにちわ "[1...-1].lstrip.should == "こにちわ"
   end
 
-  ruby_version_is '3.0' do
-    it "strips leading \\0" do
-     "\x00hello".lstrip.should == "hello"
-     "\000 \000hello\000 \000".lstrip.should == "hello\000 \000"
-    end
+  it "strips leading \\0" do
+   "\x00hello".lstrip.should == "hello"
+   "\000 \000hello\000 \000".lstrip.should == "hello\000 \000"
   end
 end
 
@@ -47,12 +45,10 @@ describe "String#lstrip!" do
     "  ".lstrip.should == ""
   end
 
-  ruby_version_is '3.0' do
-    it "removes leading NULL bytes and whitespace" do
-      a = "\000 \000hello\000 \000"
-      a.lstrip!
-      a.should == "hello\000 \000"
-    end
+  it "removes leading NULL bytes and whitespace" do
+    a = "\000 \000hello\000 \000"
+    a.lstrip!
+    a.should == "hello\000 \000"
   end
 
   it "raises a FrozenError on a frozen instance that is modified" do
diff --git a/spec/ruby/core/string/reverse_spec.rb b/spec/ruby/core/string/reverse_spec.rb
index 73526256ef..e67122c05c 100644
--- a/spec/ruby/core/string/reverse_spec.rb
+++ b/spec/ruby/core/string/reverse_spec.rb
@@ -10,20 +10,10 @@ describe "String#reverse" do
     "".reverse.should == ""
   end
 
-  ruby_version_is '3.0' do
-    it "returns String instances when called on a subclass" do
-      StringSpecs::MyString.new("stressed").reverse.should be_an_instance_of(String)
-      StringSpecs::MyString.new("m").reverse.should be_an_instance_of(String)
-      StringSpecs::MyString.new("").reverse.should be_an_instance_of(String)
-    end
-  end
-
-  ruby_version_is ''...'3.0' do
-    it "returns subclass instances when called on a subclass" do
-      StringSpecs::MyString.new("stressed").reverse.should be_an_instance_of(StringSpecs::MyString)
-      StringSpecs::MyString.new("m").reverse.should be_an_instance_of(StringSpecs::MyString)
-      StringSpecs::MyString.new("").reverse.should be_an_instance_of(StringSpecs::MyString)
-    end
+  it "returns String instances when called on a subclass" do
+    StringSpecs::MyString.new("stressed").reverse.should be_an_instance_of(String)
+    StringSpecs::MyString.new("m").reverse.should be_an_instance_of(String)
+    StringSpecs::MyString.new("").reverse.should be_an_instance_of(String)
   end
 
   it "reverses a string with multi byte characters" do
diff --git a/spec/ruby/core/string/rjust_spec.rb b/spec/ruby/core/string/rjust_spec.rb
index d067b7bdb3..fcbaf3b938 100644
--- a/spec/ruby/core/string/rjust_spec.rb
+++ b/spec/ruby/core/string/rjust_spec.rb
@@ -64,26 +64,13 @@ describe "String#rjust with length, padding" do
     -> { "hello".rjust(10, '') }.should raise_error(ArgumentError)
   end
 
-  ruby_version_is ''...'3.0' do
-    it "returns subclass instances when called on subclasses" do
-      StringSpecs::MyString.new("").rjust(10).should be_an_instance_of(StringSpecs::MyString)
-      StringSpecs::MyString.new("foo").rjust(10).should be_an_instance_of(StringSpecs::MyString)
-      StringSpecs::MyString.new("foo").rjust(10, StringSpecs::MyString.new("x")).should be_an_instance_of(StringSpecs::MyString)
-
-      "".rjust(10, StringSpecs::MyString.new("x")).should be_an_instance_of(String)
-      "foo".rjust(10, StringSpecs::MyString.new("x")).should be_an_instance_of(String)
-    end
-  end
+  it "returns String instances when called on subclasses" do
+    StringSpecs::MyString.new("").rjust(10).should be_an_instance_of(String)
+    StringSpecs::MyString.new("foo").rjust(10).should be_an_instance_of(String)
+    StringSpecs::MyString.new("foo").rjust(10, StringSpecs::MyString.new("x")).should be_an_instance_of(String)
 
-  ruby_version_is '3.0' do
-    it "returns String instances when called on subclasses" do
-      StringSpecs::MyString.new("").rjust(10).should be_an_instance_of(String)
-      StringSpecs::MyString.new("foo").rjust(10).should be_an_instance_of(String)
-      StringSpecs::MyString.new("foo").rjust(10, StringSpecs::MyString.new("x")).should be_an_instance_of(String)
-
-      "".rjust(10, StringSpecs::MyString.new("x")).should be_an_instance_of(String)
-      "foo".rjust(10, StringSpecs::MyString.new("x")).should be_an_instance_of(String)
-    end
+    "".rjust(10, StringSpecs::MyString.new("x")).should be_an_instance_of(String)
+    "foo".rjust(10, StringSpecs::MyString.new("x")).should be_an_instance_of(String)
   end
 
   describe "with width" do
diff --git a/spec/ruby/core/string/rstrip_spec.rb b/spec/ruby/core/string/rstrip_spec.rb
index e96ce4120f..e4cf93315e 100644
--- a/spec/ruby/core/string/rstrip_spec.rb
+++ b/spec/ruby/core/string/rstrip_spec.rb
@@ -51,12 +51,10 @@ describe "String#rstrip!" do
     "  ".rstrip.should == ""
   end
 
-  ruby_version_is '3.0' do
-    it "removes trailing NULL bytes and whitespace" do
-      a = "\000 goodbye \000"
-      a.rstrip!
-      a.should == "\000 goodbye"
-    end
+  it "removes trailing NULL bytes and whitespace" do
+    a = "\000 goodbye \000"
+    a.rstrip!
+    a.should == "\000 goodbye"
   end
 
   it "raises a FrozenError on a frozen instance that is modified" do
diff --git a/spec/ruby/core/string/scan_spec.rb b/spec/ruby/core/string/scan_spec.rb
index a2d1815132..70c3b7fb7b 100644
--- a/spec/ruby/core/string/scan_spec.rb
+++ b/spec/ruby/core/string/scan_spec.rb
@@ -165,11 +165,9 @@ describe "String#scan with pattern and block" do
     end
   end
 
-  ruby_version_is '3.0' do
-    it "yields String instances for subclasses" do
-      a = []
-      StringSpecs::MyString.new("abc").scan(/./) { |s| a << s.class }
-      a.should == [String, String, String]
-    end
+  it "yields String instances for subclasses" do
+    a = []
+    StringSpecs::MyString.new("abc").scan(/./) { |s| a << s.class }
+    a.should == [String, String, String]
   end
 end
diff --git a/spec/ruby/core/string/scrub_spec.rb b/spec/ruby/core/string/scrub_spec.rb
index a51fbd020a..bcee4db463 100644
--- a/spec/ruby/core/string/scrub_spec.rb
+++ b/spec/ruby/core/string/scrub_spec.rb
@@ -36,18 +36,10 @@ describe "String#scrub with a default replacement" do
     "abc\u3042#{x81}".scrub.encoding.should == Encoding::UTF_8
   end
 
-  ruby_version_is '3.0' do
-    it "returns String instances when called on a subclass" do
-      StringSpecs::MyString.new("foo").scrub.should be_an_instance_of(String)
-      input = [0x81].pack('C').force_encoding('utf-8')
-      StringSpecs::MyString.new(input).scrub.should be_an_instance_of(String)
-    end
-  end
-
-  ruby_version_is ''...'3.0' do
-    it "returns subclass instances when called on a subclass" do
-      StringSpecs::MyString.new("foo").scrub.should be_an_instance_of(StringSpecs::MyString)
-    end
+  it "returns String instances when called on a subclass" do
+    StringSpecs::MyString.new("foo").scrub.should be_an_instance_of(String)
+    input = [0x81].pack('C').force_encoding('utf-8')
+    StringSpecs::MyString.new(input).scrub.should be_an_instance_of(String)
   end
 end
 
@@ -97,12 +89,10 @@ describe "String#scrub with a custom replacement" do
     block.should raise_error(TypeError)
   end
 
-  ruby_version_is '3.0' do
-    it "returns String instances when called on a subclass" do
-      StringSpecs::MyString.new("foo").scrub("*").should be_an_instance_of(String)
-      input = [0x81].pack('C').force_encoding('utf-8')
-      StringSpecs::MyString.new(input).scrub("*").should be_an_instance_of(String)
-    end
+  it "returns String instances when called on a subclass" do
+    StringSpecs::MyString.new("foo").scrub("*").should be_an_instance_of(String)
+    input = [0x81].pack('C').force_encoding('utf-8')
+    StringSpecs::MyString.new(input).scrub("*").should be_an_instance_of(String)
   end
 end
 
@@ -129,12 +119,10 @@ describe "String#scrub with a block" do
     replaced.should == "€€"
   end
 
-  ruby_version_is '3.0' do
-    it "returns String instances when called on a subclass" do
-      StringSpecs::MyString.new("foo").scrub { |b| "*" }.should be_an_instance_of(String)
-      input = [0x81].pack('C').force_encoding('utf-8')
-      StringSpecs::MyString.new(input).scrub { |b| "<#{b.unpack("H*")[0]}>" }.should be_an_instance_of(String)
-    end
+  it "returns String instances when called on a subclass" do
+    StringSpecs::MyString.new("foo").scrub { |b| "*" }.should be_an_instance_of(String)
+    input = [0x81].pack('C').force_encoding('utf-8')
+    StringSpecs::MyString.new(input).scrub { |b| "<#{b.unpack("H*")[0]}>" }.should be_an_instance_of(String)
   end
 end
 
diff --git a/spec/ruby/core/string/shared/byte_index_common.rb b/spec/ruby/core/string/shared/byte_index_common.rb
new file mode 100644
index 0000000000..3de1453f4f
--- /dev/null
+++ b/spec/ruby/core/string/shared/byte_index_common.rb
@@ -0,0 +1,63 @@
+# -*- encoding: utf-8 -*-
+require_relative '../../../spec_helper'
+
+describe :byte_index_common, shared: true do
+  describe "raises on type errors" do
+    it "raises a TypeError if passed nil" do
+      -> { "abc".send(@method, nil) }.should raise_error(TypeError, "no implicit conversion of nil into String")
+    end
+
+    it "raises a TypeError if passed a boolean" do
+      -> { "abc".send(@method, true) }.should raise_error(TypeError, "no implicit conversion of true into String")
+    end
+
+    it "raises a TypeError if passed a Symbol" do
+      not_supported_on :opal do
+        -> { "abc".send(@method, :a) }.should raise_error(TypeError, "no implicit conversion of Symbol into String")
+      end
+    end
+
+    it "raises a TypeError if passed a Symbol" do
+      obj = mock('x')
+      obj.should_not_receive(:to_int)
+      -> { "hello".send(@method, obj) }.should raise_error(TypeError, "no implicit conversion of MockObject into String")
+    end
+
+    it "raises a TypeError if passed an Integer" do
+      -> { "abc".send(@method, 97) }.should raise_error(TypeError, "no implicit conversion of Integer into String")
+    end
+  end
+
+  describe "with multibyte codepoints" do
+    it "raises an IndexError when byte offset lands in the middle of a multibyte character" do
+      -> { "わ".send(@method, "", 1) }.should raise_error(IndexError, "offset 1 does not land on character boundary")
+      -> { "わ".send(@method, "", 2) }.should raise_error(IndexError, "offset 2 does not land on character boundary")
+      -> { "わ".send(@method, "", -1) }.should raise_error(IndexError, "offset 2 does not land on character boundary")
+      -> { "わ".send(@method, "", -2) }.should raise_error(IndexError, "offset 1 does not land on character boundary")
+    end
+
+    it "raises an Encoding::CompatibilityError if the encodings are incompatible" do
+      re = Regexp.new "れ".encode(Encoding::EUC_JP)
+      -> do
+        "あれ".send(@method, re)
+      end.should raise_error(Encoding::CompatibilityError, "incompatible encoding regexp match (EUC-JP regexp with UTF-8 string)")
+    end
+  end
+
+  describe "with global variables" do
+    it "doesn't set $~ for non regex search" do
+      $~ = nil
+
+      'hello.'.send(@method, 'll')
+      $~.should == nil
+    end
+
+    it "sets $~ to MatchData of match and nil when there's none" do
+      'hello.'.send(@method, /.e./)
+      $~[0].should == 'hel'
+
+      'hello.'.send(@method, /not/)
+      $~.should == nil
+    end
+  end
+end
diff --git a/spec/ruby/core/string/shared/dedup.rb b/spec/ruby/core/string/shared/dedup.rb
index 6ffcb9b045..893fd1e360 100644
--- a/spec/ruby/core/string/shared/dedup.rb
+++ b/spec/ruby/core/string/shared/dedup.rb
@@ -48,10 +48,8 @@ describe :string_dedup, shared: true do
     dynamic.send(@method).should equal(dynamic)
   end
 
-  ruby_version_is "3.0" do
-    it "interns the provided string if it is frozen" do
-      dynamic = "this string is unique and frozen #{rand}".freeze
-      dynamic.send(@method).should equal(dynamic)
-    end
+  it "interns the provided string if it is frozen" do
+    dynamic = "this string is unique and frozen #{rand}".freeze
+    dynamic.send(@method).should equal(dynamic)
   end
 end
diff --git a/spec/ruby/core/string/shared/each_line.rb b/spec/ruby/core/string/shared/each_line.rb
index df78bd2186..a14b4d7779 100644
--- a/spec/ruby/core/string/shared/each_line.rb
+++ b/spec/ruby/core/string/shared/each_line.rb
@@ -85,20 +85,10 @@ describe :string_each_line, shared: true do
     end
   end
 
-  ruby_version_is ''...'3.0' do
-    it "yields subclass instances for subclasses" do
-      a = []
-      StringSpecs::MyString.new("hello\nworld").send(@method) { |s| a << s.class }
-      a.should == [StringSpecs::MyString, StringSpecs::MyString]
-    end
-  end
-
-  ruby_version_is '3.0' do
-    it "yields String instances for subclasses" do
-      a = []
-      StringSpecs::MyString.new("hello\nworld").send(@method) { |s| a << s.class }
-      a.should == [String, String]
-    end
+  it "yields String instances for subclasses" do
+    a = []
+    StringSpecs::MyString.new("hello\nworld").send(@method) { |s| a << s.class }
+    a.should == [String, String]
   end
 
   it "returns self" do
diff --git a/spec/ruby/core/string/shared/partition.rb b/spec/ruby/core/string/shared/partition.rb
index 41b3c7e0c9..4cac149ce5 100644
--- a/spec/ruby/core/string/shared/partition.rb
+++ b/spec/ruby/core/string/shared/partition.rb
@@ -2,35 +2,17 @@ require_relative '../../../spec_helper'
 require_relative '../fixtures/classes'
 
 describe :string_partition, shared: true do
-  ruby_version_is '3.0' do
-    it "returns String instances when called on a subclass" do
-      StringSpecs::MyString.new("hello").send(@method, "l").each do |item|
-        item.should be_an_instance_of(String)
-      end
-
-      StringSpecs::MyString.new("hello").send(@method, "x").each do |item|
-        item.should be_an_instance_of(String)
-      end
-
-      StringSpecs::MyString.new("hello").send(@method, /l./).each do |item|
-        item.should be_an_instance_of(String)
-      end
+  it "returns String instances when called on a subclass" do
+    StringSpecs::MyString.new("hello").send(@method, "l").each do |item|
+      item.should be_an_instance_of(String)
     end
-  end
 
-  ruby_version_is ''...'3.0' do
-    it "returns subclass instances when called on a subclass" do
-      StringSpecs::MyString.new("hello").send(@method, StringSpecs::MyString.new("l")).each do |item|
-        item.should be_an_instance_of(StringSpecs::MyString)
-      end
-
-      StringSpecs::MyString.new("hello").send(@method, "x").each do |item|
-        item.should be_an_instance_of(StringSpecs::MyString)
-      end
+    StringSpecs::MyString.new("hello").send(@method, "x").each do |item|
+      item.should be_an_instance_of(String)
+    end
 
-      StringSpecs::MyString.new("hello").send(@method, /l./).each do |item|
-        item.should be_an_instance_of(StringSpecs::MyString)
-      end
+    StringSpecs::MyString.new("hello").send(@method, /l./).each do |item|
+      item.should be_an_instance_of(String)
     end
   end
 
diff --git a/spec/ruby/core/string/shared/slice.rb b/spec/ruby/core/string/shared/slice.rb
index a7c1d05b56..3ef4bc50d7 100644
--- a/spec/ruby/core/string/shared/slice.rb
+++ b/spec/ruby/core/string/shared/slice.rb
@@ -152,22 +152,11 @@ describe :string_slice_index_length, shared: true do
     -> { "hello".send(@method, 0, bignum_value) }.should raise_error(RangeError)
   end
 
-  ruby_version_is ''...'3.0' do
-    it "returns subclass instances" do
-      s = StringSpecs::MyString.new("hello")
-      s.send(@method, 0,0).should be_an_instance_of(StringSpecs::MyString)
-      s.send(@method, 0,4).should be_an_instance_of(StringSpecs::MyString)
-      s.send(@method, 1,4).should be_an_instance_of(StringSpecs::MyString)
-    end
-  end
-
-  ruby_version_is '3.0' do
-    it "returns String instances" do
-      s = StringSpecs::MyString.new("hello")
-      s.send(@method, 0,0).should be_an_instance_of(String)
-      s.send(@method, 0,4).should be_an_instance_of(String)
-      s.send(@method, 1,4).should be_an_instance_of(String)
-    end
+  it "returns String instances" do
+    s = StringSpecs::MyString.new("hello")
+    s.send(@method, 0,0).should be_an_instance_of(String)
+    s.send(@method, 0,4).should be_an_instance_of(String)
+    s.send(@method, 1,4).should be_an_instance_of(String)
   end
 
   it "handles repeated application" do
@@ -242,22 +231,11 @@ describe :string_slice_range, shared: true do
     "x".send(@method, 1...-1).should == ""
   end
 
-  ruby_version_is ''...'3.0' do
-    it "returns subclass instances" do
-      s = StringSpecs::MyString.new("hello")
-      s.send(@method, 0...0).should be_an_instance_of(StringSpecs::MyString)
-      s.send(@method, 0..4).should be_an_instance_of(StringSpecs::MyString)
-      s.send(@method, 1..4).should be_an_instance_of(StringSpecs::MyString)
-    end
-  end
-
-  ruby_version_is '3.0' do
-    it "returns String instances" do
-      s = StringSpecs::MyString.new("hello")
-      s.send(@method, 0...0).should be_an_instance_of(String)
-      s.send(@method, 0..4).should be_an_instance_of(String)
-      s.send(@method, 1..4).should be_an_instance_of(String)
-    end
+  it "returns String instances" do
+    s = StringSpecs::MyString.new("hello")
+    s.send(@method, 0...0).should be_an_instance_of(String)
+    s.send(@method, 0..4).should be_an_instance_of(String)
+    s.send(@method, 1..4).should be_an_instance_of(String)
   end
 
   it "calls to_int on range arguments" do
@@ -336,20 +314,10 @@ describe :string_slice_regexp, shared: true do
     "hello there".encode("US-ASCII").send(@method, /[aeiou](.)\1/).encoding.should == Encoding::US_ASCII
   end
 
-  ruby_version_is ''...'3.0' do
-    it "returns subclass instances" do
-      s = StringSpecs::MyString.new("hello")
-      s.send(@method, //).should be_an_instance_of(StringSpecs::MyString)
-      s.send(@method, /../).should be_an_instance_of(StringSpecs::MyString)
-    end
-  end
-
-  ruby_version_is '3.0' do
-    it "returns String instances" do
-      s = StringSpecs::MyString.new("hello")
-      s.send(@method, //).should be_an_instance_of(String)
-      s.send(@method, /../).should be_an_instance_of(String)
-    end
+  it "returns String instances" do
+    s = StringSpecs::MyString.new("hello")
+    s.send(@method, //).should be_an_instance_of(String)
+    s.send(@method, /../).should be_an_instance_of(String)
   end
 
   it "sets $~ to MatchData when there is a match and nil when there's none" do
@@ -418,20 +386,10 @@ describe :string_slice_regexp_index, shared: true do
     -> { "hello".send(@method, /(.)(.)(.)/, nil) }.should raise_error(TypeError)
   end
 
-  ruby_version_is ''...'3.0' do
-    it "returns subclass instances" do
-      s = StringSpecs::MyString.new("hello")
-      s.send(@method, /(.)(.)/, 0).should be_an_instance_of(StringSpecs::MyString)
-      s.send(@method, /(.)(.)/, 1).should be_an_instance_of(StringSpecs::MyString)
-    end
-  end
-
-  ruby_version_is '3.0' do
-    it "returns String instances" do
-      s = StringSpecs::MyString.new("hello")
-      s.send(@method, /(.)(.)/, 0).should be_an_instance_of(String)
-      s.send(@method, /(.)(.)/, 1).should be_an_instance_of(String)
-    end
+  it "returns String instances" do
+    s = StringSpecs::MyString.new("hello")
+    s.send(@method, /(.)(.)/, 0).should be_an_instance_of(String)
+    s.send(@method, /(.)(.)/, 1).should be_an_instance_of(String)
   end
 
   it "sets $~ to MatchData when there is a match and nil when there's none" do
@@ -470,22 +428,11 @@ describe :string_slice_string, shared: true do
     -> { "hello".send(@method, o) }.should raise_error(TypeError)
   end
 
-  ruby_version_is ''...'3.0' do
-    it "returns a subclass instance when given a subclass instance" do
-      s = StringSpecs::MyString.new("el")
-      r = "hello".send(@method, s)
-      r.should == "el"
-      r.should be_an_instance_of(StringSpecs::MyString)
-    end
-  end
-
-  ruby_version_is '3.0' do
-    it "returns a String instance when given a subclass instance" do
-      s = StringSpecs::MyString.new("el")
-      r = "hello".send(@method, s)
-      r.should == "el"
-      r.should be_an_instance_of(String)
-    end
+  it "returns a String instance when given a subclass instance" do
+    s = StringSpecs::MyString.new("el")
+    r = "hello".send(@method, s)
+    r.should == "el"
+    r.should be_an_instance_of(String)
   end
 end
 
@@ -531,18 +478,9 @@ describe :string_slice_regexp_group, shared: true do
       -> { "hello".send(@method, /(?<q>)/, '') }.should raise_error(IndexError)
     end
 
-    ruby_version_is ''...'3.0' do
-      it "returns subclass instances" do
-        s = StringSpecs::MyString.new("hello")
-        s.send(@method, /(?<q>.)/, 'q').should be_an_instance_of(StringSpecs::MyString)
-      end
-    end
-
-    ruby_version_is '3.0' do
-      it "returns String instances" do
-        s = StringSpecs::MyString.new("hello")
-        s.send(@method, /(?<q>.)/, 'q').should be_an_instance_of(String)
-      end
+    it "returns String instances" do
+      s = StringSpecs::MyString.new("hello")
+      s.send(@method, /(?<q>.)/, 'q').should be_an_instance_of(String)
     end
 
     it "sets $~ to MatchData when there is a match and nil when there's none" do
diff --git a/spec/ruby/core/string/shared/strip.rb b/spec/ruby/core/string/shared/strip.rb
index 0c0aae20f3..3af77b50fe 100644
--- a/spec/ruby/core/string/shared/strip.rb
+++ b/spec/ruby/core/string/shared/strip.rb
@@ -6,19 +6,9 @@ describe :string_strip, shared: true do
     " hello ".encode("US-ASCII").send(@method).encoding.should == Encoding::US_ASCII
   end
 
-  ruby_version_is '3.0' do
-    it "returns String instances when called on a subclass" do
-      StringSpecs::MyString.new(" hello ").send(@method).should be_an_instance_of(String)
-      StringSpecs::MyString.new(" ").send(@method).should be_an_instance_of(String)
-      StringSpecs::MyString.new("").send(@method).should be_an_instance_of(String)
-    end
-  end
-
-  ruby_version_is ''...'3.0' do
-    it "returns subclass instances when called on a subclass" do
-      StringSpecs::MyString.new(" hello ").send(@method).should be_an_instance_of(StringSpecs::MyString)
-      StringSpecs::MyString.new(" ").send(@method).should be_an_instance_of(StringSpecs::MyString)
-      StringSpecs::MyString.new("").send(@method).should be_an_instance_of(StringSpecs::MyString)
-    end
+  it "returns String instances when called on a subclass" do
+    StringSpecs::MyString.new(" hello ").send(@method).should be_an_instance_of(String)
+    StringSpecs::MyString.new(" ").send(@method).should be_an_instance_of(String)
+    StringSpecs::MyString.new("").send(@method).should be_an_instance_of(String)
   end
 end
diff --git a/spec/ruby/core/string/shared/succ.rb b/spec/ruby/core/string/shared/succ.rb
index 3605fa99a2..24a729ce26 100644
--- a/spec/ruby/core/string/shared/succ.rb
+++ b/spec/ruby/core/string/shared/succ.rb
@@ -59,20 +59,10 @@ describe :string_succ, shared: true do
     "\xFF\xFF".send(@method).should == "\x01\x00\x00"
   end
 
-  ruby_version_is ''...'3.0' do
-    it "returns subclass instances when called on a subclass" do
-      StringSpecs::MyString.new("").send(@method).should be_an_instance_of(StringSpecs::MyString)
-      StringSpecs::MyString.new("a").send(@method).should be_an_instance_of(StringSpecs::MyString)
-      StringSpecs::MyString.new("z").send(@method).should be_an_instance_of(StringSpecs::MyString)
-    end
-  end
-
-  ruby_version_is '3.0' do
-    it "returns String instances when called on a subclass" do
-      StringSpecs::MyString.new("").send(@method).should be_an_instance_of(String)
-      StringSpecs::MyString.new("a").send(@method).should be_an_instance_of(String)
-      StringSpecs::MyString.new("z").send(@method).should be_an_instance_of(String)
-    end
+  it "returns String instances when called on a subclass" do
+    StringSpecs::MyString.new("").send(@method).should be_an_instance_of(String)
+    StringSpecs::MyString.new("a").send(@method).should be_an_instance_of(String)
+    StringSpecs::MyString.new("z").send(@method).should be_an_instance_of(String)
   end
 
   it "returns a String in the same encoding as self" do
diff --git a/spec/ruby/core/string/shared/to_a.rb b/spec/ruby/core/string/shared/to_a.rb
deleted file mode 100644
index bad3ea6584..0000000000
--- a/spec/ruby/core/string/shared/to_a.rb
+++ /dev/null
@@ -1,9 +0,0 @@
-describe :string_to_a, shared: true do
-  it "returns an empty array for empty strings" do
-    "".send(@method).should == []
-  end
-
-  it "returns an array containing the string for non-empty strings" do
-    "hello".send(@method).should == ["hello"]
-  end
-end
diff --git a/spec/ruby/core/string/slice_spec.rb b/spec/ruby/core/string/slice_spec.rb
index c9e13ed1bc..87c5a7ac37 100644
--- a/spec/ruby/core/string/slice_spec.rb
+++ b/spec/ruby/core/string/slice_spec.rb
@@ -132,20 +132,10 @@ describe "String#slice! with index, length" do
     "hello".slice!(obj, obj).should == "ll"
   end
 
-  ruby_version_is ''...'3.0' do
-    it "returns subclass instances" do
-      s = StringSpecs::MyString.new("hello")
-      s.slice!(0, 0).should be_an_instance_of(StringSpecs::MyString)
-      s.slice!(0, 4).should be_an_instance_of(StringSpecs::MyString)
-    end
-  end
-
-  ruby_version_is '3.0' do
-    it "returns String instances" do
-      s = StringSpecs::MyString.new("hello")
-      s.slice!(0, 0).should be_an_instance_of(String)
-      s.slice!(0, 4).should be_an_instance_of(String)
-    end
+  it "returns String instances" do
+    s = StringSpecs::MyString.new("hello")
+    s.slice!(0, 0).should be_an_instance_of(String)
+    s.slice!(0, 4).should be_an_instance_of(String)
   end
 
   it "returns the substring given by the character offsets" do
@@ -185,20 +175,10 @@ describe "String#slice! Range" do
     b.should == "hello"
   end
 
-  ruby_version_is ''...'3.0' do
-    it "returns subclass instances" do
-      s = StringSpecs::MyString.new("hello")
-      s.slice!(0...0).should be_an_instance_of(StringSpecs::MyString)
-      s.slice!(0..4).should be_an_instance_of(StringSpecs::MyString)
-    end
-  end
-
-  ruby_version_is '3.0' do
-    it "returns String instances" do
-      s = StringSpecs::MyString.new("hello")
-      s.slice!(0...0).should be_an_instance_of(String)
-      s.slice!(0..4).should be_an_instance_of(String)
-    end
+  it "returns String instances" do
+    s = StringSpecs::MyString.new("hello")
+    s.slice!(0...0).should be_an_instance_of(String)
+    s.slice!(0..4).should be_an_instance_of(String)
   end
 
   it "calls to_int on range arguments" do
@@ -274,20 +254,10 @@ describe "String#slice! with Regexp" do
     s.should == "this is a string"
   end
 
-  ruby_version_is ''...'3.0' do
-    it "returns subclass instances" do
-      s = StringSpecs::MyString.new("hello")
-      s.slice!(//).should be_an_instance_of(StringSpecs::MyString)
-      s.slice!(/../).should be_an_instance_of(StringSpecs::MyString)
-    end
-  end
-
-  ruby_version_is '3.0' do
-    it "returns String instances" do
-      s = StringSpecs::MyString.new("hello")
-      s.slice!(//).should be_an_instance_of(String)
-      s.slice!(/../).should be_an_instance_of(String)
-    end
+  it "returns String instances" do
+    s = StringSpecs::MyString.new("hello")
+    s.slice!(//).should be_an_instance_of(String)
+    s.slice!(/../).should be_an_instance_of(String)
   end
 
   it "returns the matching portion of self with a multi byte character" do
@@ -344,20 +314,10 @@ describe "String#slice! with Regexp, index" do
     "har".slice!(/(.)(.)(.)/, obj).should == "a"
   end
 
-  ruby_version_is ''...'3.0' do
-    it "returns subclass instances" do
-      s = StringSpecs::MyString.new("hello")
-      s.slice!(/(.)(.)/, 0).should be_an_instance_of(StringSpecs::MyString)
-      s.slice!(/(.)(.)/, 1).should be_an_instance_of(StringSpecs::MyString)
-    end
-  end
-
-  ruby_version_is '3.0' do
-    it "returns String instances" do
-      s = StringSpecs::MyString.new("hello")
-      s.slice!(/(.)(.)/, 0).should be_an_instance_of(String)
-      s.slice!(/(.)(.)/, 1).should be_an_instance_of(String)
-    end
+  it "returns String instances" do
+    s = StringSpecs::MyString.new("hello")
+    s.slice!(/(.)(.)/, 0).should be_an_instance_of(String)
+    s.slice!(/(.)(.)/, 1).should be_an_instance_of(String)
   end
 
   it "returns the encoding aware capture for the given index" do
@@ -415,22 +375,11 @@ describe "String#slice! with String" do
     -> { "hello".slice!(o) }.should raise_error(TypeError)
   end
 
-  ruby_version_is ''...'3.0' do
-    it "returns a subclass instance when given a subclass instance" do
-      s = StringSpecs::MyString.new("el")
-      r = "hello".slice!(s)
-      r.should == "el"
-      r.should be_an_instance_of(StringSpecs::MyString)
-    end
-  end
-
-  ruby_version_is '3.0' do
-    it "returns a subclass instance when given a subclass instance" do
-      s = StringSpecs::MyString.new("el")
-      r = "hello".slice!(s)
-      r.should == "el"
-      r.should be_an_instance_of(String)
-    end
+  it "returns a subclass instance when given a subclass instance" do
+    s = StringSpecs::MyString.new("el")
+    r = "hello".slice!(s)
+    r.should == "el"
+    r.should be_an_instance_of(String)
   end
 
   it "raises a FrozenError if self is frozen" do
diff --git a/spec/ruby/core/string/split_spec.rb b/spec/ruby/core/string/split_spec.rb
index 519c5d845d..c5cca651c2 100644
--- a/spec/ruby/core/string/split_spec.rb
+++ b/spec/ruby/core/string/split_spec.rb
@@ -192,44 +192,16 @@ describe "String#split with String" do
     "foo".split("bar", 3).should == ["foo"]
   end
 
-  ruby_version_is ''...'3.0' do
-    it "returns subclass instances based on self" do
-      ["", "x.y.z.", "  x  y  "].each do |str|
-        ["", ".", " "].each do |pat|
-          [-1, 0, 1, 2].each do |limit|
-            StringSpecs::MyString.new(str).split(pat, limit).each do |x|
-              x.should be_an_instance_of(StringSpecs::MyString)
-            end
-
-            str.split(StringSpecs::MyString.new(pat), limit).each do |x|
-              x.should be_an_instance_of(String)
-            end
+  it "returns String instances based on self" do
+    ["", "x.y.z.", "  x  y  "].each do |str|
+      ["", ".", " "].each do |pat|
+        [-1, 0, 1, 2].each do |limit|
+          StringSpecs::MyString.new(str).split(pat, limit).each do |x|
+            x.should be_an_instance_of(String)
           end
-        end
-      end
-    end
-
-    it "does not call constructor on created subclass instances" do
-      # can't call should_not_receive on an object that doesn't yet exist
-      # so failure here is signalled by exception, not expectation failure
-
-      s = StringSpecs::StringWithRaisingConstructor.new('silly:string')
-      s.split(':').first.should == 'silly'
-    end
-  end
-
-  ruby_version_is '3.0' do
-    it "returns String instances based on self" do
-      ["", "x.y.z.", "  x  y  "].each do |str|
-        ["", ".", " "].each do |pat|
-          [-1, 0, 1, 2].each do |limit|
-            StringSpecs::MyString.new(str).split(pat, limit).each do |x|
-              x.should be_an_instance_of(String)
-            end
 
-            str.split(StringSpecs::MyString.new(pat), limit).each do |x|
-              x.should be_an_instance_of(String)
-            end
+          str.split(StringSpecs::MyString.new(pat), limit).each do |x|
+            x.should be_an_instance_of(String)
           end
         end
       end
@@ -414,36 +386,12 @@ describe "String#split with Regexp" do
     "foo".split(/bar/, 3).should == ["foo"]
   end
 
-  ruby_version_is ''...'3.0' do
-    it "returns subclass instances based on self" do
-      ["", "x:y:z:", "  x  y  "].each do |str|
-        [//, /:/, /\s+/].each do |pat|
-          [-1, 0, 1, 2].each do |limit|
-            StringSpecs::MyString.new(str).split(pat, limit).each do |x|
-              x.should be_an_instance_of(StringSpecs::MyString)
-            end
-          end
-        end
-      end
-    end
-
-    it "does not call constructor on created subclass instances" do
-      # can't call should_not_receive on an object that doesn't yet exist
-      # so failure here is signalled by exception, not expectation failure
-
-      s = StringSpecs::StringWithRaisingConstructor.new('silly:string')
-      s.split(/:/).first.should == 'silly'
-    end
-  end
-
-  ruby_version_is '3.0' do
-    it "returns String instances based on self" do
-      ["", "x:y:z:", "  x  y  "].each do |str|
-        [//, /:/, /\s+/].each do |pat|
-          [-1, 0, 1, 2].each do |limit|
-            StringSpecs::MyString.new(str).split(pat, limit).each do |x|
-              x.should be_an_instance_of(String)
-            end
+  it "returns String instances based on self" do
+    ["", "x:y:z:", "  x  y  "].each do |str|
+      [//, /:/, /\s+/].each do |pat|
+        [-1, 0, 1, 2].each do |limit|
+          StringSpecs::MyString.new(str).split(pat, limit).each do |x|
+            x.should be_an_instance_of(String)
           end
         end
       end
@@ -569,32 +517,16 @@ describe "String#split with Regexp" do
   end
 
   describe "for a String subclass" do
-    ruby_version_is ''...'3.0' do
-      it "yields instances of the same subclass" do
-        a = []
-        StringSpecs::MyString.new("a|b").split("|") { |str| a << str }
-        first, last = a
-
-        first.should be_an_instance_of(StringSpecs::MyString)
-        first.should == "a"
-
-        last.should be_an_instance_of(StringSpecs::MyString)
-        last.should == "b"
-      end
-    end
-
-    ruby_version_is '3.0' do
-      it "yields instances of String" do
-        a = []
-        StringSpecs::MyString.new("a|b").split("|") { |str| a << str }
-        first, last = a
+    it "yields instances of String" do
+      a = []
+      StringSpecs::MyString.new("a|b").split("|") { |str| a << str }
+      first, last = a
 
-        first.should be_an_instance_of(String)
-        first.should == "a"
+      first.should be_an_instance_of(String)
+      first.should == "a"
 
-        last.should be_an_instance_of(String)
-        last.should == "b"
-      end
+      last.should be_an_instance_of(String)
+      last.should == "b"
     end
   end
 
diff --git a/spec/ruby/core/string/squeeze_spec.rb b/spec/ruby/core/string/squeeze_spec.rb
index 2f3fa65745..4796a170f2 100644
--- a/spec/ruby/core/string/squeeze_spec.rb
+++ b/spec/ruby/core/string/squeeze_spec.rb
@@ -75,16 +75,8 @@ describe "String#squeeze" do
     -> { "hello world".squeeze(mock('x')) }.should raise_error(TypeError)
   end
 
-  ruby_version_is ''...'3.0' do
-    it "returns subclass instances when called on a subclass" do
-      StringSpecs::MyString.new("oh no!!!").squeeze("!").should be_an_instance_of(StringSpecs::MyString)
-    end
-  end
-
-  ruby_version_is '3.0' do
-    it "returns String instances when called on a subclass" do
-      StringSpecs::MyString.new("oh no!!!").squeeze("!").should be_an_instance_of(String)
-    end
+  it "returns String instances when called on a subclass" do
+    StringSpecs::MyString.new("oh no!!!").squeeze("!").should be_an_instance_of(String)
   end
 end
 
diff --git a/spec/ruby/core/string/strip_spec.rb b/spec/ruby/core/string/strip_spec.rb
index 662f13b032..5e90fe35d0 100644
--- a/spec/ruby/core/string/strip_spec.rb
+++ b/spec/ruby/core/string/strip_spec.rb
@@ -11,10 +11,8 @@ describe "String#strip" do
     "\tgoodbye\r\v\n".strip.should == "goodbye"
   end
 
-  ruby_version_is '3.0' do
-    it "returns a copy of self without leading and trailing NULL bytes and whitespace" do
-      " \x00 goodbye \x00 ".strip.should == "goodbye"
-    end
+  it "returns a copy of self without leading and trailing NULL bytes and whitespace" do
+    " \x00 goodbye \x00 ".strip.should == "goodbye"
   end
 end
 
@@ -41,12 +39,10 @@ describe "String#strip!" do
     "  ".strip.should == ""
   end
 
-  ruby_version_is '3.0' do
-    it "removes leading and trailing NULL bytes and whitespace" do
-      a = "\000 goodbye \000"
-      a.strip!
-      a.should == "goodbye"
-    end
+  it "removes leading and trailing NULL bytes and whitespace" do
+    a = "\000 goodbye \000"
+    a.strip!
+    a.should == "goodbye"
   end
 
   it "raises a FrozenError on a frozen instance that is modified" do
diff --git a/spec/ruby/core/string/sub_spec.rb b/spec/ruby/core/string/sub_spec.rb
index 99dd7b45a8..51920486f5 100644
--- a/spec/ruby/core/string/sub_spec.rb
+++ b/spec/ruby/core/string/sub_spec.rb
@@ -170,22 +170,11 @@ describe "String#sub with pattern, replacement" do
     -> { "hello".sub(/[aeiou]/, 99) }.should raise_error(TypeError)
   end
 
-  ruby_version_is ''...'3.0' do
-    it "returns subclass instances when called on a subclass" do
-      StringSpecs::MyString.new("").sub(//, "").should be_an_instance_of(StringSpecs::MyString)
-      StringSpecs::MyString.new("").sub(/foo/, "").should be_an_instance_of(StringSpecs::MyString)
-      StringSpecs::MyString.new("foo").sub(/foo/, "").should be_an_instance_of(StringSpecs::MyString)
-      StringSpecs::MyString.new("foo").sub("foo", "").should be_an_instance_of(StringSpecs::MyString)
-    end
-  end
-
-  ruby_version_is '3.0' do
-    it "returns String instances when called on a subclass" do
-      StringSpecs::MyString.new("").sub(//, "").should be_an_instance_of(String)
-      StringSpecs::MyString.new("").sub(/foo/, "").should be_an_instance_of(String)
-      StringSpecs::MyString.new("foo").sub(/foo/, "").should be_an_instance_of(String)
-      StringSpecs::MyString.new("foo").sub("foo", "").should be_an_instance_of(String)
-    end
+  it "returns String instances when called on a subclass" do
+    StringSpecs::MyString.new("").sub(//, "").should be_an_instance_of(String)
+    StringSpecs::MyString.new("").sub(/foo/, "").should be_an_instance_of(String)
+    StringSpecs::MyString.new("foo").sub(/foo/, "").should be_an_instance_of(String)
+    StringSpecs::MyString.new("foo").sub("foo", "").should be_an_instance_of(String)
   end
 
   it "sets $~ to MatchData of match and nil when there's none" do
diff --git a/spec/ruby/core/string/swapcase_spec.rb b/spec/ruby/core/string/swapcase_spec.rb
index d369ab3e4e..d740fb86c6 100644
--- a/spec/ruby/core/string/swapcase_spec.rb
+++ b/spec/ruby/core/string/swapcase_spec.rb
@@ -74,18 +74,9 @@ describe "String#swapcase" do
     -> { "abc".swapcase(:invalid_option) }.should raise_error(ArgumentError)
   end
 
-  ruby_version_is ''...'3.0' do
-    it "returns subclass instances when called on a subclass" do
-      StringSpecs::MyString.new("").swapcase.should be_an_instance_of(StringSpecs::MyString)
-      StringSpecs::MyString.new("hello").swapcase.should be_an_instance_of(StringSpecs::MyString)
-    end
-  end
-
-  ruby_version_is '3.0' do
-    it "returns String instances when called on a subclass" do
-      StringSpecs::MyString.new("").swapcase.should be_an_instance_of(String)
-      StringSpecs::MyString.new("hello").swapcase.should be_an_instance_of(String)
-    end
+  it "returns String instances when called on a subclass" do
+    StringSpecs::MyString.new("").swapcase.should be_an_instance_of(String)
+    StringSpecs::MyString.new("hello").swapcase.should be_an_instance_of(String)
   end
 end
 
diff --git a/spec/ruby/core/string/tr_s_spec.rb b/spec/ruby/core/string/tr_s_spec.rb
index e1bb20ce35..b5c87d4e4e 100644
--- a/spec/ruby/core/string/tr_s_spec.rb
+++ b/spec/ruby/core/string/tr_s_spec.rb
@@ -45,16 +45,8 @@ describe "String#tr_s" do
     "bla".tr_s(from_str, to_str).should == "BlA"
   end
 
-  ruby_version_is ''...'3.0' do
-    it "returns subclass instances when called on a subclass" do
-      StringSpecs::MyString.new("hello").tr_s("e", "a").should be_an_instance_of(StringSpecs::MyString)
-    end
-  end
-
-  ruby_version_is '3.0' do
-    it "returns String instances when called on a subclass" do
-      StringSpecs::MyString.new("hello").tr_s("e", "a").should be_an_instance_of(String)
-    end
+  it "returns String instances when called on a subclass" do
+    StringSpecs::MyString.new("hello").tr_s("e", "a").should be_an_instance_of(String)
   end
 
   # http://redmine.ruby-lang.org/issues/show/1839
diff --git a/spec/ruby/core/string/tr_spec.rb b/spec/ruby/core/string/tr_spec.rb
index 72adb9f2eb..cf485d32a3 100644
--- a/spec/ruby/core/string/tr_spec.rb
+++ b/spec/ruby/core/string/tr_spec.rb
@@ -57,16 +57,8 @@ describe "String#tr" do
     "bla".tr(from_str, to_str).should == "BlA"
   end
 
-  ruby_version_is ''...'3.0' do
-    it "returns subclass instances when called on a subclass" do
-      StringSpecs::MyString.new("hello").tr("e", "a").should be_an_instance_of(StringSpecs::MyString)
-    end
-  end
-
-  ruby_version_is '3.0' do
-    it "returns Stringinstances when called on a subclass" do
-      StringSpecs::MyString.new("hello").tr("e", "a").should be_an_instance_of(String)
-    end
+  it "returns Stringinstances when called on a subclass" do
+    StringSpecs::MyString.new("hello").tr("e", "a").should be_an_instance_of(String)
   end
 
   # http://redmine.ruby-lang.org/issues/show/1839
diff --git a/spec/ruby/core/string/upcase_spec.rb b/spec/ruby/core/string/upcase_spec.rb
index 5ce7b0b95f..a2e34f5f40 100644
--- a/spec/ruby/core/string/upcase_spec.rb
+++ b/spec/ruby/core/string/upcase_spec.rb
@@ -73,16 +73,8 @@ describe "String#upcase" do
     -> { "abc".upcase(:invalid_option) }.should raise_error(ArgumentError)
   end
 
-  ruby_version_is ''...'3.0' do
-    it "returns a subclass instance for subclasses" do
-      StringSpecs::MyString.new("fooBAR").upcase.should be_an_instance_of(StringSpecs::MyString)
-    end
-  end
-
-  ruby_version_is '3.0' do
-    it "returns a String instance for subclasses" do
-      StringSpecs::MyString.new("fooBAR").upcase.should be_an_instance_of(String)
-    end
+  it "returns a String instance for subclasses" do
+    StringSpecs::MyString.new("fooBAR").upcase.should be_an_instance_of(String)
   end
 end
 
diff --git a/spec/ruby/core/string/valid_encoding_spec.rb b/spec/ruby/core/string/valid_encoding_spec.rb
index be7cef7a8e..bb26062c0f 100644
--- a/spec/ruby/core/string/valid_encoding_spec.rb
+++ b/spec/ruby/core/string/valid_encoding_spec.rb
@@ -100,12 +100,10 @@ describe "String#valid_encoding?" do
     str.force_encoding('UTF8-MAC').valid_encoding?.should be_true
   end
 
-  ruby_version_is '3.0' do
-    it "returns true for IBM720 encoding self is valid in" do
-      str = "\xE6\x9D\x94"
-      str.force_encoding('IBM720').valid_encoding?.should be_true
-      str.force_encoding('CP720').valid_encoding?.should be_true
-    end
+  it "returns true for IBM720 encoding self is valid in" do
+    str = "\xE6\x9D\x94"
+    str.force_encoding('IBM720').valid_encoding?.should be_true
+    str.force_encoding('CP720').valid_encoding?.should be_true
   end
 
   it "returns false if self is valid in one encoding, but invalid in the one it's tagged with" do
diff --git a/spec/ruby/core/symbol/name_spec.rb b/spec/ruby/core/symbol/name_spec.rb
index 15b9aa75e9..f9b631266c 100644
--- a/spec/ruby/core/symbol/name_spec.rb
+++ b/spec/ruby/core/symbol/name_spec.rb
@@ -1,19 +1,17 @@
 require_relative '../../spec_helper'
 
-ruby_version_is "3.0" do
-  describe "Symbol#name" do
-    it "returns string" do
-      :ruby.name.should == "ruby"
-      :ルビー.name.should == "ルビー"
-    end
+describe "Symbol#name" do
+  it "returns string" do
+    :ruby.name.should == "ruby"
+    :ルビー.name.should == "ルビー"
+  end
 
-    it "returns same string instance" do
-      :"ruby_3".name.should.equal?(:ruby_3.name)
-      :"ruby_#{1+2}".name.should.equal?(:ruby_3.name)
-    end
+  it "returns same string instance" do
+    :"ruby_3".name.should.equal?(:ruby_3.name)
+    :"ruby_#{1+2}".name.should.equal?(:ruby_3.name)
+  end
 
-    it "returns frozen string" do
-      :symbol.name.should.frozen?
-    end
+  it "returns frozen string" do
+    :symbol.name.should.frozen?
   end
 end
diff --git a/spec/ruby/core/symbol/to_proc_spec.rb b/spec/ruby/core/symbol/to_proc_spec.rb
index 6d9c4bc622..2cd013696a 100644
--- a/spec/ruby/core/symbol/to_proc_spec.rb
+++ b/spec/ruby/core/symbol/to_proc_spec.rb
@@ -12,38 +12,19 @@ describe "Symbol#to_proc" do
     :to_s.to_proc.call(obj).should == "Received #to_s"
   end
 
-  ruby_version_is ""..."3.0" do
-    it "returns a Proc with #lambda? false" do
-      pr = :to_s.to_proc
-      pr.should_not.lambda?
-    end
-
-    it "produces a Proc with arity -1" do
-      pr = :to_s.to_proc
-      pr.arity.should == -1
-    end
-
-    it "produces a Proc that always returns [[:rest]] for #parameters" do
-      pr = :to_s.to_proc
-      pr.parameters.should == [[:rest]]
-    end
+  it "returns a Proc with #lambda? true" do
+    pr = :to_s.to_proc
+    pr.should.lambda?
   end
 
-  ruby_version_is "3.0" do
-    it "returns a Proc with #lambda? true" do
-      pr = :to_s.to_proc
-      pr.should.lambda?
-    end
-
-    it "produces a Proc with arity -2" do
-      pr = :to_s.to_proc
-      pr.arity.should == -2
-    end
+  it "produces a Proc with arity -2" do
+    pr = :to_s.to_proc
+    pr.arity.should == -2
+  end
 
-    it "produces a Proc that always returns [[:req], [:rest]] for #parameters" do
-      pr = :to_s.to_proc
-      pr.parameters.should == [[:req], [:rest]]
-    end
+  it "produces a Proc that always returns [[:req], [:rest]] for #parameters" do
+    pr = :to_s.to_proc
+    pr.parameters.should == [[:req], [:rest]]
   end
 
   ruby_version_is "3.2" do
diff --git a/spec/ruby/core/thread/each_caller_location_spec.rb b/spec/ruby/core/thread/each_caller_location_spec.rb
new file mode 100644
index 0000000000..dbece06cd8
--- /dev/null
+++ b/spec/ruby/core/thread/each_caller_location_spec.rb
@@ -0,0 +1,49 @@
+require_relative '../../spec_helper'
+
+describe "Thread.each_caller_location" do
+  ruby_version_is "3.2" do
+    it "iterates through the current execution stack and matches caller_locations content and type" do
+      ScratchPad.record []
+      Thread.each_caller_location { |l| ScratchPad << l; }
+
+      ScratchPad.recorded.map(&:to_s).should == caller_locations.map(&:to_s)
+      ScratchPad.recorded[0].should be_kind_of(Thread::Backtrace::Location)
+    end
+
+    it "returns subset of 'Thread.to_enum(:each_caller_location)' locations" do
+      ar = []
+      ecl = Thread.each_caller_location { |x| ar << x }
+
+      (ar.map(&:to_s) - Thread.to_enum(:each_caller_location).to_a.map(&:to_s)).should.empty?
+    end
+
+    it "stops the backtrace iteration if 'break' occurs" do
+      i = 0
+      ar = []
+      ecl = Thread.each_caller_location do |x|
+        ar << x
+        i += 1
+        break x if i == 2
+      end
+
+      ar.map(&:to_s).should == caller_locations(1, 2).map(&:to_s)
+      ecl.should be_kind_of(Thread::Backtrace::Location)
+    end
+
+    it "returns nil" do
+      Thread.each_caller_location {}.should == nil
+    end
+
+    it "raises LocalJumpError when called without a block" do
+      -> {
+        Thread.each_caller_location
+      }.should raise_error(LocalJumpError, "no block given")
+    end
+
+    it "doesn't accept positional and keyword arguments" do
+      -> {
+        Thread.each_caller_location(12, foo: 10) {}
+      }.should raise_error(ArgumentError, "wrong number of arguments (given 2, expected 0)")
+    end
+  end
+end
diff --git a/spec/ruby/core/thread/exclusive_spec.rb b/spec/ruby/core/thread/exclusive_spec.rb
deleted file mode 100644
index 37c4b19d1a..0000000000
--- a/spec/ruby/core/thread/exclusive_spec.rb
+++ /dev/null
@@ -1,49 +0,0 @@
-require_relative '../../spec_helper'
-
-ruby_version_is ''...'3.0' do
-  describe "Thread.exclusive" do
-    before :each do
-      ScratchPad.clear
-      $VERBOSE, @verbose = nil, $VERBOSE
-    end
-
-    after :each do
-      $VERBOSE = @verbose
-    end
-
-    it "yields to the block" do
-      Thread.exclusive { ScratchPad.record true }
-      ScratchPad.recorded.should == true
-    end
-
-    it "returns the result of yielding" do
-      Thread.exclusive { :result }.should == :result
-    end
-
-    it "blocks the caller if another thread is also in an exclusive block" do
-      m = Mutex.new
-      q1 = Queue.new
-      q2 = Queue.new
-
-      t = Thread.new {
-        Thread.exclusive {
-          q1.push :ready
-          q2.pop
-        }
-      }
-
-      q1.pop.should == :ready
-
-      -> { Thread.exclusive { } }.should block_caller
-
-      q2.push :done
-      t.join
-    end
-
-    it "is not recursive" do
-      Thread.exclusive do
-        -> { Thread.exclusive { } }.should raise_error(ThreadError)
-      end
-    end
-  end
-end
diff --git a/spec/ruby/core/thread/ignore_deadlock_spec.rb b/spec/ruby/core/thread/ignore_deadlock_spec.rb
index 53cc2a7f5b..b48bc9f9b0 100644
--- a/spec/ruby/core/thread/ignore_deadlock_spec.rb
+++ b/spec/ruby/core/thread/ignore_deadlock_spec.rb
@@ -1,21 +1,19 @@
 require_relative '../../spec_helper'
 
-ruby_version_is "3.0" do
-  describe "Thread.ignore_deadlock" do
-    it "returns false by default" do
-      Thread.ignore_deadlock.should == false
-    end
+describe "Thread.ignore_deadlock" do
+  it "returns false by default" do
+    Thread.ignore_deadlock.should == false
   end
+end
 
-  describe "Thread.ignore_deadlock=" do
-    it "changes the value of Thread.ignore_deadlock" do
-      ignore_deadlock = Thread.ignore_deadlock
-      Thread.ignore_deadlock = true
-      begin
-        Thread.ignore_deadlock.should == true
-      ensure
-        Thread.ignore_deadlock = ignore_deadlock
-      end
+describe "Thread.ignore_deadlock=" do
+  it "changes the value of Thread.ignore_deadlock" do
+    ignore_deadlock = Thread.ignore_deadlock
+    Thread.ignore_deadlock = true
+    begin
+      Thread.ignore_deadlock.should == true
+    ensure
+      Thread.ignore_deadlock = ignore_deadlock
     end
   end
 end
diff --git a/spec/ruby/core/thread/report_on_exception_spec.rb b/spec/ruby/core/thread/report_on_exception_spec.rb
index 9279fa1da5..ab0af0972e 100644
--- a/spec/ruby/core/thread/report_on_exception_spec.rb
+++ b/spec/ruby/core/thread/report_on_exception_spec.rb
@@ -61,34 +61,32 @@ describe "Thread#report_on_exception=" do
       }.should raise_error(RuntimeError, "Thread#report_on_exception specs")
     end
 
-    ruby_version_is "3.0" do
-      it "prints a backtrace on $stderr in the regular backtrace order" do
-        line_raise = __LINE__ + 2
-        def foo
-          raise RuntimeError, "Thread#report_on_exception specs backtrace order"
-        end
-
-        line_call_foo = __LINE__ + 5
-        go = false
-        t = Thread.new {
-          Thread.current.report_on_exception = true
-          Thread.pass until go
-          foo
-        }
+    it "prints a backtrace on $stderr in the regular backtrace order" do
+      line_raise = __LINE__ + 2
+      def foo
+        raise RuntimeError, "Thread#report_on_exception specs backtrace order"
+      end
 
-        -> {
-          go = true
-          Thread.pass while t.alive?
-        }.should output("", <<ERR)
+      line_call_foo = __LINE__ + 5
+      go = false
+      t = Thread.new {
+        Thread.current.report_on_exception = true
+        Thread.pass until go
+        foo
+      }
+
+      -> {
+        go = true
+        Thread.pass while t.alive?
+      }.should output("", <<ERR)
 #{t.inspect} terminated with exception (report_on_exception is true):
 #{__FILE__}:#{line_raise}:in `foo': Thread#report_on_exception specs backtrace order (RuntimeError)
-\tfrom #{__FILE__}:#{line_call_foo}:in `block (5 levels) in <top (required)>'
+\tfrom #{__FILE__}:#{line_call_foo}:in `block (4 levels) in <top (required)>'
 ERR
 
-        -> {
-          t.join
-        }.should raise_error(RuntimeError, "Thread#report_on_exception specs backtrace order")
-      end
+      -> {
+        t.join
+      }.should raise_error(RuntimeError, "Thread#report_on_exception specs backtrace order")
     end
 
     it "prints the backtrace even if the thread was killed just after Thread#raise" do
diff --git a/spec/ruby/core/time/new_spec.rb b/spec/ruby/core/time/new_spec.rb
index 3752cd146d..18d7396269 100644
--- a/spec/ruby/core/time/new_spec.rb
+++ b/spec/ruby/core/time/new_spec.rb
@@ -58,7 +58,7 @@ describe "Time.new with a utc_offset argument" do
     Time.new(2000, 1, 1, 0, 0, 0, "-04:10:43").utc_offset.should == -15043
   end
 
-  ruby_bug '#13669', '3.0'...'3.1' do
+  ruby_bug '#13669', ''...'3.1' do
     it "returns a Time with a UTC offset specified as +HH" do
       Time.new(2000, 1, 1, 0, 0, 0, "+05").utc_offset.should == 3600 * 5
     end
@@ -200,10 +200,8 @@ describe "Time.new with a timezone argument" do
 
     time.zone.should == zone
     time.utc_offset.should == 5*3600+30*60
-    ruby_version_is "3.0" do
-      time.wday.should == 6
-      time.yday.should == 1
-    end
+    time.wday.should == 6
+    time.yday.should == 1
   end
 
   it "accepts timezone argument that must have #local_to_utc and #utc_to_local methods" do
diff --git a/spec/ruby/core/time/succ_spec.rb b/spec/ruby/core/time/succ_spec.rb
deleted file mode 100644
index cbf7cf0951..0000000000
--- a/spec/ruby/core/time/succ_spec.rb
+++ /dev/null
@@ -1,40 +0,0 @@
-require_relative '../../spec_helper'
-
-ruby_version_is ""..."3.0" do
-  require_relative 'fixtures/classes'
-
-  describe "Time#succ" do
-    it "returns a new time one second later than time" do
-      suppress_warning {
-        @result = Time.at(100).succ
-      }
-
-      @result.should == Time.at(101)
-    end
-
-    it "returns a new instance" do
-      time = Time.at(100)
-
-      suppress_warning {
-        @result = time.succ
-      }
-
-      @result.should_not equal time
-    end
-
-    it "is obsolete" do
-      -> {
-        Time.at(100).succ
-      }.should complain(/Time#succ is obsolete/)
-    end
-
-    context "zone is a timezone object" do
-      it "preserves time zone" do
-        zone = TimeSpecs::Timezone.new(offset: (5*3600+30*60))
-        time = Time.new(2012, 1, 1, 12, 0, 0, zone) - 1
-
-        time.zone.should == zone
-      end
-    end
-  end
-end
diff --git a/spec/ruby/core/tracepoint/enable_spec.rb b/spec/ruby/core/tracepoint/enable_spec.rb
index 24f6070b97..6cc8bb3897 100644
--- a/spec/ruby/core/tracepoint/enable_spec.rb
+++ b/spec/ruby/core/tracepoint/enable_spec.rb
@@ -149,13 +149,7 @@ describe 'TracePoint#enable' do
 
   describe "when nested" do
     before do
-      ruby_version_is ""..."3.0" do
-        @path_prefix = '@'
-      end
-
-      ruby_version_is "3.0" do
-        @path_prefix = ' '
-      end
+      @path_prefix = ' '
     end
 
     it "enables both TracePoints but only calls the respective callbacks" do
diff --git a/spec/ruby/core/tracepoint/inspect_spec.rb b/spec/ruby/core/tracepoint/inspect_spec.rb
index 151a08e7b4..21d62e9e26 100644
--- a/spec/ruby/core/tracepoint/inspect_spec.rb
+++ b/spec/ruby/core/tracepoint/inspect_spec.rb
@@ -3,13 +3,7 @@ require_relative 'fixtures/classes'
 
 describe 'TracePoint#inspect' do
   before do
-    ruby_version_is ""..."3.0" do
-      @path_prefix = '@'
-    end
-
-    ruby_version_is "3.0" do
-      @path_prefix = ' '
-    end
+    @path_prefix = ' '
   end
 
   it 'returns a string containing a human-readable TracePoint status' do
diff --git a/spec/ruby/core/warning/element_set_spec.rb b/spec/ruby/core/warning/element_set_spec.rb
index d20ee215ad..f439ffde0a 100644
--- a/spec/ruby/core/warning/element_set_spec.rb
+++ b/spec/ruby/core/warning/element_set_spec.rb
@@ -8,13 +8,7 @@ describe "Warning.[]=" do
 
   describe ":experimental" do
     before do
-      ruby_version_is ""..."3.0" do
-        @src = 'case [0, 1]; in [a, b]; end'
-      end
-
-      ruby_version_is "3.0" do
-        @src = 'warn "This is experimental warning.", category: :experimental'
-      end
+      @src = 'warn "This is experimental warning.", category: :experimental'
     end
 
     it "emits and suppresses warnings for :experimental" do
diff --git a/spec/ruby/core/warning/warn_spec.rb b/spec/ruby/core/warning/warn_spec.rb
index e2fcfbf93f..8f96fe9287 100644
--- a/spec/ruby/core/warning/warn_spec.rb
+++ b/spec/ruby/core/warning/warn_spec.rb
@@ -51,100 +51,85 @@ describe "Warning.warn" do
     end
   end
 
-  ruby_version_is '3.0' do
-    it "is called by Kernel.warn with nil category keyword" do
-      Warning.should_receive(:warn).with("Chunky bacon!\n", category: nil)
-      verbose = $VERBOSE
-      $VERBOSE = false
-      begin
-        Kernel.warn("Chunky bacon!")
-      ensure
-        $VERBOSE = verbose
-      end
-    end
-
-    it "is called by Kernel.warn with given category keyword converted to a symbol" do
-      Warning.should_receive(:warn).with("Chunky bacon!\n", category: :deprecated)
-      verbose = $VERBOSE
-      $VERBOSE = false
-      begin
-        Kernel.warn("Chunky bacon!", category: "deprecated")
-      ensure
-        $VERBOSE = verbose
-      end
+  it "is called by Kernel.warn with nil category keyword" do
+    Warning.should_receive(:warn).with("Chunky bacon!\n", category: nil)
+    verbose = $VERBOSE
+    $VERBOSE = false
+    begin
+      Kernel.warn("Chunky bacon!")
+    ensure
+      $VERBOSE = verbose
     end
+  end
 
-    it "warns when category is :deprecated and Warning[:deprecated] is true" do
-      warn_deprecated = Warning[:deprecated]
-      Warning[:deprecated] = true
-      begin
-        -> {
-          Warning.warn("foo", category: :deprecated)
-        }.should complain("foo")
-      ensure
-        Warning[:deprecated] = warn_deprecated
-      end
+  it "is called by Kernel.warn with given category keyword converted to a symbol" do
+    Warning.should_receive(:warn).with("Chunky bacon!\n", category: :deprecated)
+    verbose = $VERBOSE
+    $VERBOSE = false
+    begin
+      Kernel.warn("Chunky bacon!", category: "deprecated")
+    ensure
+      $VERBOSE = verbose
     end
+  end
 
-    it "warns when category is :experimental and Warning[:experimental] is true" do
-      warn_experimental = Warning[:experimental]
-      Warning[:experimental] = true
-      begin
-        -> {
-          Warning.warn("foo", category: :experimental)
-        }.should complain("foo")
-      ensure
-        Warning[:experimental] = warn_experimental
-      end
+  it "warns when category is :deprecated and Warning[:deprecated] is true" do
+    warn_deprecated = Warning[:deprecated]
+    Warning[:deprecated] = true
+    begin
+      -> {
+        Warning.warn("foo", category: :deprecated)
+      }.should complain("foo")
+    ensure
+      Warning[:deprecated] = warn_deprecated
     end
+  end
 
-    it "doesn't print message when category is :deprecated but Warning[:deprecated] is false" do
-      warn_deprecated = Warning[:deprecated]
-      Warning[:deprecated] = false
-      begin
-        -> {
-          Warning.warn("foo", category: :deprecated)
-        }.should_not complain
-      ensure
-        Warning[:deprecated] = warn_deprecated
-      end
+  it "warns when category is :experimental and Warning[:experimental] is true" do
+    warn_experimental = Warning[:experimental]
+    Warning[:experimental] = true
+    begin
+      -> {
+        Warning.warn("foo", category: :experimental)
+      }.should complain("foo")
+    ensure
+      Warning[:experimental] = warn_experimental
     end
+  end
 
-    it "doesn't print message when category is :experimental but Warning[:experimental] is false" do
-      warn_experimental = Warning[:experimental]
-      Warning[:experimental] = false
-      begin
-        -> {
-          Warning.warn("foo", category: :experimental)
-        }.should_not complain
-      ensure
-        Warning[:experimental] = warn_experimental
-      end
+  it "doesn't print message when category is :deprecated but Warning[:deprecated] is false" do
+    warn_deprecated = Warning[:deprecated]
+    Warning[:deprecated] = false
+    begin
+      -> {
+        Warning.warn("foo", category: :deprecated)
+      }.should_not complain
+    ensure
+      Warning[:deprecated] = warn_deprecated
     end
+  end
 
-    it "prints the message when VERBOSE is false" do
-      -> { Warning.warn("foo") }.should complain("foo")
+  it "doesn't print message when category is :experimental but Warning[:experimental] is false" do
+    warn_experimental = Warning[:experimental]
+    Warning[:experimental] = false
+    begin
+      -> {
+        Warning.warn("foo", category: :experimental)
+      }.should_not complain
+    ensure
+      Warning[:experimental] = warn_experimental
     end
+  end
 
-    it "prints the message when VERBOSE is nil" do
-      -> { Warning.warn("foo") }.should complain("foo", verbose: nil)
-    end
+  it "prints the message when VERBOSE is false" do
+    -> { Warning.warn("foo") }.should complain("foo")
+  end
 
-    it "prints the message when VERBOSE is true" do
-      -> { Warning.warn("foo") }.should complain("foo", verbose: true)
-    end
+  it "prints the message when VERBOSE is nil" do
+    -> { Warning.warn("foo") }.should complain("foo", verbose: nil)
   end
 
-  ruby_version_is ''...'3.0' do
-    it "is called by Kernel.warn" do
-      Warning.should_receive(:warn).with("Chunky bacon!\n")
-      verbose = $VERBOSE
-      $VERBOSE = false
-      begin
-        Kernel.warn("Chunky bacon!")
-      ensure
-        $VERBOSE = verbose
-      end
-    end
+  it "prints the message when VERBOSE is true" do
+    -> { Warning.warn("foo") }.should complain("foo", verbose: true)
   end
 end