205 files changed, 4403 insertions, 3856 deletions
diff --git a/spec/ruby/core/array/pack/a_spec.rb b/spec/ruby/core/array/pack/a_spec.rb
index f4a40502c2..75b8d63b1e 100644
--- a/spec/ruby/core/array/pack/a_spec.rb
+++ b/spec/ruby/core/array/pack/a_spec.rb
@@ -27,7 +27,7 @@ describe "Array#pack with format 'A'" do
     ["abc"].pack("A*").should == "abc"
   end
 
-  it "padds the output with spaces when the count exceeds the size of the String" do
+  it "pads the output with spaces when the count exceeds the size of the String" do
     ["abc"].pack("A6").should == "abc   "
   end
 
@@ -55,7 +55,7 @@ describe "Array#pack with format 'a'" do
     ["abc"].pack("a*").should == "abc"
   end
 
-  it "padds the output with NULL bytes when the count exceeds the size of the String" do
+  it "pads the output with NULL bytes when the count exceeds the size of the String" do
     ["abc"].pack("a6").should == "abc\x00\x00\x00"
   end
 
diff --git a/spec/ruby/core/array/pack/shared/basic.rb b/spec/ruby/core/array/pack/shared/basic.rb
index 4b28de7ed0..ebd9f75d9d 100644
--- a/spec/ruby/core/array/pack/shared/basic.rb
+++ b/spec/ruby/core/array/pack/shared/basic.rb
@@ -32,16 +32,7 @@ describe :array_pack_basic_non_float, shared: true do
     [@obj, @obj, @obj, @obj].pack("aa #{pack_format} # some comment \n#{pack_format}").should be_an_instance_of(String)
   end
 
-  ruby_version_is ""..."3.2" do
-    it "warns in verbose mode that a directive is unknown" do
-      # additional directive ('a') is required for the X directive
-      -> { [@obj, @obj].pack("a R" + pack_format) }.should complain(/unknown pack directive 'R'/, verbose: true)
-      -> { [@obj, @obj].pack("a 0" + pack_format) }.should complain(/unknown pack directive '0'/, verbose: true)
-      -> { [@obj, @obj].pack("a :" + pack_format) }.should complain(/unknown pack directive ':'/, verbose: true)
-    end
-  end
-
-  ruby_version_is "3.2"..."3.3" do
+  ruby_version_is ""..."3.3" do
     # https://bugs.ruby-lang.org/issues/19150
     # NOTE: it's just a plan of the Ruby core team
     it "warns that a directive is unknown" do
diff --git a/spec/ruby/core/array/pack/z_spec.rb b/spec/ruby/core/array/pack/z_spec.rb
index 5ad3afd69e..0757d16e31 100644
--- a/spec/ruby/core/array/pack/z_spec.rb
+++ b/spec/ruby/core/array/pack/z_spec.rb
@@ -26,7 +26,7 @@ describe "Array#pack with format 'Z'" do
     ["abc"].pack("Z*").should == "abc\x00"
   end
 
-  it "padds the output with NULL bytes when the count exceeds the size of the String" do
+  it "pads the output with NULL bytes when the count exceeds the size of the String" do
     ["abc"].pack("Z6").should == "abc\x00\x00\x00"
   end
 
diff --git a/spec/ruby/core/array/shared/slice.rb b/spec/ruby/core/array/shared/slice.rb
index d2866970a5..b80261d32f 100644
--- a/spec/ruby/core/array/shared/slice.rb
+++ b/spec/ruby/core/array/shared/slice.rb
@@ -754,99 +754,97 @@ describe :array_slice, shared: true do
     a.send(@method, (...-9)).should == []
   end
 
-  ruby_version_is "3.2" do
-    describe "can be sliced with Enumerator::ArithmeticSequence" do
-      it "with infinite/inverted ranges and negative steps" do
-        @array = [0, 1, 2, 3, 4, 5]
-        @array.send(@method, (2..).step(-1)).should == [2, 1, 0]
-        @array.send(@method, (2..).step(-2)).should == [2, 0]
-        @array.send(@method, (2..).step(-3)).should == [2]
-        @array.send(@method, (2..).step(-4)).should == [2]
-
-        @array.send(@method, (-3..).step(-1)).should == [3, 2, 1, 0]
-        @array.send(@method, (-3..).step(-2)).should == [3, 1]
-        @array.send(@method, (-3..).step(-3)).should == [3, 0]
-        @array.send(@method, (-3..).step(-4)).should == [3]
-        @array.send(@method, (-3..).step(-5)).should == [3]
-
-        @array.send(@method, (..0).step(-1)).should == [5, 4, 3, 2, 1, 0]
-        @array.send(@method, (..0).step(-2)).should == [5, 3, 1]
-        @array.send(@method, (..0).step(-3)).should == [5, 2]
-        @array.send(@method, (..0).step(-4)).should == [5, 1]
-        @array.send(@method, (..0).step(-5)).should == [5, 0]
-        @array.send(@method, (..0).step(-6)).should == [5]
-        @array.send(@method, (..0).step(-7)).should == [5]
-
-        @array.send(@method, (...0).step(-1)).should == [5, 4, 3, 2, 1]
-        @array.send(@method, (...0).step(-2)).should == [5, 3, 1]
-        @array.send(@method, (...0).step(-3)).should == [5, 2]
-        @array.send(@method, (...0).step(-4)).should == [5, 1]
-        @array.send(@method, (...0).step(-5)).should == [5]
-        @array.send(@method, (...0).step(-6)).should == [5]
-
-        @array.send(@method, (...1).step(-1)).should == [5, 4, 3, 2]
-        @array.send(@method, (...1).step(-2)).should == [5, 3]
-        @array.send(@method, (...1).step(-3)).should == [5, 2]
-        @array.send(@method, (...1).step(-4)).should == [5]
-        @array.send(@method, (...1).step(-5)).should == [5]
-
-        @array.send(@method, (..-5).step(-1)).should == [5, 4, 3, 2, 1]
-        @array.send(@method, (..-5).step(-2)).should == [5, 3, 1]
-        @array.send(@method, (..-5).step(-3)).should == [5, 2]
-        @array.send(@method, (..-5).step(-4)).should == [5, 1]
-        @array.send(@method, (..-5).step(-5)).should == [5]
-        @array.send(@method, (..-5).step(-6)).should == [5]
-
-        @array.send(@method, (...-5).step(-1)).should == [5, 4, 3, 2]
-        @array.send(@method, (...-5).step(-2)).should == [5, 3]
-        @array.send(@method, (...-5).step(-3)).should == [5, 2]
-        @array.send(@method, (...-5).step(-4)).should == [5]
-        @array.send(@method, (...-5).step(-5)).should == [5]
-
-        @array.send(@method, (4..1).step(-1)).should == [4, 3, 2, 1]
-        @array.send(@method, (4..1).step(-2)).should == [4, 2]
-        @array.send(@method, (4..1).step(-3)).should == [4, 1]
-        @array.send(@method, (4..1).step(-4)).should == [4]
-        @array.send(@method, (4..1).step(-5)).should == [4]
-
-        @array.send(@method, (4...1).step(-1)).should == [4, 3, 2]
-        @array.send(@method, (4...1).step(-2)).should == [4, 2]
-        @array.send(@method, (4...1).step(-3)).should == [4]
-        @array.send(@method, (4...1).step(-4)).should == [4]
-
-        @array.send(@method, (-2..1).step(-1)).should == [4, 3, 2, 1]
-        @array.send(@method, (-2..1).step(-2)).should == [4, 2]
-        @array.send(@method, (-2..1).step(-3)).should == [4, 1]
-        @array.send(@method, (-2..1).step(-4)).should == [4]
-        @array.send(@method, (-2..1).step(-5)).should == [4]
-
-        @array.send(@method, (-2...1).step(-1)).should == [4, 3, 2]
-        @array.send(@method, (-2...1).step(-2)).should == [4, 2]
-        @array.send(@method, (-2...1).step(-3)).should == [4]
-        @array.send(@method, (-2...1).step(-4)).should == [4]
-
-        @array.send(@method, (4..-5).step(-1)).should == [4, 3, 2, 1]
-        @array.send(@method, (4..-5).step(-2)).should == [4, 2]
-        @array.send(@method, (4..-5).step(-3)).should == [4, 1]
-        @array.send(@method, (4..-5).step(-4)).should == [4]
-        @array.send(@method, (4..-5).step(-5)).should == [4]
-
-        @array.send(@method, (4...-5).step(-1)).should == [4, 3, 2]
-        @array.send(@method, (4...-5).step(-2)).should == [4, 2]
-        @array.send(@method, (4...-5).step(-3)).should == [4]
-        @array.send(@method, (4...-5).step(-4)).should == [4]
-
-        @array.send(@method, (-2..-5).step(-1)).should == [4, 3, 2, 1]
-        @array.send(@method, (-2..-5).step(-2)).should == [4, 2]
-        @array.send(@method, (-2..-5).step(-3)).should == [4, 1]
-        @array.send(@method, (-2..-5).step(-4)).should == [4]
-        @array.send(@method, (-2..-5).step(-5)).should == [4]
-
-        @array.send(@method, (-2...-5).step(-1)).should == [4, 3, 2]
-        @array.send(@method, (-2...-5).step(-2)).should == [4, 2]
-        @array.send(@method, (-2...-5).step(-3)).should == [4]
-        @array.send(@method, (-2...-5).step(-4)).should == [4]
-      end
+  describe "can be sliced with Enumerator::ArithmeticSequence" do
+    it "with infinite/inverted ranges and negative steps" do
+      @array = [0, 1, 2, 3, 4, 5]
+      @array.send(@method, (2..).step(-1)).should == [2, 1, 0]
+      @array.send(@method, (2..).step(-2)).should == [2, 0]
+      @array.send(@method, (2..).step(-3)).should == [2]
+      @array.send(@method, (2..).step(-4)).should == [2]
+
+      @array.send(@method, (-3..).step(-1)).should == [3, 2, 1, 0]
+      @array.send(@method, (-3..).step(-2)).should == [3, 1]
+      @array.send(@method, (-3..).step(-3)).should == [3, 0]
+      @array.send(@method, (-3..).step(-4)).should == [3]
+      @array.send(@method, (-3..).step(-5)).should == [3]
+
+      @array.send(@method, (..0).step(-1)).should == [5, 4, 3, 2, 1, 0]
+      @array.send(@method, (..0).step(-2)).should == [5, 3, 1]
+      @array.send(@method, (..0).step(-3)).should == [5, 2]
+      @array.send(@method, (..0).step(-4)).should == [5, 1]
+      @array.send(@method, (..0).step(-5)).should == [5, 0]
+      @array.send(@method, (..0).step(-6)).should == [5]
+      @array.send(@method, (..0).step(-7)).should == [5]
+
+      @array.send(@method, (...0).step(-1)).should == [5, 4, 3, 2, 1]
+      @array.send(@method, (...0).step(-2)).should == [5, 3, 1]
+      @array.send(@method, (...0).step(-3)).should == [5, 2]
+      @array.send(@method, (...0).step(-4)).should == [5, 1]
+      @array.send(@method, (...0).step(-5)).should == [5]
+      @array.send(@method, (...0).step(-6)).should == [5]
+
+      @array.send(@method, (...1).step(-1)).should == [5, 4, 3, 2]
+      @array.send(@method, (...1).step(-2)).should == [5, 3]
+      @array.send(@method, (...1).step(-3)).should == [5, 2]
+      @array.send(@method, (...1).step(-4)).should == [5]
+      @array.send(@method, (...1).step(-5)).should == [5]
+
+      @array.send(@method, (..-5).step(-1)).should == [5, 4, 3, 2, 1]
+      @array.send(@method, (..-5).step(-2)).should == [5, 3, 1]
+      @array.send(@method, (..-5).step(-3)).should == [5, 2]
+      @array.send(@method, (..-5).step(-4)).should == [5, 1]
+      @array.send(@method, (..-5).step(-5)).should == [5]
+      @array.send(@method, (..-5).step(-6)).should == [5]
+
+      @array.send(@method, (...-5).step(-1)).should == [5, 4, 3, 2]
+      @array.send(@method, (...-5).step(-2)).should == [5, 3]
+      @array.send(@method, (...-5).step(-3)).should == [5, 2]
+      @array.send(@method, (...-5).step(-4)).should == [5]
+      @array.send(@method, (...-5).step(-5)).should == [5]
+
+      @array.send(@method, (4..1).step(-1)).should == [4, 3, 2, 1]
+      @array.send(@method, (4..1).step(-2)).should == [4, 2]
+      @array.send(@method, (4..1).step(-3)).should == [4, 1]
+      @array.send(@method, (4..1).step(-4)).should == [4]
+      @array.send(@method, (4..1).step(-5)).should == [4]
+
+      @array.send(@method, (4...1).step(-1)).should == [4, 3, 2]
+      @array.send(@method, (4...1).step(-2)).should == [4, 2]
+      @array.send(@method, (4...1).step(-3)).should == [4]
+      @array.send(@method, (4...1).step(-4)).should == [4]
+
+      @array.send(@method, (-2..1).step(-1)).should == [4, 3, 2, 1]
+      @array.send(@method, (-2..1).step(-2)).should == [4, 2]
+      @array.send(@method, (-2..1).step(-3)).should == [4, 1]
+      @array.send(@method, (-2..1).step(-4)).should == [4]
+      @array.send(@method, (-2..1).step(-5)).should == [4]
+
+      @array.send(@method, (-2...1).step(-1)).should == [4, 3, 2]
+      @array.send(@method, (-2...1).step(-2)).should == [4, 2]
+      @array.send(@method, (-2...1).step(-3)).should == [4]
+      @array.send(@method, (-2...1).step(-4)).should == [4]
+
+      @array.send(@method, (4..-5).step(-1)).should == [4, 3, 2, 1]
+      @array.send(@method, (4..-5).step(-2)).should == [4, 2]
+      @array.send(@method, (4..-5).step(-3)).should == [4, 1]
+      @array.send(@method, (4..-5).step(-4)).should == [4]
+      @array.send(@method, (4..-5).step(-5)).should == [4]
+
+      @array.send(@method, (4...-5).step(-1)).should == [4, 3, 2]
+      @array.send(@method, (4...-5).step(-2)).should == [4, 2]
+      @array.send(@method, (4...-5).step(-3)).should == [4]
+      @array.send(@method, (4...-5).step(-4)).should == [4]
+
+      @array.send(@method, (-2..-5).step(-1)).should == [4, 3, 2, 1]
+      @array.send(@method, (-2..-5).step(-2)).should == [4, 2]
+      @array.send(@method, (-2..-5).step(-3)).should == [4, 1]
+      @array.send(@method, (-2..-5).step(-4)).should == [4]
+      @array.send(@method, (-2..-5).step(-5)).should == [4]
+
+      @array.send(@method, (-2...-5).step(-1)).should == [4, 3, 2]
+      @array.send(@method, (-2...-5).step(-2)).should == [4, 2]
+      @array.send(@method, (-2...-5).step(-3)).should == [4]
+      @array.send(@method, (-2...-5).step(-4)).should == [4]
     end
   end
 
diff --git a/spec/ruby/core/class/attached_object_spec.rb b/spec/ruby/core/class/attached_object_spec.rb
index f1c0f63a44..8f8a0734c6 100644
--- a/spec/ruby/core/class/attached_object_spec.rb
+++ b/spec/ruby/core/class/attached_object_spec.rb
@@ -1,31 +1,29 @@
 require_relative '../../spec_helper'
 
-ruby_version_is '3.2' do
-  describe "Class#attached_object" do
-    it "returns the object that is attached to a singleton class" do
-      a = Class.new
+describe "Class#attached_object" do
+  it "returns the object that is attached to a singleton class" do
+    a = Class.new
 
-      a_obj = a.new
-      a_obj.singleton_class.attached_object.should == a_obj
-    end
+    a_obj = a.new
+    a_obj.singleton_class.attached_object.should == a_obj
+  end
 
-    it "returns the class object that is attached to a class's singleton class" do
-      a = Class.new
-      singleton_class = (class << a; self; end)
+  it "returns the class object that is attached to a class's singleton class" do
+    a = Class.new
+    singleton_class = (class << a; self; end)
 
-      singleton_class.attached_object.should == a
-    end
+    singleton_class.attached_object.should == a
+  end
 
-    it "raises TypeError if the class is not a singleton class" do
-      a = Class.new
+  it "raises TypeError if the class is not a singleton class" do
+    a = Class.new
 
-      -> { a.attached_object }.should raise_error(TypeError, /is not a singleton class/)
-    end
+    -> { a.attached_object }.should raise_error(TypeError, /is not a singleton class/)
+  end
 
-    it "raises TypeError for special singleton classes" do
-      -> { nil.singleton_class.attached_object }.should raise_error(TypeError, /[`']NilClass' is not a singleton class/)
-      -> { true.singleton_class.attached_object }.should raise_error(TypeError, /[`']TrueClass' is not a singleton class/)
-      -> { false.singleton_class.attached_object }.should raise_error(TypeError, /[`']FalseClass' is not a singleton class/)
-    end
+  it "raises TypeError for special singleton classes" do
+    -> { nil.singleton_class.attached_object }.should raise_error(TypeError, /[`']NilClass' is not a singleton class/)
+    -> { true.singleton_class.attached_object }.should raise_error(TypeError, /[`']TrueClass' is not a singleton class/)
+    -> { false.singleton_class.attached_object }.should raise_error(TypeError, /[`']FalseClass' is not a singleton class/)
   end
 end
diff --git a/spec/ruby/core/complex/polar_spec.rb b/spec/ruby/core/complex/polar_spec.rb
index 3bb3751bc6..56335584ef 100644
--- a/spec/ruby/core/complex/polar_spec.rb
+++ b/spec/ruby/core/complex/polar_spec.rb
@@ -11,20 +11,18 @@ describe "Complex.polar" do
     ->{ Complex.polar(nil, nil) }.should raise_error(TypeError)
   end
 
-  ruby_bug "#19004", ""..."3.2" do
-    it "computes the real values of the real & imaginary parts from the polar form" do
-      a = Complex.polar(1.0+0.0i, Math::PI/2+0.0i)
-      a.real.should be_close(0.0, TOLERANCE)
-      a.imag.should be_close(1.0, TOLERANCE)
-      a.real.real?.should be_true
-      a.imag.real?.should be_true
+  it "computes the real values of the real & imaginary parts from the polar form" do
+    a = Complex.polar(1.0+0.0i, Math::PI/2+0.0i)
+    a.real.should be_close(0.0, TOLERANCE)
+    a.imag.should be_close(1.0, TOLERANCE)
+    a.real.real?.should be_true
+    a.imag.real?.should be_true
 
-      b = Complex.polar(1+0.0i)
-      b.real.should be_close(1.0, TOLERANCE)
-      b.imag.should be_close(0.0, TOLERANCE)
-      b.real.real?.should be_true
-      b.imag.real?.should be_true
-    end
+    b = Complex.polar(1+0.0i)
+    b.real.should be_close(1.0, TOLERANCE)
+    b.imag.should be_close(0.0, TOLERANCE)
+    b.real.real?.should be_true
+    b.imag.real?.should be_true
   end
 end
 
diff --git a/spec/ruby/core/data/constants_spec.rb b/spec/ruby/core/data/constants_spec.rb
index 2eb43d501e..ad0b1ddea7 100644
--- a/spec/ruby/core/data/constants_spec.rb
+++ b/spec/ruby/core/data/constants_spec.rb
@@ -1,21 +1,11 @@
 require_relative '../../spec_helper'
 
-ruby_version_is ''...'3.2' do
-  describe "Data" do
-    it "does not exist anymore" do
-      Object.should_not have_constant(:Data)
-    end
+describe "Data" do
+  it "is a new constant" do
+    Data.superclass.should == Object
   end
-end
-
-ruby_version_is '3.2' do
-  describe "Data" do
-    it "is a new constant" do
-      Data.superclass.should == Object
-    end
 
-    it "is not deprecated" do
-      -> { Data }.should_not complain
-    end
+  it "is not deprecated" do
+    -> { Data }.should_not complain
   end
 end
diff --git a/spec/ruby/core/data/deconstruct_keys_spec.rb b/spec/ruby/core/data/deconstruct_keys_spec.rb
index 07af87771d..5cae4cbd68 100644
--- a/spec/ruby/core/data/deconstruct_keys_spec.rb
+++ b/spec/ruby/core/data/deconstruct_keys_spec.rb
@@ -1,107 +1,105 @@
 require_relative '../../spec_helper'
 require_relative 'fixtures/classes'
 
-ruby_version_is "3.2" do
-  describe "Data#deconstruct" do
-    it "returns a hash of attributes" do
-      klass = Data.define(:x, :y)
-      d = klass.new(1, 2)
-      d.deconstruct_keys([:x, :y]).should == {x: 1, y: 2}
-    end
-
-    it "requires one argument" do
-      klass = Data.define(:x, :y)
-      d = klass.new(1, 2)
-
-      -> {
-        d.deconstruct_keys
-      }.should raise_error(ArgumentError, /wrong number of arguments \(given 0, expected 1\)/)
-    end
-
-    it "returns only specified keys" do
-      klass = Data.define(:x, :y)
-      d = klass.new(1, 2)
-
-      d.deconstruct_keys([:x, :y]).should == {x: 1, y: 2}
-      d.deconstruct_keys([:x]    ).should == {x: 1}
-      d.deconstruct_keys([]      ).should == {}
-    end
-
-    it "accepts string attribute names" do
-      klass = Data.define(:x, :y)
-      d = klass.new(1, 2)
-      d.deconstruct_keys(['x', 'y']).should == {'x' => 1, 'y' => 2}
-    end
-
-    it "accepts argument position number as well but returns them as keys" do
-      klass = Data.define(:x, :y)
-      d = klass.new(1, 2)
-
-      d.deconstruct_keys([0, 1]).should == {0 => 1, 1 => 2}
-      d.deconstruct_keys([0]   ).should == {0 => 1}
-      d.deconstruct_keys([-1]  ).should == {-1 => 2}
-    end
-
-    it "ignores incorrect position numbers" do
-      klass = Data.define(:x, :y)
-      d = klass.new(1, 2)
-
-      d.deconstruct_keys([0, 3]).should == {0 => 1}
-    end
-
-    it "support mixing attribute names and argument position numbers" do
-      klass = Data.define(:x, :y)
-      d = klass.new(1, 2)
-
-      d.deconstruct_keys([0, :x]).should == {0 => 1, :x => 1}
-    end
-
-    it "returns an empty hash when there are more keys than attributes" do
-      klass = Data.define(:x, :y)
-      d = klass.new(1, 2)
-      d.deconstruct_keys([:x, :y, :x]).should == {}
-    end
-
-    it "returns at first not existing attribute name" do
-      klass = Data.define(:x, :y)
-      d = klass.new(1, 2)
-
-      d.deconstruct_keys([:a, :x]).should == {}
-      d.deconstruct_keys([:x, :a]).should == {x: 1}
-    end
-
-    it "returns at first not existing argument position number" do
-      klass = Data.define(:x, :y)
-      d = klass.new(1, 2)
-
-      d.deconstruct_keys([3, 0]).should == {}
-      d.deconstruct_keys([0, 3]).should == {0 => 1}
-    end
-
-    it "accepts nil argument and return all the attributes" do
-      klass = Data.define(:x, :y)
-      d = klass.new(1, 2)
-
-      d.deconstruct_keys(nil).should == {x: 1, y: 2}
-    end
-
-    it "raises TypeError if index is not a String, a Symbol and not convertible to Integer " do
-      klass = Data.define(:x, :y)
-      d = klass.new(1, 2)
-
-      -> {
-        d.deconstruct_keys([0, []])
-      }.should raise_error(TypeError, "no implicit conversion of Array into Integer")
-    end
-
-    it "raise TypeError if passed anything except nil or array" do
-      klass = Data.define(:x, :y)
-      d = klass.new(1, 2)
-
-      -> { d.deconstruct_keys('x') }.should raise_error(TypeError, /expected Array or nil/)
-      -> { d.deconstruct_keys(1)   }.should raise_error(TypeError, /expected Array or nil/)
-      -> { d.deconstruct_keys(:x)  }.should raise_error(TypeError, /expected Array or nil/)
-      -> { d.deconstruct_keys({})  }.should raise_error(TypeError, /expected Array or nil/)
-    end
+describe "Data#deconstruct" do
+  it "returns a hash of attributes" do
+    klass = Data.define(:x, :y)
+    d = klass.new(1, 2)
+    d.deconstruct_keys([:x, :y]).should == {x: 1, y: 2}
+  end
+
+  it "requires one argument" do
+    klass = Data.define(:x, :y)
+    d = klass.new(1, 2)
+
+    -> {
+      d.deconstruct_keys
+    }.should raise_error(ArgumentError, /wrong number of arguments \(given 0, expected 1\)/)
+  end
+
+  it "returns only specified keys" do
+    klass = Data.define(:x, :y)
+    d = klass.new(1, 2)
+
+    d.deconstruct_keys([:x, :y]).should == {x: 1, y: 2}
+    d.deconstruct_keys([:x]    ).should == {x: 1}
+    d.deconstruct_keys([]      ).should == {}
+  end
+
+  it "accepts string attribute names" do
+    klass = Data.define(:x, :y)
+    d = klass.new(1, 2)
+    d.deconstruct_keys(['x', 'y']).should == {'x' => 1, 'y' => 2}
+  end
+
+  it "accepts argument position number as well but returns them as keys" do
+    klass = Data.define(:x, :y)
+    d = klass.new(1, 2)
+
+    d.deconstruct_keys([0, 1]).should == {0 => 1, 1 => 2}
+    d.deconstruct_keys([0]   ).should == {0 => 1}
+    d.deconstruct_keys([-1]  ).should == {-1 => 2}
+  end
+
+  it "ignores incorrect position numbers" do
+    klass = Data.define(:x, :y)
+    d = klass.new(1, 2)
+
+    d.deconstruct_keys([0, 3]).should == {0 => 1}
+  end
+
+  it "support mixing attribute names and argument position numbers" do
+    klass = Data.define(:x, :y)
+    d = klass.new(1, 2)
+
+    d.deconstruct_keys([0, :x]).should == {0 => 1, :x => 1}
+  end
+
+  it "returns an empty hash when there are more keys than attributes" do
+    klass = Data.define(:x, :y)
+    d = klass.new(1, 2)
+    d.deconstruct_keys([:x, :y, :x]).should == {}
+  end
+
+  it "returns at first not existing attribute name" do
+    klass = Data.define(:x, :y)
+    d = klass.new(1, 2)
+
+    d.deconstruct_keys([:a, :x]).should == {}
+    d.deconstruct_keys([:x, :a]).should == {x: 1}
+  end
+
+  it "returns at first not existing argument position number" do
+    klass = Data.define(:x, :y)
+    d = klass.new(1, 2)
+
+    d.deconstruct_keys([3, 0]).should == {}
+    d.deconstruct_keys([0, 3]).should == {0 => 1}
+  end
+
+  it "accepts nil argument and return all the attributes" do
+    klass = Data.define(:x, :y)
+    d = klass.new(1, 2)
+
+    d.deconstruct_keys(nil).should == {x: 1, y: 2}
+  end
+
+  it "raises TypeError if index is not a String, a Symbol and not convertible to Integer " do
+    klass = Data.define(:x, :y)
+    d = klass.new(1, 2)
+
+    -> {
+      d.deconstruct_keys([0, []])
+    }.should raise_error(TypeError, "no implicit conversion of Array into Integer")
+  end
+
+  it "raise TypeError if passed anything except nil or array" do
+    klass = Data.define(:x, :y)
+    d = klass.new(1, 2)
+
+    -> { d.deconstruct_keys('x') }.should raise_error(TypeError, /expected Array or nil/)
+    -> { d.deconstruct_keys(1)   }.should raise_error(TypeError, /expected Array or nil/)
+    -> { d.deconstruct_keys(:x)  }.should raise_error(TypeError, /expected Array or nil/)
+    -> { d.deconstruct_keys({})  }.should raise_error(TypeError, /expected Array or nil/)
   end
 end
diff --git a/spec/ruby/core/data/deconstruct_spec.rb b/spec/ruby/core/data/deconstruct_spec.rb
index f0995e8fed..4ca0b87039 100644
--- a/spec/ruby/core/data/deconstruct_spec.rb
+++ b/spec/ruby/core/data/deconstruct_spec.rb
@@ -1,10 +1,8 @@
 require_relative '../../spec_helper'
 require_relative 'fixtures/classes'
 
-ruby_version_is "3.2" do
-  describe "Data#deconstruct" do
-    it "returns an array of attribute values" do
-      DataSpecs::Measure.new(42, "km").deconstruct.should == [42, "km"]
-    end
+describe "Data#deconstruct" do
+  it "returns an array of attribute values" do
+    DataSpecs::Measure.new(42, "km").deconstruct.should == [42, "km"]
   end
 end
diff --git a/spec/ruby/core/data/define_spec.rb b/spec/ruby/core/data/define_spec.rb
index 2aa2c50d4c..c0b4671e39 100644
--- a/spec/ruby/core/data/define_spec.rb
+++ b/spec/ruby/core/data/define_spec.rb
@@ -1,36 +1,34 @@
 require_relative '../../spec_helper'
 require_relative 'fixtures/classes'
 
-ruby_version_is "3.2" do
-  describe "Data.define" do
-    it "accepts no arguments" do
-      empty_data = Data.define
-      empty_data.members.should == []
-    end
+describe "Data.define" do
+  it "accepts no arguments" do
+    empty_data = Data.define
+    empty_data.members.should == []
+  end
 
-    it "accepts symbols" do
-      movie = Data.define(:title, :year)
-      movie.members.should == [:title, :year]
-    end
+  it "accepts symbols" do
+    movie = Data.define(:title, :year)
+    movie.members.should == [:title, :year]
+  end
 
-    it "accepts strings" do
-      movie = Data.define("title", "year")
-      movie.members.should == [:title, :year]
-    end
+  it "accepts strings" do
+    movie = Data.define("title", "year")
+    movie.members.should == [:title, :year]
+  end
 
-    it "accepts a mix of strings and symbols" do
-      movie = Data.define("title", :year, "genre")
-      movie.members.should == [:title, :year, :genre]
-    end
+  it "accepts a mix of strings and symbols" do
+    movie = Data.define("title", :year, "genre")
+    movie.members.should == [:title, :year, :genre]
+  end
 
-    it "accepts a block" do
-      movie = Data.define(:title, :year) do
-        def title_with_year
-          "#{title} (#{year})"
-        end
+  it "accepts a block" do
+    movie = Data.define(:title, :year) do
+      def title_with_year
+        "#{title} (#{year})"
       end
-      movie.members.should == [:title, :year]
-      movie.new("Matrix", 1999).title_with_year.should == "Matrix (1999)"
     end
+    movie.members.should == [:title, :year]
+    movie.new("Matrix", 1999).title_with_year.should == "Matrix (1999)"
   end
 end
diff --git a/spec/ruby/core/data/eql_spec.rb b/spec/ruby/core/data/eql_spec.rb
index 906e46316c..6958d5de4a 100644
--- a/spec/ruby/core/data/eql_spec.rb
+++ b/spec/ruby/core/data/eql_spec.rb
@@ -1,65 +1,63 @@
 require_relative '../../spec_helper'
 require_relative 'fixtures/classes'
 
-ruby_version_is "3.2" do
-  describe "Data#eql?" do
-    it "returns true if the other is the same object" do
-      a = DataSpecs::Measure.new(42, "km")
-      a.should.eql?(a)
-    end
+describe "Data#eql?" do
+  it "returns true if the other is the same object" do
+    a = DataSpecs::Measure.new(42, "km")
+    a.should.eql?(a)
+  end
 
-    it "returns true if the other has all the same fields" do
-      a = DataSpecs::Measure.new(42, "km")
-      b = DataSpecs::Measure.new(42, "km")
-      a.should.eql?(b)
-    end
+  it "returns true if the other has all the same fields" do
+    a = DataSpecs::Measure.new(42, "km")
+    b = DataSpecs::Measure.new(42, "km")
+    a.should.eql?(b)
+  end
 
-    it "returns false if the other is a different object or has different fields" do
-      a = DataSpecs::Measure.new(42, "km")
-      b = DataSpecs::Measure.new(42, "mi")
-      a.should_not.eql?(b)
-    end
+  it "returns false if the other is a different object or has different fields" do
+    a = DataSpecs::Measure.new(42, "km")
+    b = DataSpecs::Measure.new(42, "mi")
+    a.should_not.eql?(b)
+  end
 
-    it "returns false if other is of a different class" do
-      a = DataSpecs::Measure.new(42, "km")
-      klass = Data.define(*DataSpecs::Measure.members)
-      b = klass.new(42, "km")
-      a.should_not.eql?(b)
-    end
+  it "returns false if other is of a different class" do
+    a = DataSpecs::Measure.new(42, "km")
+    klass = Data.define(*DataSpecs::Measure.members)
+    b = klass.new(42, "km")
+    a.should_not.eql?(b)
+  end
 
-    it "returns false if any corresponding elements are not equal with #eql?" do
-      a = DataSpecs::Measure.new(42, "km")
-      b = DataSpecs::Measure.new(42.0, "mi")
-      a.should_not.eql?(b)
-    end
+  it "returns false if any corresponding elements are not equal with #eql?" do
+    a = DataSpecs::Measure.new(42, "km")
+    b = DataSpecs::Measure.new(42.0, "mi")
+    a.should_not.eql?(b)
+  end
 
-    context "recursive structure" do
-      it "returns true the other is the same object" do
-        a = DataSpecs::Measure.allocate
-        a.send(:initialize, amount: 42, unit: a)
+  context "recursive structure" do
+    it "returns true the other is the same object" do
+      a = DataSpecs::Measure.allocate
+      a.send(:initialize, amount: 42, unit: a)
 
-        a.should.eql?(a)
-      end
+      a.should.eql?(a)
+    end
 
-      it "returns true if the other has all the same fields" do
-        a = DataSpecs::Measure.allocate
-        a.send(:initialize, amount: 42, unit: a)
+    it "returns true if the other has all the same fields" do
+      a = DataSpecs::Measure.allocate
+      a.send(:initialize, amount: 42, unit: a)
 
-        b = DataSpecs::Measure.allocate
-        b.send(:initialize, amount: 42, unit: b)
+      b = DataSpecs::Measure.allocate
+      b.send(:initialize, amount: 42, unit: b)
 
-        a.should.eql?(b)
-      end
+      a.should.eql?(b)
+    end
 
-      it "returns false if any corresponding elements are not equal with #eql?" do
-        a = DataSpecs::Measure.allocate
-        a.send(:initialize, amount: a, unit: "km")
+    it "returns false if any corresponding elements are not equal with #eql?" do
+      a = DataSpecs::Measure.allocate
+      a.send(:initialize, amount: a, unit: "km")
 
-        b = DataSpecs::Measure.allocate
-        b.send(:initialize, amount: b, unit: "mi")
+      b = DataSpecs::Measure.allocate
+      b.send(:initialize, amount: b, unit: "mi")
 
-        a.should_not.eql?(b)
-      end
+      a.should_not.eql?(b)
     end
   end
 end
diff --git a/spec/ruby/core/data/equal_value_spec.rb b/spec/ruby/core/data/equal_value_spec.rb
index f90a7d7a62..d9a0dcff3e 100644
--- a/spec/ruby/core/data/equal_value_spec.rb
+++ b/spec/ruby/core/data/equal_value_spec.rb
@@ -1,65 +1,63 @@
 require_relative '../../spec_helper'
 require_relative 'fixtures/classes'
 
-ruby_version_is "3.2" do
-  describe "Data#==" do
-    it "returns true if the other is the same object" do
-      a = DataSpecs::Measure.new(42, "km")
-      a.should == a
-    end
+describe "Data#==" do
+  it "returns true if the other is the same object" do
+    a = DataSpecs::Measure.new(42, "km")
+    a.should == a
+  end
 
-    it "returns true if the other has all the same fields" do
-      a = DataSpecs::Measure.new(42, "km")
-      b = DataSpecs::Measure.new(42, "km")
-      a.should == b
-    end
+  it "returns true if the other has all the same fields" do
+    a = DataSpecs::Measure.new(42, "km")
+    b = DataSpecs::Measure.new(42, "km")
+    a.should == b
+  end
 
-    it "returns false if the other is a different object or has different fields" do
-      a = DataSpecs::Measure.new(42, "km")
-      b = DataSpecs::Measure.new(42, "mi")
-      a.should_not == b
-    end
+  it "returns false if the other is a different object or has different fields" do
+    a = DataSpecs::Measure.new(42, "km")
+    b = DataSpecs::Measure.new(42, "mi")
+    a.should_not == b
+  end
 
-    it "returns false if other is of a different class" do
-      a = DataSpecs::Measure.new(42, "km")
-      klass = Data.define(*DataSpecs::Measure.members)
-      b = klass.new(42, "km")
-      a.should_not == b
-    end
+  it "returns false if other is of a different class" do
+    a = DataSpecs::Measure.new(42, "km")
+    klass = Data.define(*DataSpecs::Measure.members)
+    b = klass.new(42, "km")
+    a.should_not == b
+  end
 
-    it "returns false if any corresponding elements are not equal with #==" do
-      a = DataSpecs::Measure.new(42, "km")
-      b = DataSpecs::Measure.new(42.0, "mi")
-      a.should_not == b
-    end
+  it "returns false if any corresponding elements are not equal with #==" do
+    a = DataSpecs::Measure.new(42, "km")
+    b = DataSpecs::Measure.new(42.0, "mi")
+    a.should_not == b
+  end
 
-    context "recursive structure" do
-      it "returns true the other is the same object" do
-        a = DataSpecs::Measure.allocate
-        a.send(:initialize, amount: 42, unit: a)
+  context "recursive structure" do
+    it "returns true the other is the same object" do
+      a = DataSpecs::Measure.allocate
+      a.send(:initialize, amount: 42, unit: a)
 
-        a.should == a
-      end
+      a.should == a
+    end
 
-      it "returns true if the other has all the same fields" do
-        a = DataSpecs::Measure.allocate
-        a.send(:initialize, amount: 42, unit: a)
+    it "returns true if the other has all the same fields" do
+      a = DataSpecs::Measure.allocate
+      a.send(:initialize, amount: 42, unit: a)
 
-        b = DataSpecs::Measure.allocate
-        b.send(:initialize, amount: 42, unit: b)
+      b = DataSpecs::Measure.allocate
+      b.send(:initialize, amount: 42, unit: b)
 
-        a.should == b
-      end
+      a.should == b
+    end
 
-      it "returns false if any corresponding elements are not equal with #==" do
-        a = DataSpecs::Measure.allocate
-        a.send(:initialize, amount: a, unit: "km")
+    it "returns false if any corresponding elements are not equal with #==" do
+      a = DataSpecs::Measure.allocate
+      a.send(:initialize, amount: a, unit: "km")
 
-        b = DataSpecs::Measure.allocate
-        b.send(:initialize, amount: b, unit: "mi")
+      b = DataSpecs::Measure.allocate
+      b.send(:initialize, amount: b, unit: "mi")
 
-        a.should_not == b
-      end
+      a.should_not == b
     end
   end
 end
diff --git a/spec/ruby/core/data/fixtures/classes.rb b/spec/ruby/core/data/fixtures/classes.rb
index f0a526517d..5db263fa20 100644
--- a/spec/ruby/core/data/fixtures/classes.rb
+++ b/spec/ruby/core/data/fixtures/classes.rb
@@ -1,5 +1,5 @@
 module DataSpecs
-  guard -> { ruby_version_is "3.2" and Data.respond_to?(:define) } do
+  if Data.respond_to?(:define)
     Measure = Data.define(:amount, :unit)
 
     class MeasureWithOverriddenName < Measure
diff --git a/spec/ruby/core/data/hash_spec.rb b/spec/ruby/core/data/hash_spec.rb
index 324a2abca4..c23f08a71d 100644
--- a/spec/ruby/core/data/hash_spec.rb
+++ b/spec/ruby/core/data/hash_spec.rb
@@ -1,27 +1,25 @@
 require_relative '../../spec_helper'
 require_relative 'fixtures/classes'
 
-ruby_version_is "3.2" do
-  describe "Data#hash" do
-    it "returns the same integer for objects with the same content" do
-      a = DataSpecs::Measure.new(42, "km")
-      b = DataSpecs::Measure.new(42, "km")
-      a.hash.should == b.hash
-      a.hash.should be_an_instance_of(Integer)
-    end
+describe "Data#hash" do
+  it "returns the same integer for objects with the same content" do
+    a = DataSpecs::Measure.new(42, "km")
+    b = DataSpecs::Measure.new(42, "km")
+    a.hash.should == b.hash
+    a.hash.should be_an_instance_of(Integer)
+  end
 
-    it "returns different hashes for objects with different values" do
-      a = DataSpecs::Measure.new(42, "km")
-      b = DataSpecs::Measure.new(42, "ml")
-      a.hash.should_not == b.hash
+  it "returns different hashes for objects with different values" do
+    a = DataSpecs::Measure.new(42, "km")
+    b = DataSpecs::Measure.new(42, "ml")
+    a.hash.should_not == b.hash
 
-      a = DataSpecs::Measure.new(42, "km")
-      b = DataSpecs::Measure.new(13, "km")
-      a.hash.should_not == b.hash
-    end
+    a = DataSpecs::Measure.new(42, "km")
+    b = DataSpecs::Measure.new(13, "km")
+    a.hash.should_not == b.hash
+  end
 
-    it "returns different hashes for different classes" do
-      Data.define(:x).new(1).hash.should != Data.define(:x).new(1).hash
-    end
+  it "returns different hashes for different classes" do
+    Data.define(:x).new(1).hash.should != Data.define(:x).new(1).hash
   end
 end
diff --git a/spec/ruby/core/data/initialize_spec.rb b/spec/ruby/core/data/initialize_spec.rb
index 2c36bd3ac4..37a6c8f2dd 100644
--- a/spec/ruby/core/data/initialize_spec.rb
+++ b/spec/ruby/core/data/initialize_spec.rb
@@ -1,65 +1,63 @@
 require_relative '../../spec_helper'
 require_relative 'fixtures/classes'
 
-ruby_version_is "3.2" do
-  describe "Data#initialize" do
-    it "accepts positional arguments" do
-      data = DataSpecs::Measure.new(42, "km")
+describe "Data#initialize" do
+  it "accepts positional arguments" do
+    data = DataSpecs::Measure.new(42, "km")
 
-      data.amount.should == 42
-      data.unit.should == "km"
-    end
+    data.amount.should == 42
+    data.unit.should == "km"
+  end
 
-    it "accepts alternative positional arguments" do
-      data = DataSpecs::Measure[42, "km"]
+  it "accepts alternative positional arguments" do
+    data = DataSpecs::Measure[42, "km"]
 
-      data.amount.should == 42
-      data.unit.should == "km"
-    end
+    data.amount.should == 42
+    data.unit.should == "km"
+  end
 
-    it "accepts keyword arguments" do
-      data = DataSpecs::Measure.new(amount: 42, unit: "km")
+  it "accepts keyword arguments" do
+    data = DataSpecs::Measure.new(amount: 42, unit: "km")
 
-      data.amount.should == 42
-      data.unit.should == "km"
-    end
+    data.amount.should == 42
+    data.unit.should == "km"
+  end
 
-    it "accepts alternative keyword arguments" do
-      data = DataSpecs::Measure[amount: 42, unit: "km"]
+  it "accepts alternative keyword arguments" do
+    data = DataSpecs::Measure[amount: 42, unit: "km"]
 
-      data.amount.should == 42
-      data.unit.should == "km"
-    end
+    data.amount.should == 42
+    data.unit.should == "km"
+  end
 
-    it "accepts String keyword arguments" do
-      data = DataSpecs::Measure.new("amount" => 42, "unit" => "km")
+  it "accepts String keyword arguments" do
+    data = DataSpecs::Measure.new("amount" => 42, "unit" => "km")
 
-      data.amount.should == 42
-      data.unit.should == "km"
-    end
+    data.amount.should == 42
+    data.unit.should == "km"
+  end
 
-    it "raises ArgumentError if no arguments are given" do
-      -> {
-        DataSpecs::Measure.new
-      }.should raise_error(ArgumentError) { |e|
-        e.message.should.include?("missing keywords: :amount, :unit")
-      }
-    end
+  it "raises ArgumentError if no arguments are given" do
+    -> {
+      DataSpecs::Measure.new
+    }.should raise_error(ArgumentError) { |e|
+      e.message.should.include?("missing keywords: :amount, :unit")
+    }
+  end
 
-    it "raises ArgumentError if at least one argument is missing" do
-      -> {
-        DataSpecs::Measure.new(unit: "km")
-      }.should raise_error(ArgumentError) { |e|
-        e.message.should.include?("missing keyword: :amount")
-      }
-    end
+  it "raises ArgumentError if at least one argument is missing" do
+    -> {
+      DataSpecs::Measure.new(unit: "km")
+    }.should raise_error(ArgumentError) { |e|
+      e.message.should.include?("missing keyword: :amount")
+    }
+  end
 
-    it "raises ArgumentError if unknown keyword is given" do
-      -> {
-        DataSpecs::Measure.new(amount: 42, unit: "km", system: "metric")
-      }.should raise_error(ArgumentError) { |e|
-        e.message.should.include?("unknown keyword: :system")
-      }
-    end
+  it "raises ArgumentError if unknown keyword is given" do
+    -> {
+      DataSpecs::Measure.new(amount: 42, unit: "km", system: "metric")
+    }.should raise_error(ArgumentError) { |e|
+      e.message.should.include?("unknown keyword: :system")
+    }
   end
 end
diff --git a/spec/ruby/core/data/inspect_spec.rb b/spec/ruby/core/data/inspect_spec.rb
index 3d337fac68..38642910a0 100644
--- a/spec/ruby/core/data/inspect_spec.rb
+++ b/spec/ruby/core/data/inspect_spec.rb
@@ -1,8 +1,6 @@
 require_relative '../../spec_helper'
 require_relative 'shared/inspect'
 
-ruby_version_is "3.2" do
-  describe "Data#inspect" do
-    it_behaves_like :data_inspect, :inspect
-  end
+describe "Data#inspect" do
+  it_behaves_like :data_inspect, :inspect
 end
diff --git a/spec/ruby/core/data/members_spec.rb b/spec/ruby/core/data/members_spec.rb
index 1776b0b9c1..457a90a0d6 100644
--- a/spec/ruby/core/data/members_spec.rb
+++ b/spec/ruby/core/data/members_spec.rb
@@ -1,23 +1,21 @@
 require_relative '../../spec_helper'
 require_relative 'fixtures/classes'
 
-ruby_version_is "3.2" do
-  describe "Data#members" do
-    it "returns an array of attribute names" do
-      measure = DataSpecs::Measure.new(amount: 42, unit: 'km')
-      measure.members.should == [:amount, :unit]
-    end
+describe "Data#members" do
+  it "returns an array of attribute names" do
+    measure = DataSpecs::Measure.new(amount: 42, unit: 'km')
+    measure.members.should == [:amount, :unit]
   end
+end
 
-  describe "DataClass#members" do
-    it "returns an array of attribute names" do
-      DataSpecs::Measure.members.should == [:amount, :unit]
-    end
+describe "DataClass#members" do
+  it "returns an array of attribute names" do
+    DataSpecs::Measure.members.should == [:amount, :unit]
+  end
 
-    context "class inheriting Data" do
-      it "isn't available in a subclass" do
-        DataSpecs::DataSubclass.should_not.respond_to?(:members)
-      end
+  context "class inheriting Data" do
+    it "isn't available in a subclass" do
+      DataSpecs::DataSubclass.should_not.respond_to?(:members)
     end
   end
 end
diff --git a/spec/ruby/core/data/to_h_spec.rb b/spec/ruby/core/data/to_h_spec.rb
index 41d6960c97..64816b7251 100644
--- a/spec/ruby/core/data/to_h_spec.rb
+++ b/spec/ruby/core/data/to_h_spec.rb
@@ -1,65 +1,63 @@
 require_relative '../../spec_helper'
 require_relative 'fixtures/classes'
 
-ruby_version_is "3.2" do
-  describe "Data#to_h" do
-    it "transforms the data object into a hash" do
+describe "Data#to_h" do
+  it "transforms the data object into a hash" do
+    data = DataSpecs::Measure.new(amount: 42, unit: 'km')
+    data.to_h.should == { amount: 42, unit: 'km' }
+  end
+
+  context "with block" do
+    it "transforms [key, value] pairs returned by the block into a hash" do
       data = DataSpecs::Measure.new(amount: 42, unit: 'km')
-      data.to_h.should == { amount: 42, unit: 'km' }
+      data.to_h { |key, value| [value, key] }.should == { 42 => :amount, 'km' => :unit }
     end
 
-    context "with block" do
-      it "transforms [key, value] pairs returned by the block into a hash" do
-        data = DataSpecs::Measure.new(amount: 42, unit: 'km')
-        data.to_h { |key, value| [value, key] }.should == { 42 => :amount, 'km' => :unit }
-      end
-
-      it "passes to a block each pair's key and value as separate arguments" do
-        ScratchPad.record []
-        data = DataSpecs::Measure.new(amount: 42, unit: 'km')
-        data.to_h { |k, v| ScratchPad << [k, v]; [k, v] }
-        ScratchPad.recorded.sort.should == [[:amount, 42], [:unit, 'km']]
+    it "passes to a block each pair's key and value as separate arguments" do
+      ScratchPad.record []
+      data = DataSpecs::Measure.new(amount: 42, unit: 'km')
+      data.to_h { |k, v| ScratchPad << [k, v]; [k, v] }
+      ScratchPad.recorded.sort.should == [[:amount, 42], [:unit, 'km']]
 
-        ScratchPad.record []
-        data.to_h { |*args| ScratchPad << args; [args[0], args[1]] }
-        ScratchPad.recorded.sort.should == [[:amount, 42], [:unit, 'km']]
-      end
+      ScratchPad.record []
+      data.to_h { |*args| ScratchPad << args; [args[0], args[1]] }
+      ScratchPad.recorded.sort.should == [[:amount, 42], [:unit, 'km']]
+    end
 
-      it "raises ArgumentError if block returns longer or shorter array" do
-        data = DataSpecs::Measure.new(amount: 42, unit: 'km')
-        -> do
-          data.to_h { |k, v| [k.to_s, v*v, 1] }
-        end.should raise_error(ArgumentError, /element has wrong array length/)
+    it "raises ArgumentError if block returns longer or shorter array" do
+      data = DataSpecs::Measure.new(amount: 42, unit: 'km')
+      -> do
+        data.to_h { |k, v| [k.to_s, v*v, 1] }
+      end.should raise_error(ArgumentError, /element has wrong array length/)
 
-        -> do
-          data.to_h { |k, v| [k] }
-        end.should raise_error(ArgumentError, /element has wrong array length/)
-      end
+      -> do
+        data.to_h { |k, v| [k] }
+      end.should raise_error(ArgumentError, /element has wrong array length/)
+    end
 
-      it "raises TypeError if block returns something other than Array" do
-        data = DataSpecs::Measure.new(amount: 42, unit: 'km')
-        -> do
-          data.to_h { |k, v| "not-array" }
-        end.should raise_error(TypeError, /wrong element type String/)
-      end
+    it "raises TypeError if block returns something other than Array" do
+      data = DataSpecs::Measure.new(amount: 42, unit: 'km')
+      -> do
+        data.to_h { |k, v| "not-array" }
+      end.should raise_error(TypeError, /wrong element type String/)
+    end
 
-      it "coerces returned pair to Array with #to_ary" do
-        x = mock('x')
-        x.stub!(:to_ary).and_return([:b, 'b'])
-        data = DataSpecs::Measure.new(amount: 42, unit: 'km')
+    it "coerces returned pair to Array with #to_ary" do
+      x = mock('x')
+      x.stub!(:to_ary).and_return([:b, 'b'])
+      data = DataSpecs::Measure.new(amount: 42, unit: 'km')
 
-        data.to_h { |k| x }.should == { :b => 'b' }
-      end
+      data.to_h { |k| x }.should == { :b => 'b' }
+    end
 
-      it "does not coerce returned pair to Array with #to_a" do
-        x = mock('x')
-        x.stub!(:to_a).and_return([:b, 'b'])
-        data = DataSpecs::Measure.new(amount: 42, unit: 'km')
+    it "does not coerce returned pair to Array with #to_a" do
+      x = mock('x')
+      x.stub!(:to_a).and_return([:b, 'b'])
+      data = DataSpecs::Measure.new(amount: 42, unit: 'km')
 
-        -> do
-          data.to_h { |k| x }
-        end.should raise_error(TypeError, /wrong element type MockObject/)
-      end
+      -> do
+        data.to_h { |k| x }
+      end.should raise_error(TypeError, /wrong element type MockObject/)
     end
   end
 end
diff --git a/spec/ruby/core/data/to_s_spec.rb b/spec/ruby/core/data/to_s_spec.rb
index 0b9099f035..2b4a670e8e 100644
--- a/spec/ruby/core/data/to_s_spec.rb
+++ b/spec/ruby/core/data/to_s_spec.rb
@@ -1,8 +1,6 @@
 require_relative '../../spec_helper'
 require_relative 'shared/inspect'
 
-ruby_version_is "3.2" do
-  describe "Data#to_s" do
-    it_behaves_like :data_inspect, :to_s
-  end
+describe "Data#to_s" do
+  it_behaves_like :data_inspect, :to_s
 end
diff --git a/spec/ruby/core/data/with_spec.rb b/spec/ruby/core/data/with_spec.rb
index 97e34c951f..9cd2d57335 100644
--- a/spec/ruby/core/data/with_spec.rb
+++ b/spec/ruby/core/data/with_spec.rb
@@ -1,35 +1,33 @@
 require_relative '../../spec_helper'
 require_relative 'fixtures/classes'
 
-ruby_version_is "3.2" do
-  describe "Data#with" do
-    it "returns self if given no arguments" do
-      data = DataSpecs::Measure.new(amount: 42, unit: "km")
-      data = data.with.should.equal?(data)
-    end
+describe "Data#with" do
+  it "returns self if given no arguments" do
+    data = DataSpecs::Measure.new(amount: 42, unit: "km")
+    data = data.with.should.equal?(data)
+  end
 
-    it "accepts keyword arguments" do
-      data = DataSpecs::Measure.new(amount: 42, unit: "km")
-      data = data.with(amount: 4, unit: "m")
+  it "accepts keyword arguments" do
+    data = DataSpecs::Measure.new(amount: 42, unit: "km")
+    data = data.with(amount: 4, unit: "m")
 
-      data.amount.should == 4
-      data.unit.should == "m"
-    end
+    data.amount.should == 4
+    data.unit.should == "m"
+  end
 
-    it "accepts String keyword arguments" do
-      data = DataSpecs::Measure.new(amount: 42, unit: "km")
-      data = data.with("amount" => 4, "unit" => "m")
+  it "accepts String keyword arguments" do
+    data = DataSpecs::Measure.new(amount: 42, unit: "km")
+    data = data.with("amount" => 4, "unit" => "m")
 
-      data.amount.should == 4
-      data.unit.should == "m"
-    end
+    data.amount.should == 4
+    data.unit.should == "m"
+  end
 
-    it "raises ArgumentError if no keyword arguments are given" do
-      data = DataSpecs::Measure.new(amount: 42, unit: "km")
+  it "raises ArgumentError if no keyword arguments are given" do
+    data = DataSpecs::Measure.new(amount: 42, unit: "km")
 
-      -> {
-        data.with(4, "m")
-      }.should raise_error(ArgumentError, "wrong number of arguments (given 2, expected 0)")
-    end
+    -> {
+      data.with(4, "m")
+    }.should raise_error(ArgumentError, "wrong number of arguments (given 2, expected 0)")
   end
 end
diff --git a/spec/ruby/core/dir/chdir_spec.rb b/spec/ruby/core/dir/chdir_spec.rb
index 1da9307599..015386a902 100644
--- a/spec/ruby/core/dir/chdir_spec.rb
+++ b/spec/ruby/core/dir/chdir_spec.rb
@@ -177,7 +177,7 @@ ruby_version_is '3.3' do
       dir.close
     end
 
-    guard -> { Dir.respond_to? :fchdir } do
+    platform_is_not :windows do
       it "does not raise an Errno::ENOENT if the original directory no longer exists" do
         dir_name1 = tmp('testdir1')
         dir_name2 = tmp('testdir2')
diff --git a/spec/ruby/core/dir/close_spec.rb b/spec/ruby/core/dir/close_spec.rb
index 5fbf5fcaf2..f7cce318b8 100644
--- a/spec/ruby/core/dir/close_spec.rb
+++ b/spec/ruby/core/dir/close_spec.rb
@@ -14,7 +14,7 @@ describe "Dir#close" do
     dir.close.should == nil
     dir.close.should == nil
 
-    guard -> { dir.respond_to? :fileno } do
+    platform_is_not :windows do
       -> { dir.fileno }.should raise_error(IOError, /closed directory/)
     end
   end
@@ -25,7 +25,7 @@ describe "Dir#close" do
   end
 
   ruby_version_is '3.3'...'3.4' do
-    guard -> { Dir.respond_to? :for_fd } do
+    platform_is_not :windows do
       it "does not raise an error even if the file descriptor is closed with another Dir instance" do
         dir = Dir.open DirSpecs.mock_dir
         dir_new = Dir.for_fd(dir.fileno)
@@ -40,7 +40,7 @@ describe "Dir#close" do
   end
 
   ruby_version_is '3.4' do
-    guard -> { Dir.respond_to? :for_fd } do
+    platform_is_not :windows do
       it "raises an error if the file descriptor is closed with another Dir instance" do
         dir = Dir.open DirSpecs.mock_dir
         dir_new = Dir.for_fd(dir.fileno)
diff --git a/spec/ruby/core/dir/exist_spec.rb b/spec/ruby/core/dir/exist_spec.rb
index 9023de533f..0b8e521894 100644
--- a/spec/ruby/core/dir/exist_spec.rb
+++ b/spec/ruby/core/dir/exist_spec.rb
@@ -14,10 +14,8 @@ describe "Dir.exist?" do
   it_behaves_like :dir_exist, :exist?
 end
 
-ruby_version_is "3.2" do
-  describe "Dir.exists?" do
-    it "has been removed" do
-      Dir.should_not.respond_to?(:exists?)
-    end
+describe "Dir.exists?" do
+  it "has been removed" do
+    Dir.should_not.respond_to?(:exists?)
   end
 end
diff --git a/spec/ruby/core/dir/fchdir_spec.rb b/spec/ruby/core/dir/fchdir_spec.rb
index d9dec13aab..52600a95f2 100644
--- a/spec/ruby/core/dir/fchdir_spec.rb
+++ b/spec/ruby/core/dir/fchdir_spec.rb
@@ -2,7 +2,7 @@ require_relative '../../spec_helper'
 require_relative 'fixtures/common'
 
 ruby_version_is '3.3' do
-  guard -> { Dir.respond_to? :fchdir } do
+  platform_is_not :windows do
     describe "Dir.fchdir" do
       before :all do
         DirSpecs.create_mock_dirs
@@ -62,7 +62,7 @@ ruby_version_is '3.3' do
     end
   end
 
-  guard_not -> { Dir.respond_to? :fchdir } do
+  platform_is :windows do
     describe "Dir.fchdir" do
       it "raises NotImplementedError" do
         -> { Dir.fchdir 1 }.should raise_error(NotImplementedError)
diff --git a/spec/ruby/core/dir/fixtures/common.rb b/spec/ruby/core/dir/fixtures/common.rb
index 087f46b331..848656c9b9 100644
--- a/spec/ruby/core/dir/fixtures/common.rb
+++ b/spec/ruby/core/dir/fixtures/common.rb
@@ -192,13 +192,7 @@ module DirSpecs
     ]
   end
 
-  if RUBY_VERSION > '3.1'
-    def self.expected_glob_paths
-      expected_paths - ['..']
-    end
-  else
-    def self.expected_glob_paths
-      expected_paths
-    end
+  def self.expected_glob_paths
+    expected_paths - ['..']
   end
 end
diff --git a/spec/ruby/core/dir/for_fd_spec.rb b/spec/ruby/core/dir/for_fd_spec.rb
index 3afcc7e949..ba467f2f86 100644
--- a/spec/ruby/core/dir/for_fd_spec.rb
+++ b/spec/ruby/core/dir/for_fd_spec.rb
@@ -3,7 +3,7 @@ require_relative 'fixtures/common'
 
 quarantine! do # leads to "Errno::EBADF: Bad file descriptor - closedir" in DirSpecs.delete_mock_dirs
 ruby_version_is '3.3' do
-  guard -> { Dir.respond_to? :for_fd } do
+  platform_is_not :windows do
     describe "Dir.for_fd" do
       before :all do
         DirSpecs.create_mock_dirs
@@ -68,7 +68,7 @@ ruby_version_is '3.3' do
     end
   end
 
-  guard_not -> { Dir.respond_to? :for_fd } do
+  platform_is :windows do
     describe "Dir.for_fd" do
       it "raises NotImplementedError" do
         -> { Dir.for_fd 1 }.should raise_error(NotImplementedError)
diff --git a/spec/ruby/core/dir/home_spec.rb b/spec/ruby/core/dir/home_spec.rb
index 6abd1a65df..966ac38af3 100644
--- a/spec/ruby/core/dir/home_spec.rb
+++ b/spec/ruby/core/dir/home_spec.rb
@@ -33,28 +33,26 @@ describe "Dir.home" do
     end
 
     platform_is :windows do
-      ruby_version_is "3.2" do
-        it "returns the home directory with forward slashs and as UTF-8" do
-          ENV['HOME'] = "C:\\rubyspäc\\home"
-          home = Dir.home
-          home.should == "C:/rubyspäc/home"
-          home.encoding.should == Encoding::UTF_8
-        end
+      it "returns the home directory with forward slashs and as UTF-8" do
+        ENV['HOME'] = "C:\\rubyspäc\\home"
+        home = Dir.home
+        home.should == "C:/rubyspäc/home"
+        home.encoding.should == Encoding::UTF_8
+      end
 
-        it "retrieves the directory from HOME, USERPROFILE, HOMEDRIVE/HOMEPATH and the WinAPI in that order" do
-          old_dirs = [ENV.delete('HOME'), ENV.delete('USERPROFILE'), ENV.delete('HOMEDRIVE'), ENV.delete('HOMEPATH')]
+      it "retrieves the directory from HOME, USERPROFILE, HOMEDRIVE/HOMEPATH and the WinAPI in that order" do
+        old_dirs = [ENV.delete('HOME'), ENV.delete('USERPROFILE'), ENV.delete('HOMEDRIVE'), ENV.delete('HOMEPATH')]
 
-          Dir.home.should == old_dirs[1].gsub("\\", "/")
-          ENV['HOMEDRIVE'] = "C:"
-          ENV['HOMEPATH'] = "\\rubyspec\\home1"
-          Dir.home.should == "C:/rubyspec/home1"
-          ENV['USERPROFILE'] = "C:\\rubyspec\\home2"
-          Dir.home.should == "C:/rubyspec/home2"
-          ENV['HOME'] = "C:\\rubyspec\\home3"
-          Dir.home.should == "C:/rubyspec/home3"
-        ensure
-          ENV['HOME'], ENV['USERPROFILE'], ENV['HOMEDRIVE'], ENV['HOMEPATH'] = *old_dirs
-        end
+        Dir.home.should == old_dirs[1].gsub("\\", "/")
+        ENV['HOMEDRIVE'] = "C:"
+        ENV['HOMEPATH'] = "\\rubyspec\\home1"
+        Dir.home.should == "C:/rubyspec/home1"
+        ENV['USERPROFILE'] = "C:\\rubyspec\\home2"
+        Dir.home.should == "C:/rubyspec/home2"
+        ENV['HOME'] = "C:\\rubyspec\\home3"
+        Dir.home.should == "C:/rubyspec/home3"
+      ensure
+        ENV['HOME'], ENV['USERPROFILE'], ENV['HOMEDRIVE'], ENV['HOMEPATH'] = *old_dirs
       end
     end
   end
diff --git a/spec/ruby/core/encoding/replicate_spec.rb b/spec/ruby/core/encoding/replicate_spec.rb
index e22673db7d..8d6f843fdf 100644
--- a/spec/ruby/core/encoding/replicate_spec.rb
+++ b/spec/ruby/core/encoding/replicate_spec.rb
@@ -67,7 +67,7 @@ describe "Encoding#replicate" do
     end
   end
 
-  ruby_version_is "3.2"..."3.3" do
+  ruby_version_is ""..."3.3" do
     it "warns about deprecation" do
       -> {
         Encoding::US_ASCII.replicate('MY-US-ASCII')
diff --git a/spec/ruby/core/enumerable/fixtures/classes.rb b/spec/ruby/core/enumerable/fixtures/classes.rb
index 2701c6999c..e30b57d294 100644
--- a/spec/ruby/core/enumerable/fixtures/classes.rb
+++ b/spec/ruby/core/enumerable/fixtures/classes.rb
@@ -343,9 +343,6 @@ module EnumerableSpecs
     end
   end
 
-  # Set is a core class since Ruby 3.2
-  ruby_version_is '3.2' do
-    class SetSubclass < Set
-    end
+  class SetSubclass < Set
   end
 end # EnumerableSpecs utility classes
diff --git a/spec/ruby/core/enumerable/shared/inject.rb b/spec/ruby/core/enumerable/shared/inject.rb
index 92f220efa4..aae9e06c97 100644
--- a/spec/ruby/core/enumerable/shared/inject.rb
+++ b/spec/ruby/core/enumerable/shared/inject.rb
@@ -135,10 +135,8 @@ describe :enumerable_inject, shared: true do
     actual.sort_by(&:to_s).should == expected.sort_by(&:to_s)
   end
 
-  ruby_bug '#18635', ''...'3.2' do
-    it "raises an ArgumentError when no parameters or block is given" do
-      -> { [1,2].send(@method) }.should raise_error(ArgumentError)
-      -> { {one: 1, two: 2}.send(@method) }.should raise_error(ArgumentError)
-    end
+  it "raises an ArgumentError when no parameters or block is given" do
+    -> { [1,2].send(@method) }.should raise_error(ArgumentError)
+    -> { {one: 1, two: 2}.send(@method) }.should raise_error(ArgumentError)
   end
 end
diff --git a/spec/ruby/core/enumerable/to_set_spec.rb b/spec/ruby/core/enumerable/to_set_spec.rb
index c21a2772c4..966baae1d9 100644
--- a/spec/ruby/core/enumerable/to_set_spec.rb
+++ b/spec/ruby/core/enumerable/to_set_spec.rb
@@ -1,29 +1,27 @@
 require_relative '../../spec_helper'
 require_relative 'fixtures/classes'
 
-ruby_version_is "3.2" do
-  describe "Enumerable#to_set" do
-    it "returns a new Set created from self" do
-      [1, 2, 3].to_set.should == Set[1, 2, 3]
-      {a: 1, b: 2}.to_set.should == Set[[:b, 2], [:a, 1]]
-    end
+describe "Enumerable#to_set" do
+  it "returns a new Set created from self" do
+    [1, 2, 3].to_set.should == Set[1, 2, 3]
+    {a: 1, b: 2}.to_set.should == Set[[:b, 2], [:a, 1]]
+  end
 
-    it "passes down passed blocks" do
-      [1, 2, 3].to_set { |x| x * x }.should == Set[1, 4, 9]
-    end
+  it "passes down passed blocks" do
+    [1, 2, 3].to_set { |x| x * x }.should == Set[1, 4, 9]
+  end
 
-    it "instantiates an object of provided as the first argument set class" do
-      set = [1, 2, 3].to_set(EnumerableSpecs::SetSubclass)
-      set.should be_kind_of(EnumerableSpecs::SetSubclass)
-      set.to_a.sort.should == [1, 2, 3]
-    end
+  it "instantiates an object of provided as the first argument set class" do
+    set = [1, 2, 3].to_set(EnumerableSpecs::SetSubclass)
+    set.should be_kind_of(EnumerableSpecs::SetSubclass)
+    set.to_a.sort.should == [1, 2, 3]
+  end
 
-    it "does not need explicit `require 'set'`" do
-      output = ruby_exe(<<~RUBY, options: '--disable-gems', args: '2>&1')
-        puts [1, 2, 3].to_set
-      RUBY
+  it "does not need explicit `require 'set'`" do
+    output = ruby_exe(<<~RUBY, options: '--disable-gems', args: '2>&1')
+      puts [1, 2, 3].to_set
+    RUBY
 
-      output.chomp.should == "#<Set: {1, 2, 3}>"
-    end
+    output.chomp.should == "#<Set: {1, 2, 3}>"
   end
 end
diff --git a/spec/ruby/core/enumerator/product/each_spec.rb b/spec/ruby/core/enumerator/product/each_spec.rb
index cabeb9d93a..88f115a712 100644
--- a/spec/ruby/core/enumerator/product/each_spec.rb
+++ b/spec/ruby/core/enumerator/product/each_spec.rb
@@ -1,73 +1,71 @@
 require_relative '../../../spec_helper'
 require_relative '../../enumerable/shared/enumeratorized'
 
-ruby_version_is "3.2" do
-  describe "Enumerator::Product#each" do
-    it_behaves_like :enumeratorized_with_origin_size, :each, Enumerator::Product.new([1, 2], [:a, :b])
+describe "Enumerator::Product#each" do
+  it_behaves_like :enumeratorized_with_origin_size, :each, Enumerator::Product.new([1, 2], [:a, :b])
 
-    it "yields each element of Cartesian product of enumerators" do
-      enum = Enumerator::Product.new([1, 2], [:a, :b])
-      acc = []
-      enum.each { |e| acc << e }
-      acc.should == [[1, :a], [1, :b], [2, :a], [2, :b]]
-    end
-
-    it "calls #each_entry method on enumerators" do
-      object1 = Object.new
-      def object1.each_entry
-        yield 1
-        yield 2
-      end
-
-      object2 = Object.new
-      def object2.each_entry
-        yield :a
-        yield :b
-      end
+  it "yields each element of Cartesian product of enumerators" do
+    enum = Enumerator::Product.new([1, 2], [:a, :b])
+    acc = []
+    enum.each { |e| acc << e }
+    acc.should == [[1, :a], [1, :b], [2, :a], [2, :b]]
+  end
 
-      enum = Enumerator::Product.new(object1, object2)
-      acc = []
-      enum.each { |e| acc << e }
-      acc.should == [[1, :a], [1, :b], [2, :a], [2, :b]]
+  it "calls #each_entry method on enumerators" do
+    object1 = Object.new
+    def object1.each_entry
+      yield 1
+      yield 2
     end
 
-    it "raises a NoMethodError if the object doesn't respond to #each_entry" do
-      -> {
-        Enumerator::Product.new(Object.new).each {}
-      }.should raise_error(NoMethodError, /undefined method [`']each_entry' for/)
+    object2 = Object.new
+    def object2.each_entry
+      yield :a
+      yield :b
     end
 
-    it "returns enumerator if not given a block" do
-      enum = Enumerator::Product.new([1, 2], [:a, :b])
-      enum.each.should.kind_of?(Enumerator)
+    enum = Enumerator::Product.new(object1, object2)
+    acc = []
+    enum.each { |e| acc << e }
+    acc.should == [[1, :a], [1, :b], [2, :a], [2, :b]]
+  end
 
-      enum = Enumerator::Product.new([1, 2], [:a, :b])
-      enum.each.to_a.should == [[1, :a], [1, :b], [2, :a], [2, :b]]
-    end
+  it "raises a NoMethodError if the object doesn't respond to #each_entry" do
+    -> {
+      Enumerator::Product.new(Object.new).each {}
+    }.should raise_error(NoMethodError, /undefined method [`']each_entry' for/)
+  end
 
-    it "returns self if given a block" do
-      enum = Enumerator::Product.new([1, 2], [:a, :b])
-      enum.each {}.should.equal?(enum)
-    end
+  it "returns enumerator if not given a block" do
+    enum = Enumerator::Product.new([1, 2], [:a, :b])
+    enum.each.should.kind_of?(Enumerator)
 
-    it "doesn't accept arguments" do
-      Enumerator::Product.instance_method(:each).arity.should == 0
-    end
+    enum = Enumerator::Product.new([1, 2], [:a, :b])
+    enum.each.to_a.should == [[1, :a], [1, :b], [2, :a], [2, :b]]
+  end
 
-    it "yields each element to a block that takes multiple arguments" do
-      enum = Enumerator::Product.new([1, 2], [:a, :b])
+  it "returns self if given a block" do
+    enum = Enumerator::Product.new([1, 2], [:a, :b])
+    enum.each {}.should.equal?(enum)
+  end
 
-      acc = []
-      enum.each { |x, y| acc << x }
-      acc.should == [1, 1, 2, 2]
+  it "doesn't accept arguments" do
+    Enumerator::Product.instance_method(:each).arity.should == 0
+  end
 
-      acc = []
-      enum.each { |x, y| acc << y }
-      acc.should == [:a, :b, :a, :b]
+  it "yields each element to a block that takes multiple arguments" do
+    enum = Enumerator::Product.new([1, 2], [:a, :b])
 
-      acc = []
-      enum.each { |x, y, z| acc << z }
-      acc.should == [nil, nil, nil, nil]
-    end
+    acc = []
+    enum.each { |x, y| acc << x }
+    acc.should == [1, 1, 2, 2]
+
+    acc = []
+    enum.each { |x, y| acc << y }
+    acc.should == [:a, :b, :a, :b]
+
+    acc = []
+    enum.each { |x, y, z| acc << z }
+    acc.should == [nil, nil, nil, nil]
   end
 end
diff --git a/spec/ruby/core/enumerator/product/initialize_copy_spec.rb b/spec/ruby/core/enumerator/product/initialize_copy_spec.rb
index 46e8421322..b1b9f3ca9b 100644
--- a/spec/ruby/core/enumerator/product/initialize_copy_spec.rb
+++ b/spec/ruby/core/enumerator/product/initialize_copy_spec.rb
@@ -1,54 +1,52 @@
 require_relative '../../../spec_helper'
 
-ruby_version_is "3.2" do
-  describe "Enumerator::Product#initialize_copy" do
-    it "replaces content of the receiver with content of the other object" do
-      enum = Enumerator::Product.new([true, false])
-      enum2 = Enumerator::Product.new([1, 2], [:a, :b])
+describe "Enumerator::Product#initialize_copy" do
+  it "replaces content of the receiver with content of the other object" do
+    enum = Enumerator::Product.new([true, false])
+    enum2 = Enumerator::Product.new([1, 2], [:a, :b])
 
-      enum.send(:initialize_copy, enum2)
-      enum.each.to_a.should == [[1, :a], [1, :b], [2, :a], [2, :b]]
-    end
+    enum.send(:initialize_copy, enum2)
+    enum.each.to_a.should == [[1, :a], [1, :b], [2, :a], [2, :b]]
+  end
 
-    it "returns self" do
-      enum = Enumerator::Product.new([true, false])
-      enum2 = Enumerator::Product.new([1, 2], [:a, :b])
+  it "returns self" do
+    enum = Enumerator::Product.new([true, false])
+    enum2 = Enumerator::Product.new([1, 2], [:a, :b])
 
-      enum.send(:initialize_copy, enum2).should.equal?(enum)
-    end
+    enum.send(:initialize_copy, enum2).should.equal?(enum)
+  end
 
-    it "is a private method" do
-      Enumerator::Product.should have_private_instance_method(:initialize_copy, false)
-    end
+  it "is a private method" do
+    Enumerator::Product.should have_private_instance_method(:initialize_copy, false)
+  end
 
-    it "does nothing if the argument is the same as the receiver" do
-      enum = Enumerator::Product.new(1..2)
-      enum.send(:initialize_copy, enum).should.equal?(enum)
+  it "does nothing if the argument is the same as the receiver" do
+    enum = Enumerator::Product.new(1..2)
+    enum.send(:initialize_copy, enum).should.equal?(enum)
 
-      enum.freeze
-      enum.send(:initialize_copy, enum).should.equal?(enum)
-    end
+    enum.freeze
+    enum.send(:initialize_copy, enum).should.equal?(enum)
+  end
 
-    it "raises FrozenError if the receiver is frozen" do
-      enum = Enumerator::Product.new(1..2)
-      enum2 = Enumerator::Product.new(3..4)
+  it "raises FrozenError if the receiver is frozen" do
+    enum = Enumerator::Product.new(1..2)
+    enum2 = Enumerator::Product.new(3..4)
 
-      -> { enum.freeze.send(:initialize_copy, enum2) }.should raise_error(FrozenError)
-    end
+    -> { enum.freeze.send(:initialize_copy, enum2) }.should raise_error(FrozenError)
+  end
 
-    it "raises TypeError if the objects are of different class" do
-      enum = Enumerator::Product.new(1..2)
-      enum2 = Class.new(Enumerator::Product).new(3..4)
+  it "raises TypeError if the objects are of different class" do
+    enum = Enumerator::Product.new(1..2)
+    enum2 = Class.new(Enumerator::Product).new(3..4)
 
-      -> { enum.send(:initialize_copy, enum2) }.should raise_error(TypeError, 'initialize_copy should take same class object')
-      -> { enum2.send(:initialize_copy, enum) }.should raise_error(TypeError, 'initialize_copy should take same class object')
-    end
+    -> { enum.send(:initialize_copy, enum2) }.should raise_error(TypeError, 'initialize_copy should take same class object')
+    -> { enum2.send(:initialize_copy, enum) }.should raise_error(TypeError, 'initialize_copy should take same class object')
+  end
 
-    it "raises ArgumentError if the argument is not initialized yet" do
-      enum = Enumerator::Product.new(1..2)
-      enum2 = Enumerator::Product.allocate
+  it "raises ArgumentError if the argument is not initialized yet" do
+    enum = Enumerator::Product.new(1..2)
+    enum2 = Enumerator::Product.allocate
 
-      -> { enum.send(:initialize_copy, enum2) }.should raise_error(ArgumentError, 'uninitialized product')
-    end
+    -> { enum.send(:initialize_copy, enum2) }.should raise_error(ArgumentError, 'uninitialized product')
   end
 end
diff --git a/spec/ruby/core/enumerator/product/initialize_spec.rb b/spec/ruby/core/enumerator/product/initialize_spec.rb
index 4b60564240..ed2a8a2a13 100644
--- a/spec/ruby/core/enumerator/product/initialize_spec.rb
+++ b/spec/ruby/core/enumerator/product/initialize_spec.rb
@@ -1,33 +1,31 @@
 require_relative '../../../spec_helper'
 
-ruby_version_is "3.2" do
-  describe "Enumerator::Product#initialize" do
-    before :each do
-      @uninitialized = Enumerator::Product.allocate
-    end
+describe "Enumerator::Product#initialize" do
+  before :each do
+    @uninitialized = Enumerator::Product.allocate
+  end
 
-    it "is a private method" do
-      Enumerator::Product.should have_private_instance_method(:initialize, false)
-    end
+  it "is a private method" do
+    Enumerator::Product.should have_private_instance_method(:initialize, false)
+  end
 
-    it "returns self" do
-      @uninitialized.send(:initialize).should equal(@uninitialized)
-    end
+  it "returns self" do
+    @uninitialized.send(:initialize).should equal(@uninitialized)
+  end
 
-    it "accepts many arguments" do
-      @uninitialized.send(:initialize, 0..1, 2..3, 4..5).should equal(@uninitialized)
-    end
+  it "accepts many arguments" do
+    @uninitialized.send(:initialize, 0..1, 2..3, 4..5).should equal(@uninitialized)
+  end
 
-    it "accepts arguments that are not Enumerable nor responding to :each_entry" do
-      @uninitialized.send(:initialize, Object.new).should equal(@uninitialized)
-    end
+  it "accepts arguments that are not Enumerable nor responding to :each_entry" do
+    @uninitialized.send(:initialize, Object.new).should equal(@uninitialized)
+  end
 
-    describe "on frozen instance" do
-      it "raises a FrozenError" do
-        -> {
-          @uninitialized.freeze.send(:initialize, 0..1)
-        }.should raise_error(FrozenError)
-      end
+  describe "on frozen instance" do
+    it "raises a FrozenError" do
+      -> {
+        @uninitialized.freeze.send(:initialize, 0..1)
+      }.should raise_error(FrozenError)
     end
   end
 end
diff --git a/spec/ruby/core/enumerator/product/inspect_spec.rb b/spec/ruby/core/enumerator/product/inspect_spec.rb
index 1ea8e9c49b..e0d7441f26 100644
--- a/spec/ruby/core/enumerator/product/inspect_spec.rb
+++ b/spec/ruby/core/enumerator/product/inspect_spec.rb
@@ -1,22 +1,20 @@
 require_relative '../../../spec_helper'
 
-ruby_version_is "3.2" do
-  describe "Enumerator::Product#inspect" do
-    it "returns a String including enumerators" do
-      enum = Enumerator::Product.new([1, 2], [:a, :b])
-      enum.inspect.should == "#<Enumerator::Product: [[1, 2], [:a, :b]]>"
-    end
+describe "Enumerator::Product#inspect" do
+  it "returns a String including enumerators" do
+    enum = Enumerator::Product.new([1, 2], [:a, :b])
+    enum.inspect.should == "#<Enumerator::Product: [[1, 2], [:a, :b]]>"
+  end
 
-    it "represents a recursive element with '[...]'" do
-      enum = [1, 2]
-      enum_recursive = Enumerator::Product.new(enum)
+  it "represents a recursive element with '[...]'" do
+    enum = [1, 2]
+    enum_recursive = Enumerator::Product.new(enum)
 
-      enum << enum_recursive
-      enum_recursive.inspect.should == "#<Enumerator::Product: [[1, 2, #<Enumerator::Product: ...>]]>"
-    end
+    enum << enum_recursive
+    enum_recursive.inspect.should == "#<Enumerator::Product: [[1, 2, #<Enumerator::Product: ...>]]>"
+  end
 
-    it "returns a not initialized representation if #initialized is not called yet" do
-      Enumerator::Product.allocate.inspect.should == "#<Enumerator::Product: uninitialized>"
-    end
+  it "returns a not initialized representation if #initialized is not called yet" do
+    Enumerator::Product.allocate.inspect.should == "#<Enumerator::Product: uninitialized>"
   end
 end
diff --git a/spec/ruby/core/enumerator/product/rewind_spec.rb b/spec/ruby/core/enumerator/product/rewind_spec.rb
index e8ee730239..2beffaf5c1 100644
--- a/spec/ruby/core/enumerator/product/rewind_spec.rb
+++ b/spec/ruby/core/enumerator/product/rewind_spec.rb
@@ -1,64 +1,62 @@
 require_relative '../../../spec_helper'
 
-ruby_version_is "3.2" do
-  describe "Enumerator::Product#rewind" do
-    before :each do
-      @enum = Enumerator::Product.new([1, 2].each.to_enum, [:a, :b].each.to_enum)
-    end
+describe "Enumerator::Product#rewind" do
+  before :each do
+    @enum = Enumerator::Product.new([1, 2].each.to_enum, [:a, :b].each.to_enum)
+  end
 
-    it "resets the enumerator to its initial state" do
-      @enum.each.to_a.should == [[1, :a], [1, :b], [2, :a], [2, :b]]
-      @enum.rewind
-      @enum.each.to_a.should == [[1, :a], [1, :b], [2, :a], [2, :b]]
-    end
+  it "resets the enumerator to its initial state" do
+    @enum.each.to_a.should == [[1, :a], [1, :b], [2, :a], [2, :b]]
+    @enum.rewind
+    @enum.each.to_a.should == [[1, :a], [1, :b], [2, :a], [2, :b]]
+  end
 
-    it "returns self" do
-      @enum.rewind.should.equal? @enum
-    end
+  it "returns self" do
+    @enum.rewind.should.equal? @enum
+  end
 
-    it "has no effect on a new enumerator" do
-      @enum.rewind
-      @enum.each.to_a.should == [[1, :a], [1, :b], [2, :a], [2, :b]]
-    end
+  it "has no effect on a new enumerator" do
+    @enum.rewind
+    @enum.each.to_a.should == [[1, :a], [1, :b], [2, :a], [2, :b]]
+  end
 
-    it "has no effect if called multiple, consecutive times" do
-      @enum.each.to_a.should == [[1, :a], [1, :b], [2, :a], [2, :b]]
-      @enum.rewind
-      @enum.rewind
-      @enum.each.to_a.should == [[1, :a], [1, :b], [2, :a], [2, :b]]
-    end
+  it "has no effect if called multiple, consecutive times" do
+    @enum.each.to_a.should == [[1, :a], [1, :b], [2, :a], [2, :b]]
+    @enum.rewind
+    @enum.rewind
+    @enum.each.to_a.should == [[1, :a], [1, :b], [2, :a], [2, :b]]
+  end
 
-    it "calls the enclosed object's rewind method if one exists" do
-      obj = mock('rewinder')
-      enum = Enumerator::Product.new(obj.to_enum)
+  it "calls the enclosed object's rewind method if one exists" do
+    obj = mock('rewinder')
+    enum = Enumerator::Product.new(obj.to_enum)
 
-      obj.should_receive(:rewind)
-      enum.rewind
-    end
+    obj.should_receive(:rewind)
+    enum.rewind
+  end
 
-    it "does nothing if the object doesn't have a #rewind method" do
-      obj = mock('rewinder')
-      enum = Enumerator::Product.new(obj.to_enum)
+  it "does nothing if the object doesn't have a #rewind method" do
+    obj = mock('rewinder')
+    enum = Enumerator::Product.new(obj.to_enum)
 
-      enum.rewind.should == enum
-    end
+    enum.rewind.should == enum
+  end
 
-    it "calls a rewind method on each enumerable in direct order" do
-      ScratchPad.record []
+  it "calls a rewind method on each enumerable in direct order" do
+    ScratchPad.record []
 
-      object1 = Object.new
-      def object1.rewind; ScratchPad << :object1; end
+    object1 = Object.new
+    def object1.rewind; ScratchPad << :object1; end
 
-      object2 = Object.new
-      def object2.rewind; ScratchPad << :object2; end
+    object2 = Object.new
+    def object2.rewind; ScratchPad << :object2; end
 
-      object3 = Object.new
-      def object3.rewind; ScratchPad << :object3; end
+    object3 = Object.new
+    def object3.rewind; ScratchPad << :object3; end
 
-      enum = Enumerator::Product.new(object1, object2, object3)
-      enum.rewind
+    enum = Enumerator::Product.new(object1, object2, object3)
+    enum.rewind
 
-      ScratchPad.recorded.should == [:object1, :object2, :object3]
-    end
+    ScratchPad.recorded.should == [:object1, :object2, :object3]
   end
 end
diff --git a/spec/ruby/core/enumerator/product/size_spec.rb b/spec/ruby/core/enumerator/product/size_spec.rb
index 46958b1a22..96632d6eee 100644
--- a/spec/ruby/core/enumerator/product/size_spec.rb
+++ b/spec/ruby/core/enumerator/product/size_spec.rb
@@ -1,56 +1,54 @@
 require_relative '../../../spec_helper'
 
-ruby_version_is "3.2" do
-  describe "Enumerator::Product#size" do
-    it "returns the total size of the enumerator product calculated by multiplying the sizes of enumerables in the product" do
-      product = Enumerator::Product.new(1..2, 1..3, 1..4)
-      product.size.should == 24 # 2 * 3 * 4
-    end
-
-    it "returns nil if any enumerable reports its size as nil" do
-      enum = Object.new
-      def enum.size; nil; end
-
-      product = Enumerator::Product.new(1..2, enum)
-      product.size.should == nil
-    end
-
-    it "returns Float::INFINITY if any enumerable reports its size as Float::INFINITY" do
-      enum = Object.new
-      def enum.size; Float::INFINITY; end
-
-      product = Enumerator::Product.new(1..2, enum)
-      product.size.should == Float::INFINITY
-    end
-
-    it "returns nil if any enumerable reports its size as Float::NAN" do
-      enum = Object.new
-      def enum.size; Float::NAN; end
-
-      product = Enumerator::Product.new(1..2, enum)
-      product.size.should == nil
-    end
-
-    it "returns nil if any enumerable doesn't respond to #size" do
-      enum = Object.new
-      product = Enumerator::Product.new(1..2, enum)
-      product.size.should == nil
-    end
-
-    it "returns nil if any enumerable reports a not-convertible to Integer" do
-      enum = Object.new
-      def enum.size; :symbol; end
-
-      product = Enumerator::Product.new(1..2, enum)
-      product.size.should == nil
-    end
-
-    it "returns nil if any enumerable reports a non-Integer but convertible to Integer size" do
-      enum = Object.new
-      def enum.size; 1.0; end
-
-      product = Enumerator::Product.new(1..2, enum)
-      product.size.should == nil
-    end
+describe "Enumerator::Product#size" do
+  it "returns the total size of the enumerator product calculated by multiplying the sizes of enumerables in the product" do
+    product = Enumerator::Product.new(1..2, 1..3, 1..4)
+    product.size.should == 24 # 2 * 3 * 4
+  end
+
+  it "returns nil if any enumerable reports its size as nil" do
+    enum = Object.new
+    def enum.size; nil; end
+
+    product = Enumerator::Product.new(1..2, enum)
+    product.size.should == nil
+  end
+
+  it "returns Float::INFINITY if any enumerable reports its size as Float::INFINITY" do
+    enum = Object.new
+    def enum.size; Float::INFINITY; end
+
+    product = Enumerator::Product.new(1..2, enum)
+    product.size.should == Float::INFINITY
+  end
+
+  it "returns nil if any enumerable reports its size as Float::NAN" do
+    enum = Object.new
+    def enum.size; Float::NAN; end
+
+    product = Enumerator::Product.new(1..2, enum)
+    product.size.should == nil
+  end
+
+  it "returns nil if any enumerable doesn't respond to #size" do
+    enum = Object.new
+    product = Enumerator::Product.new(1..2, enum)
+    product.size.should == nil
+  end
+
+  it "returns nil if any enumerable reports a not-convertible to Integer" do
+    enum = Object.new
+    def enum.size; :symbol; end
+
+    product = Enumerator::Product.new(1..2, enum)
+    product.size.should == nil
+  end
+
+  it "returns nil if any enumerable reports a non-Integer but convertible to Integer size" do
+    enum = Object.new
+    def enum.size; 1.0; end
+
+    product = Enumerator::Product.new(1..2, enum)
+    product.size.should == nil
   end
 end
diff --git a/spec/ruby/core/enumerator/product_spec.rb b/spec/ruby/core/enumerator/product_spec.rb
index 0acca6690e..83c7cb8e0e 100644
--- a/spec/ruby/core/enumerator/product_spec.rb
+++ b/spec/ruby/core/enumerator/product_spec.rb
@@ -1,93 +1,91 @@
 require_relative '../../spec_helper'
 
-ruby_version_is "3.2" do
-  describe "Enumerator.product" do
-    it "returns a Cartesian product of enumerators" do
-      enum = Enumerator.product(1..2, ["A", "B"])
-      enum.to_a.should == [[1, "A"], [1, "B"], [2, "A"], [2, "B"]]
-    end
-
-    it "accepts a list of enumerators of any length" do
-      enum = Enumerator.product(1..2)
-      enum.to_a.should == [[1], [2]]
+describe "Enumerator.product" do
+  it "returns a Cartesian product of enumerators" do
+    enum = Enumerator.product(1..2, ["A", "B"])
+    enum.to_a.should == [[1, "A"], [1, "B"], [2, "A"], [2, "B"]]
+  end
 
-      enum = Enumerator.product(1..2, ["A"])
-      enum.to_a.should == [[1, "A"], [2, "A"]]
+  it "accepts a list of enumerators of any length" do
+    enum = Enumerator.product(1..2)
+    enum.to_a.should == [[1], [2]]
 
-      enum = Enumerator.product(1..2, ["A"], ["B"])
-      enum.to_a.should == [[1, "A", "B"], [2, "A", "B"]]
+    enum = Enumerator.product(1..2, ["A"])
+    enum.to_a.should == [[1, "A"], [2, "A"]]
 
-      enum = Enumerator.product(2..3, ["A"], ["B"], ["C"])
-      enum.to_a.should == [[2, "A", "B", "C"], [3, "A", "B", "C"]]
-    end
+    enum = Enumerator.product(1..2, ["A"], ["B"])
+    enum.to_a.should == [[1, "A", "B"], [2, "A", "B"]]
 
-    it "returns an enumerator with an empty array when no arguments passed" do
-      enum = Enumerator.product
-      enum.to_a.should == [[]]
-    end
+    enum = Enumerator.product(2..3, ["A"], ["B"], ["C"])
+    enum.to_a.should == [[2, "A", "B", "C"], [3, "A", "B", "C"]]
+  end
 
-    it "returns an instance of Enumerator::Product" do
-      enum = Enumerator.product
-      enum.class.should == Enumerator::Product
-    end
+  it "returns an enumerator with an empty array when no arguments passed" do
+    enum = Enumerator.product
+    enum.to_a.should == [[]]
+  end
 
-    it "accepts infinite enumerators and returns infinite enumerator" do
-      enum = Enumerator.product(1.., ["A", "B"])
-      enum.take(5).should == [[1, "A"], [1, "B"], [2, "A"], [2, "B"], [3, "A"]]
-      enum.size.should == Float::INFINITY
-    end
+  it "returns an instance of Enumerator::Product" do
+    enum = Enumerator.product
+    enum.class.should == Enumerator::Product
+  end
 
-    it "accepts a block" do
-      elems = []
-      enum = Enumerator.product(1..2, ["X", "Y"]) { elems << _1 }
+  it "accepts infinite enumerators and returns infinite enumerator" do
+    enum = Enumerator.product(1.., ["A", "B"])
+    enum.take(5).should == [[1, "A"], [1, "B"], [2, "A"], [2, "B"], [3, "A"]]
+    enum.size.should == Float::INFINITY
+  end
 
-      elems.should == [[1, "X"], [1, "Y"], [2, "X"], [2, "Y"]]
-    end
+  it "accepts a block" do
+    elems = []
+    enum = Enumerator.product(1..2, ["X", "Y"]) { elems << _1 }
 
-    it "returns nil when a block passed" do
-      Enumerator.product(1..2) {}.should == nil
-    end
+    elems.should == [[1, "X"], [1, "Y"], [2, "X"], [2, "Y"]]
+  end
 
-    # https://bugs.ruby-lang.org/issues/19829
-    it "reject keyword arguments" do
-      -> {
-        Enumerator.product(1..3, foo: 1, bar: 2)
-      }.should raise_error(ArgumentError, "unknown keywords: :foo, :bar")
-    end
+  it "returns nil when a block passed" do
+    Enumerator.product(1..2) {}.should == nil
+  end
 
-    it "calls only #each_entry method on arguments" do
-      object = Object.new
-      def object.each_entry
-        yield 1
-        yield 2
-      end
+  # https://bugs.ruby-lang.org/issues/19829
+  it "reject keyword arguments" do
+    -> {
+      Enumerator.product(1..3, foo: 1, bar: 2)
+    }.should raise_error(ArgumentError, "unknown keywords: :foo, :bar")
+  end
 
-      enum = Enumerator.product(object, ["A", "B"])
-      enum.to_a.should == [[1, "A"], [1, "B"], [2, "A"], [2, "B"]]
+  it "calls only #each_entry method on arguments" do
+    object = Object.new
+    def object.each_entry
+      yield 1
+      yield 2
     end
 
-    it "raises NoMethodError when argument doesn't respond to #each_entry" do
-      -> {
-        Enumerator.product(Object.new).to_a
-      }.should raise_error(NoMethodError, /undefined method [`']each_entry' for/)
-    end
+    enum = Enumerator.product(object, ["A", "B"])
+    enum.to_a.should == [[1, "A"], [1, "B"], [2, "A"], [2, "B"]]
+  end
 
-    it "calls #each_entry lazily" do
-      Enumerator.product(Object.new).should be_kind_of(Enumerator)
-    end
+  it "raises NoMethodError when argument doesn't respond to #each_entry" do
+    -> {
+      Enumerator.product(Object.new).to_a
+    }.should raise_error(NoMethodError, /undefined method [`']each_entry' for/)
+  end
+
+  it "calls #each_entry lazily" do
+    Enumerator.product(Object.new).should be_kind_of(Enumerator)
+  end
 
-    it "iterates through consuming enumerator elements only once" do
-      a = [1, 2, 3]
-      i = 0
+  it "iterates through consuming enumerator elements only once" do
+    a = [1, 2, 3]
+    i = 0
 
-      enum = Enumerator.new do |y|
-        while i < a.size
-          y << a[i]
-          i += 1
-        end
+    enum = Enumerator.new do |y|
+      while i < a.size
+        y << a[i]
+        i += 1
       end
-
-      Enumerator.product(['a', 'b'], enum).to_a.should == [["a", 1], ["a", 2], ["a", 3]]
     end
+
+    Enumerator.product(['a', 'b'], enum).to_a.should == [["a", 1], ["a", 2], ["a", 3]]
   end
 end
diff --git a/spec/ruby/core/env/clone_spec.rb b/spec/ruby/core/env/clone_spec.rb
index 991e4e6774..01a29c6ab4 100644
--- a/spec/ruby/core/env/clone_spec.rb
+++ b/spec/ruby/core/env/clone_spec.rb
@@ -13,11 +13,9 @@ describe "ENV#clone" do
     }.should raise_error(ArgumentError)
   end
 
-  ruby_version_is "3.2" do
-    it "raises TypeError" do
-      -> {
-        ENV.clone
-      }.should raise_error(TypeError, /Cannot clone ENV, use ENV.to_h to get a copy of ENV as a hash/)
-    end
+  it "raises TypeError" do
+    -> {
+      ENV.clone
+    }.should raise_error(TypeError, /Cannot clone ENV, use ENV.to_h to get a copy of ENV as a hash/)
   end
 end
diff --git a/spec/ruby/core/env/shared/update.rb b/spec/ruby/core/env/shared/update.rb
index 7d4799955b..e1b1c9c290 100644
--- a/spec/ruby/core/env/shared/update.rb
+++ b/spec/ruby/core/env/shared/update.rb
@@ -15,12 +15,10 @@ describe :env_update, shared: true do
     ENV["bar"].should == "1"
   end
 
-  ruby_version_is "3.2" do
-    it "adds the multiple parameter hashes to ENV, returning ENV" do
-      ENV.send(@method, {"foo" => "multi1"}, {"bar" => "multi2"}).should equal(ENV)
-      ENV["foo"].should == "multi1"
-      ENV["bar"].should == "multi2"
-    end
+  it "adds the multiple parameter hashes to ENV, returning ENV" do
+    ENV.send(@method, {"foo" => "multi1"}, {"bar" => "multi2"}).should equal(ENV)
+    ENV["foo"].should == "multi1"
+    ENV["bar"].should == "multi2"
   end
 
   it "returns ENV when no block given" do
diff --git a/spec/ruby/core/exception/detailed_message_spec.rb b/spec/ruby/core/exception/detailed_message_spec.rb
index 8178278b2b..9df164a1cf 100644
--- a/spec/ruby/core/exception/detailed_message_spec.rb
+++ b/spec/ruby/core/exception/detailed_message_spec.rb
@@ -2,51 +2,49 @@ require_relative '../../spec_helper'
 require_relative 'fixtures/common'
 
 describe "Exception#detailed_message" do
-  ruby_version_is "3.2" do
-    it "returns decorated message" do
-      RuntimeError.new("new error").detailed_message.should == "new error (RuntimeError)"
-    end
+  it "returns decorated message" do
+    RuntimeError.new("new error").detailed_message.should == "new error (RuntimeError)"
+  end
 
-    it "is called by #full_message to allow message customization" do
-      exception = Exception.new("new error")
-      def exception.detailed_message(**)
-        "<prefix>#{message}<suffix>"
-      end
-      exception.full_message(highlight: false).should.include? "<prefix>new error<suffix>"
+  it "is called by #full_message to allow message customization" do
+    exception = Exception.new("new error")
+    def exception.detailed_message(**)
+      "<prefix>#{message}<suffix>"
     end
+    exception.full_message(highlight: false).should.include? "<prefix>new error<suffix>"
+  end
 
-    it "returns just a message if exception class is anonymous" do
-      Class.new(RuntimeError).new("message").detailed_message.should == "message"
-    end
+  it "returns just a message if exception class is anonymous" do
+    Class.new(RuntimeError).new("message").detailed_message.should == "message"
+  end
 
-    it "returns 'unhandled exception' for an instance of RuntimeError with empty message" do
-      RuntimeError.new("").detailed_message.should == "unhandled exception"
-    end
+  it "returns 'unhandled exception' for an instance of RuntimeError with empty message" do
+    RuntimeError.new("").detailed_message.should == "unhandled exception"
+  end
 
-    it "returns just class name for an instance other than RuntimeError with empty message" do
-      DetailedMessageSpec::C.new("").detailed_message.should == "DetailedMessageSpec::C"
-      StandardError.new("").detailed_message.should == "StandardError"
-    end
+  it "returns just class name for an instance other than RuntimeError with empty message" do
+    DetailedMessageSpec::C.new("").detailed_message.should == "DetailedMessageSpec::C"
+    StandardError.new("").detailed_message.should == "StandardError"
+  end
 
-    it "returns a generated class name for an instance of RuntimeError anonymous subclass with empty message" do
-      klass = Class.new(RuntimeError)
-      klass.new("").detailed_message.should =~ /\A#<Class:0x\h+>\z/
-    end
+  it "returns a generated class name for an instance of RuntimeError anonymous subclass with empty message" do
+    klass = Class.new(RuntimeError)
+    klass.new("").detailed_message.should =~ /\A#<Class:0x\h+>\z/
+  end
 
-    it "accepts highlight keyword argument and adds escape control sequences" do
-      RuntimeError.new("new error").detailed_message(highlight: true).should == "\e[1mnew error (\e[1;4mRuntimeError\e[m\e[1m)\e[m"
-    end
+  it "accepts highlight keyword argument and adds escape control sequences" do
+    RuntimeError.new("new error").detailed_message(highlight: true).should == "\e[1mnew error (\e[1;4mRuntimeError\e[m\e[1m)\e[m"
+  end
 
-    it "accepts highlight keyword argument and adds escape control sequences for an instance of RuntimeError with empty message" do
-      RuntimeError.new("").detailed_message(highlight: true).should == "\e[1;4munhandled exception\e[m"
-    end
+  it "accepts highlight keyword argument and adds escape control sequences for an instance of RuntimeError with empty message" do
+    RuntimeError.new("").detailed_message(highlight: true).should == "\e[1;4munhandled exception\e[m"
+  end
 
-    it "accepts highlight keyword argument and adds escape control sequences for an instance other than RuntimeError with empty message" do
-      StandardError.new("").detailed_message(highlight: true).should == "\e[1;4mStandardError\e[m"
-    end
+  it "accepts highlight keyword argument and adds escape control sequences for an instance other than RuntimeError with empty message" do
+    StandardError.new("").detailed_message(highlight: true).should == "\e[1;4mStandardError\e[m"
+  end
 
-    it "allows and ignores other keyword arguments" do
-      RuntimeError.new("new error").detailed_message(foo: true).should == "new error (RuntimeError)"
-    end
+  it "allows and ignores other keyword arguments" do
+    RuntimeError.new("new error").detailed_message(foo: true).should == "new error (RuntimeError)"
   end
 end
diff --git a/spec/ruby/core/exception/full_message_spec.rb b/spec/ruby/core/exception/full_message_spec.rb
index d752083db2..b07c6d4829 100644
--- a/spec/ruby/core/exception/full_message_spec.rb
+++ b/spec/ruby/core/exception/full_message_spec.rb
@@ -165,52 +165,50 @@ describe "Exception#full_message" do
     exception.full_message.should include "origin exception"
   end
 
-  ruby_version_is "3.2" do
-    it "relies on #detailed_message" do
-      e = RuntimeError.new("new error")
-      e.define_singleton_method(:detailed_message) { |**| "DETAILED MESSAGE" }
+  it "relies on #detailed_message" do
+    e = RuntimeError.new("new error")
+    e.define_singleton_method(:detailed_message) { |**| "DETAILED MESSAGE" }
 
-      e.full_message.lines.first.should =~ /DETAILED MESSAGE/
-    end
-
-    it "passes all its own keyword arguments (with :highlight default value and without :order default value) to #detailed_message" do
-      e = RuntimeError.new("new error")
-      options_passed = nil
-      e.define_singleton_method(:detailed_message) do |**options|
-        options_passed = options
-        "DETAILED MESSAGE"
-      end
+    e.full_message.lines.first.should =~ /DETAILED MESSAGE/
+  end
 
-      e.full_message(foo: "bar")
-      options_passed.should == { foo: "bar", highlight: Exception.to_tty? }
+  it "passes all its own keyword arguments (with :highlight default value and without :order default value) to #detailed_message" do
+    e = RuntimeError.new("new error")
+    options_passed = nil
+    e.define_singleton_method(:detailed_message) do |**options|
+      options_passed = options
+      "DETAILED MESSAGE"
     end
 
-    it "converts #detailed_message returned value to String if it isn't a String" do
-      message = Object.new
-      def message.to_str; "DETAILED MESSAGE"; end
+    e.full_message(foo: "bar")
+    options_passed.should == { foo: "bar", highlight: Exception.to_tty? }
+  end
 
-      e = RuntimeError.new("new error")
-      e.define_singleton_method(:detailed_message) { |**| message }
+  it "converts #detailed_message returned value to String if it isn't a String" do
+    message = Object.new
+    def message.to_str; "DETAILED MESSAGE"; end
 
-      e.full_message.lines.first.should =~ /DETAILED MESSAGE/
-    end
+    e = RuntimeError.new("new error")
+    e.define_singleton_method(:detailed_message) { |**| message }
 
-    it "uses class name if #detailed_message returns nil" do
-      e = RuntimeError.new("new error")
-      e.define_singleton_method(:detailed_message) { |**| nil }
+    e.full_message.lines.first.should =~ /DETAILED MESSAGE/
+  end
 
-      e.full_message(highlight: false).lines.first.should =~ /RuntimeError/
-      e.full_message(highlight: true).lines.first.should =~ /#{Regexp.escape("\e[1;4mRuntimeError\e[m")}/
-    end
+  it "uses class name if #detailed_message returns nil" do
+    e = RuntimeError.new("new error")
+    e.define_singleton_method(:detailed_message) { |**| nil }
 
-    it "uses class name if exception object doesn't respond to #detailed_message" do
-      e = RuntimeError.new("new error")
-      class << e
-        undef :detailed_message
-      end
+    e.full_message(highlight: false).lines.first.should =~ /RuntimeError/
+    e.full_message(highlight: true).lines.first.should =~ /#{Regexp.escape("\e[1;4mRuntimeError\e[m")}/
+  end
 
-      e.full_message(highlight: false).lines.first.should =~ /RuntimeError/
-      e.full_message(highlight: true).lines.first.should =~ /#{Regexp.escape("\e[1;4mRuntimeError\e[m")}/
+  it "uses class name if exception object doesn't respond to #detailed_message" do
+    e = RuntimeError.new("new error")
+    class << e
+      undef :detailed_message
     end
+
+    e.full_message(highlight: false).lines.first.should =~ /RuntimeError/
+    e.full_message(highlight: true).lines.first.should =~ /#{Regexp.escape("\e[1;4mRuntimeError\e[m")}/
   end
 end
diff --git a/spec/ruby/core/exception/syntax_error_spec.rb b/spec/ruby/core/exception/syntax_error_spec.rb
index 6cc8522de3..4c713a3507 100644
--- a/spec/ruby/core/exception/syntax_error_spec.rb
+++ b/spec/ruby/core/exception/syntax_error_spec.rb
@@ -1,27 +1,25 @@
 require_relative '../../spec_helper'
 
-ruby_version_is "3.2" do
-  describe "SyntaxError#path" do
-    it "returns the file path provided to eval" do
-      filename = "speccing.rb"
+describe "SyntaxError#path" do
+  it "returns the file path provided to eval" do
+    filename = "speccing.rb"
 
-      -> {
-        eval("if true", TOPLEVEL_BINDING, filename)
-      }.should raise_error(SyntaxError) { |e|
-        e.path.should == filename
-      }
-    end
+    -> {
+      eval("if true", TOPLEVEL_BINDING, filename)
+    }.should raise_error(SyntaxError) { |e|
+      e.path.should == filename
+    }
+  end
 
-    it "returns the file path that raised an exception" do
-      expected_path = fixture(__FILE__, "syntax_error.rb")
+  it "returns the file path that raised an exception" do
+    expected_path = fixture(__FILE__, "syntax_error.rb")
 
-      -> {
-        require_relative "fixtures/syntax_error"
-      }.should raise_error(SyntaxError) { |e| e.path.should == expected_path }
-    end
+    -> {
+      require_relative "fixtures/syntax_error"
+    }.should raise_error(SyntaxError) { |e| e.path.should == expected_path }
+  end
 
-    it "returns nil when constructed directly" do
-      SyntaxError.new.path.should == nil
-    end
+  it "returns nil when constructed directly" do
+    SyntaxError.new.path.should == nil
   end
 end
diff --git a/spec/ruby/core/fiber/blocking_spec.rb b/spec/ruby/core/fiber/blocking_spec.rb
index ed3c057516..d5caf81fbe 100644
--- a/spec/ruby/core/fiber/blocking_spec.rb
+++ b/spec/ruby/core/fiber/blocking_spec.rb
@@ -57,19 +57,17 @@ describe "Fiber#blocking?" do
   end
 end
 
-ruby_version_is "3.2" do
-  describe "Fiber.blocking" do
-    context "when fiber is non-blocking" do
-      it "can become blocking" do
-        fiber = Fiber.new(blocking: false) do
-          Fiber.blocking do |f|
-            f.blocking? ? :blocking : :non_blocking
-          end
+describe "Fiber.blocking" do
+  context "when fiber is non-blocking" do
+    it "can become blocking" do
+      fiber = Fiber.new(blocking: false) do
+        Fiber.blocking do |f|
+          f.blocking? ? :blocking : :non_blocking
         end
-
-        blocking = fiber.resume
-        blocking.should == :blocking
       end
+
+      blocking = fiber.resume
+      blocking.should == :blocking
     end
   end
 end
diff --git a/spec/ruby/core/fiber/storage_spec.rb b/spec/ruby/core/fiber/storage_spec.rb
index 03e9e3b822..3d39f32009 100644
--- a/spec/ruby/core/fiber/storage_spec.rb
+++ b/spec/ruby/core/fiber/storage_spec.rb
@@ -1,183 +1,179 @@
 require_relative '../../spec_helper'
 
-ruby_version_is "3.2" do
-  describe "Fiber.new(storage:)" do
-    it "creates a Fiber with the given storage" do
-      storage = {life: 42}
-      fiber = Fiber.new(storage: storage) { Fiber.current.storage }
-      fiber.resume.should == storage
-    end
+describe "Fiber.new(storage:)" do
+  it "creates a Fiber with the given storage" do
+    storage = {life: 42}
+    fiber = Fiber.new(storage: storage) { Fiber.current.storage }
+    fiber.resume.should == storage
+  end
 
-    it "creates a fiber with lazily initialized storage" do
-      Fiber.new(storage: nil) { Fiber[:x] = 10; Fiber.current.storage }.resume.should == {x: 10}
-    end
+  it "creates a fiber with lazily initialized storage" do
+    Fiber.new(storage: nil) { Fiber[:x] = 10; Fiber.current.storage }.resume.should == {x: 10}
+  end
 
-    it "creates a fiber by inheriting the storage of the parent fiber" do
-      fiber = Fiber.new(storage: {life: 42}) do
-        Fiber.new { Fiber.current.storage }.resume
-      end
-      fiber.resume.should == {life: 42}
+  it "creates a fiber by inheriting the storage of the parent fiber" do
+    fiber = Fiber.new(storage: {life: 42}) do
+      Fiber.new { Fiber.current.storage }.resume
     end
+    fiber.resume.should == {life: 42}
+  end
 
-    it "cannot create a fiber with non-hash storage" do
-      -> { Fiber.new(storage: 42) {} }.should raise_error(TypeError)
-    end
+  it "cannot create a fiber with non-hash storage" do
+    -> { Fiber.new(storage: 42) {} }.should raise_error(TypeError)
+  end
 
-    it "cannot create a fiber with a frozen hash as storage" do
-      -> { Fiber.new(storage: {life: 43}.freeze) {} }.should raise_error(FrozenError)
-    end
+  it "cannot create a fiber with a frozen hash as storage" do
+    -> { Fiber.new(storage: {life: 43}.freeze) {} }.should raise_error(FrozenError)
+  end
 
-    it "cannot create a fiber with a storage hash with non-symbol keys" do
-      -> { Fiber.new(storage: {life: 43, Object.new => 44}) {} }.should raise_error(TypeError)
-    end
+  it "cannot create a fiber with a storage hash with non-symbol keys" do
+    -> { Fiber.new(storage: {life: 43, Object.new => 44}) {} }.should raise_error(TypeError)
   end
+end
 
-  describe "Fiber#storage" do
-    it "cannot be accessed from a different fiber" do
-      f = Fiber.new(storage: {life: 42}) { nil }
-      -> {
-        f.storage
-      }.should raise_error(ArgumentError, /Fiber storage can only be accessed from the Fiber it belongs to/)
-    end
+describe "Fiber#storage" do
+  it "cannot be accessed from a different fiber" do
+    f = Fiber.new(storage: {life: 42}) { nil }
+    -> {
+      f.storage
+    }.should raise_error(ArgumentError, /Fiber storage can only be accessed from the Fiber it belongs to/)
   end
+end
 
-  describe "Fiber#storage=" do
-    it "can clear the storage of the fiber" do
-      fiber = Fiber.new(storage: {life: 42}) do
-        Fiber.current.storage = nil
-        Fiber[:x] = 10
-        Fiber.current.storage
-      end
-      fiber.resume.should == {x: 10}
+describe "Fiber#storage=" do
+  it "can clear the storage of the fiber" do
+    fiber = Fiber.new(storage: {life: 42}) do
+      Fiber.current.storage = nil
+      Fiber[:x] = 10
+      Fiber.current.storage
     end
+    fiber.resume.should == {x: 10}
+  end
 
-    it "can set the storage of the fiber" do
-      fiber = Fiber.new(storage: {life: 42}) do
-        Fiber.current.storage = {life: 43}
-        Fiber.current.storage
-      end
-      fiber.resume.should == {life: 43}
+  it "can set the storage of the fiber" do
+    fiber = Fiber.new(storage: {life: 42}) do
+      Fiber.current.storage = {life: 43}
+      Fiber.current.storage
     end
+    fiber.resume.should == {life: 43}
+  end
 
-    it "can't set the storage of the fiber to non-hash" do
-      -> { Fiber.current.storage = 42 }.should raise_error(TypeError)
-    end
+  it "can't set the storage of the fiber to non-hash" do
+    -> { Fiber.current.storage = 42 }.should raise_error(TypeError)
+  end
 
-    it "can't set the storage of the fiber to a frozen hash" do
-      -> { Fiber.current.storage = {life: 43}.freeze }.should raise_error(FrozenError)
-    end
+  it "can't set the storage of the fiber to a frozen hash" do
+    -> { Fiber.current.storage = {life: 43}.freeze }.should raise_error(FrozenError)
+  end
 
-    it "can't set the storage of the fiber to a hash with non-symbol keys" do
-      -> { Fiber.current.storage = {life: 43, Object.new => 44} }.should raise_error(TypeError)
-    end
+  it "can't set the storage of the fiber to a hash with non-symbol keys" do
+    -> { Fiber.current.storage = {life: 43, Object.new => 44} }.should raise_error(TypeError)
   end
+end
 
-  describe "Fiber.[]" do
-    it "returns the value of the given key in the storage of the current fiber" do
-      Fiber.new(storage: {life: 42}) { Fiber[:life] }.resume.should == 42
-    end
+describe "Fiber.[]" do
+  it "returns the value of the given key in the storage of the current fiber" do
+    Fiber.new(storage: {life: 42}) { Fiber[:life] }.resume.should == 42
+  end
 
-    it "returns nil if the key is not present in the storage of the current fiber" do
-      Fiber.new(storage: {life: 42}) { Fiber[:death] }.resume.should be_nil
-    end
+  it "returns nil if the key is not present in the storage of the current fiber" do
+    Fiber.new(storage: {life: 42}) { Fiber[:death] }.resume.should be_nil
+  end
+
+  it "returns nil if the current fiber has no storage" do
+    Fiber.new { Fiber[:life] }.resume.should be_nil
+  end
 
-    it "returns nil if the current fiber has no storage" do
-      Fiber.new { Fiber[:life] }.resume.should be_nil
+  it "can use dynamically defined keys" do
+    key = :"#{self.class.name}#.#{self.object_id}"
+    Fiber.new { Fiber[key] = 42; Fiber[key] }.resume.should == 42
+  end
+
+  it "can't use invalid keys" do
+    invalid_keys = [Object.new, 12]
+    invalid_keys.each do |key|
+      -> { Fiber[key] }.should raise_error(TypeError)
     end
+  end
 
-    ruby_version_is "3.2.3" do
-      it "can use dynamically defined keys" do
-        key = :"#{self.class.name}#.#{self.object_id}"
-        Fiber.new { Fiber[key] = 42; Fiber[key] }.resume.should == 42
-      end
-
-      it "can't use invalid keys" do
-        invalid_keys = [Object.new, 12]
-        invalid_keys.each do |key|
-          -> { Fiber[key] }.should raise_error(TypeError)
-        end
-      end
+  ruby_bug "#20978", ""..."3.4" do
+    it "can use keys as strings" do
+      key = Object.new
+      def key.to_str; "Foo"; end
+      Fiber.new { Fiber[key] = 42; Fiber["Foo"] }.resume.should == 42
     end
 
-    ruby_bug "#20978", "3.2"..."3.4" do
-      it "can use keys as strings" do
-        key = Object.new
-        def key.to_str; "Foo"; end
-        Fiber.new { Fiber[key] = 42; Fiber["Foo"] }.resume.should == 42
-      end
-
-      it "converts a String key into a Symbol" do
-        Fiber.new { Fiber["key"] = 42; Fiber[:key] }.resume.should == 42
-        Fiber.new { Fiber[:key] = 42; Fiber["key"] }.resume.should == 42
-      end
-
-      it "can use any object that responds to #to_str as a key" do
-        key = mock("key")
-        key.should_receive(:to_str).twice.and_return("key")
-        Fiber.new { Fiber[key] = 42; Fiber[key] }.resume.should == 42
-      end
+    it "converts a String key into a Symbol" do
+      Fiber.new { Fiber["key"] = 42; Fiber[:key] }.resume.should == 42
+      Fiber.new { Fiber[:key] = 42; Fiber["key"] }.resume.should == 42
     end
 
-    it "does not call #to_sym on the key" do
+    it "can use any object that responds to #to_str as a key" do
       key = mock("key")
-      key.should_not_receive(:to_sym)
-      -> { Fiber[key] }.should raise_error(TypeError)
+      key.should_receive(:to_str).twice.and_return("key")
+      Fiber.new { Fiber[key] = 42; Fiber[key] }.resume.should == 42
     end
+  end
 
-    it "can access the storage of the parent fiber" do
-      f = Fiber.new(storage: {life: 42}) do
-        Fiber.new { Fiber[:life] }.resume
-      end
-      f.resume.should == 42
-    end
+  it "does not call #to_sym on the key" do
+    key = mock("key")
+    key.should_not_receive(:to_sym)
+    -> { Fiber[key] }.should raise_error(TypeError)
+  end
 
-    it "can't access the storage of the fiber with non-symbol keys" do
-      -> { Fiber[Object.new] }.should raise_error(TypeError)
+  it "can access the storage of the parent fiber" do
+    f = Fiber.new(storage: {life: 42}) do
+      Fiber.new { Fiber[:life] }.resume
     end
+    f.resume.should == 42
   end
 
-  describe "Fiber.[]=" do
-    it "sets the value of the given key in the storage of the current fiber" do
-      Fiber.new(storage: {life: 42}) { Fiber[:life] = 43; Fiber[:life] }.resume.should == 43
-    end
+  it "can't access the storage of the fiber with non-symbol keys" do
+    -> { Fiber[Object.new] }.should raise_error(TypeError)
+  end
+end
 
-    it "sets the value of the given key in the storage of the current fiber" do
-      Fiber.new(storage: {life: 42}) { Fiber[:death] = 43; Fiber[:death] }.resume.should == 43
-    end
+describe "Fiber.[]=" do
+  it "sets the value of the given key in the storage of the current fiber" do
+    Fiber.new(storage: {life: 42}) { Fiber[:life] = 43; Fiber[:life] }.resume.should == 43
+  end
 
-    it "sets the value of the given key in the storage of the current fiber" do
-      Fiber.new { Fiber[:life] = 43; Fiber[:life] }.resume.should == 43
-    end
+  it "sets the value of the given key in the storage of the current fiber" do
+    Fiber.new(storage: {life: 42}) { Fiber[:death] = 43; Fiber[:death] }.resume.should == 43
+  end
 
-    it "does not overwrite the storage of the parent fiber" do
-      f = Fiber.new(storage: {life: 42}) do
-        Fiber.yield Fiber.new { Fiber[:life] = 43; Fiber[:life] }.resume
-        Fiber[:life]
-      end
-      f.resume.should == 43 # Value of the inner fiber
-      f.resume.should == 42 # Value of the outer fiber
-    end
+  it "sets the value of the given key in the storage of the current fiber" do
+    Fiber.new { Fiber[:life] = 43; Fiber[:life] }.resume.should == 43
+  end
 
-    it "can't access the storage of the fiber with non-symbol keys" do
-      -> { Fiber[Object.new] = 44 }.should raise_error(TypeError)
+  it "does not overwrite the storage of the parent fiber" do
+    f = Fiber.new(storage: {life: 42}) do
+      Fiber.yield Fiber.new { Fiber[:life] = 43; Fiber[:life] }.resume
+      Fiber[:life]
     end
+    f.resume.should == 43 # Value of the inner fiber
+    f.resume.should == 42 # Value of the outer fiber
+  end
+
+  it "can't access the storage of the fiber with non-symbol keys" do
+    -> { Fiber[Object.new] = 44 }.should raise_error(TypeError)
+  end
 
-    ruby_version_is "3.3" do
-      it "deletes the fiber storage key when assigning nil" do
-        Fiber.new(storage: {life: 42}) {
-          Fiber[:life] = nil
-          Fiber.current.storage
-        }.resume.should == {}
-      end
+  ruby_version_is "3.3" do
+    it "deletes the fiber storage key when assigning nil" do
+      Fiber.new(storage: {life: 42}) {
+        Fiber[:life] = nil
+        Fiber.current.storage
+      }.resume.should == {}
     end
   end
+end
 
-  describe "Thread.new" do
-    it "creates a thread with the storage of the current fiber" do
-      fiber = Fiber.new(storage: {life: 42}) do
-        Thread.new { Fiber.current.storage }.value
-      end
-      fiber.resume.should == {life: 42}
+describe "Thread.new" do
+  it "creates a thread with the storage of the current fiber" do
+    fiber = Fiber.new(storage: {life: 42}) do
+      Thread.new { Fiber.current.storage }.value
     end
+    fiber.resume.should == {life: 42}
   end
 end
diff --git a/spec/ruby/core/file/exist_spec.rb b/spec/ruby/core/file/exist_spec.rb
index 2633376880..b5600e5b07 100644
--- a/spec/ruby/core/file/exist_spec.rb
+++ b/spec/ruby/core/file/exist_spec.rb
@@ -5,10 +5,8 @@ describe "File.exist?" do
   it_behaves_like :file_exist, :exist?, File
 end
 
-ruby_version_is "3.2" do
-  describe "File.exists?" do
-    it "has been removed" do
-      File.should_not.respond_to?(:exists?)
-    end
+describe "File.exists?" do
+  it "has been removed" do
+    File.should_not.respond_to?(:exists?)
   end
 end
diff --git a/spec/ruby/core/filetest/exist_spec.rb b/spec/ruby/core/filetest/exist_spec.rb
index a95d3f91a1..612ffa9fcb 100644
--- a/spec/ruby/core/filetest/exist_spec.rb
+++ b/spec/ruby/core/filetest/exist_spec.rb
@@ -5,10 +5,8 @@ describe "FileTest.exist?" do
   it_behaves_like :file_exist, :exist?, FileTest
 end
 
-ruby_version_is "3.2" do
-  describe "FileTest.exists?" do
-    it "has been removed" do
-      FileTest.should_not.respond_to?(:exists?)
-    end
+describe "FileTest.exists?" do
+  it "has been removed" do
+    FileTest.should_not.respond_to?(:exists?)
   end
 end
diff --git a/spec/ruby/core/hash/shared/to_s.rb b/spec/ruby/core/hash/shared/to_s.rb
index 5f0a8f97fd..e116b8878b 100644
--- a/spec/ruby/core/hash/shared/to_s.rb
+++ b/spec/ruby/core/hash/shared/to_s.rb
@@ -84,4 +84,10 @@ describe :hash_to_s, shared: true do
     expected = ruby_version_is("3.4") ? "{true => false}" : "{true=>false}"
     { true => false }.to_s.should == expected
   end
+
+  ruby_version_is "3.4" do
+    it "adds quotes to symbol keys that are not valid symbol literals" do
+      { "needs-quotes": 1 }.send(@method).should == '{"needs-quotes": 1}'
+    end
+  end
 end
diff --git a/spec/ruby/core/hash/shift_spec.rb b/spec/ruby/core/hash/shift_spec.rb
index ea36488a04..3f31b9864c 100644
--- a/spec/ruby/core/hash/shift_spec.rb
+++ b/spec/ruby/core/hash/shift_spec.rb
@@ -30,45 +30,22 @@ describe "Hash#shift" do
     h.should == {}
   end
 
-  ruby_version_is '3.2' do
-    it "returns nil if the Hash is empty" do
-      h = {}
-      def h.default(key)
-        raise
-      end
-      h.shift.should == nil
-    end
-  end
-
-  ruby_version_is ''...'3.2' do
-    it "calls #default with nil if the Hash is empty" do
-      h = {}
-      def h.default(key)
-        key.should == nil
-        :foo
-      end
-      h.shift.should == :foo
+  it "returns nil if the Hash is empty" do
+    h = {}
+    def h.default(key)
+      raise
     end
+    h.shift.should == nil
   end
 
   it "returns nil from an empty hash" do
     {}.shift.should == nil
   end
 
-  ruby_version_is '3.2' do
-    it "returns nil for empty hashes with defaults and default procs" do
-      Hash.new(5).shift.should == nil
-      h = Hash.new { |*args| args }
-      h.shift.should == nil
-    end
-  end
-
-  ruby_version_is ''...'3.2' do
-    it "returns (computed) default for empty hashes" do
-      Hash.new(5).shift.should == 5
-      h = Hash.new { |*args| args }
-      h.shift.should == [h, nil]
-    end
+  it "returns nil for empty hashes with defaults and default procs" do
+    Hash.new(5).shift.should == nil
+    h = Hash.new { |*args| args }
+    h.shift.should == nil
   end
 
   it "preserves Hash invariants when removing the last item" do
diff --git a/spec/ruby/core/integer/ceildiv_spec.rb b/spec/ruby/core/integer/ceildiv_spec.rb
index 18d07c66d0..c6e22a457d 100644
--- a/spec/ruby/core/integer/ceildiv_spec.rb
+++ b/spec/ruby/core/integer/ceildiv_spec.rb
@@ -1,22 +1,20 @@
 require_relative '../../spec_helper'
 
 describe "Integer#ceildiv" do
-  ruby_version_is '3.2' do
-    it "returns a quotient of division which is rounded up to the nearest integer" do
-      0.ceildiv(3).should eql(0)
-      1.ceildiv(3).should eql(1)
-      3.ceildiv(3).should eql(1)
-      4.ceildiv(3).should eql(2)
+  it "returns a quotient of division which is rounded up to the nearest integer" do
+    0.ceildiv(3).should eql(0)
+    1.ceildiv(3).should eql(1)
+    3.ceildiv(3).should eql(1)
+    4.ceildiv(3).should eql(2)
 
-      4.ceildiv(-3).should eql(-1)
-      -4.ceildiv(3).should eql(-1)
-      -4.ceildiv(-3).should eql(2)
+    4.ceildiv(-3).should eql(-1)
+    -4.ceildiv(3).should eql(-1)
+    -4.ceildiv(-3).should eql(2)
 
-      3.ceildiv(1.2).should eql(3)
-      3.ceildiv(6/5r).should eql(3)
+    3.ceildiv(1.2).should eql(3)
+    3.ceildiv(6/5r).should eql(3)
 
-      (10**100-11).ceildiv(10**99-1).should eql(10)
-      (10**100-9).ceildiv(10**99-1).should eql(11)
-    end
+    (10**100-11).ceildiv(10**99-1).should eql(10)
+    (10**100-9).ceildiv(10**99-1).should eql(11)
   end
 end
diff --git a/spec/ruby/core/integer/constants_spec.rb b/spec/ruby/core/integer/constants_spec.rb
index 2077ad451e..937806c72f 100644
--- a/spec/ruby/core/integer/constants_spec.rb
+++ b/spec/ruby/core/integer/constants_spec.rb
@@ -1,41 +1,13 @@
 require_relative '../../spec_helper'
 
 describe "Fixnum" do
-  ruby_version_is ""..."3.2" do
-    it "is unified into Integer" do
-      suppress_warning do
-        Fixnum.should equal(Integer)
-      end
-    end
-
-    it "is deprecated" do
-      -> { Fixnum }.should complain(/constant ::Fixnum is deprecated/)
-    end
-  end
-
-  ruby_version_is "3.2" do
-    it "is no longer defined" do
-      Object.should_not.const_defined?(:Fixnum)
-    end
+  it "is no longer defined" do
+    Object.should_not.const_defined?(:Fixnum)
   end
 end
 
 describe "Bignum" do
-  ruby_version_is ""..."3.2" do
-    it "is unified into Integer" do
-      suppress_warning do
-        Bignum.should equal(Integer)
-      end
-    end
-
-    it "is deprecated" do
-      -> { Bignum }.should complain(/constant ::Bignum is deprecated/)
-    end
-  end
-
-  ruby_version_is "3.2" do
-    it "is no longer defined" do
-      Object.should_not.const_defined?(:Bignum)
-    end
+  it "is no longer defined" do
+    Object.should_not.const_defined?(:Bignum)
   end
 end
diff --git a/spec/ruby/core/integer/left_shift_spec.rb b/spec/ruby/core/integer/left_shift_spec.rb
index 0781371d93..86c2b18ae2 100644
--- a/spec/ruby/core/integer/left_shift_spec.rb
+++ b/spec/ruby/core/integer/left_shift_spec.rb
@@ -181,10 +181,8 @@ describe "Integer#<< (with n << m)" do
       (bignum_value << -(2**40)).should == 0
     end
 
-    ruby_bug "#18517", ""..."3.2" do
-      it "returns 0 when m > 0 long and n == 0" do
-        (0 << (2**40)).should == 0
-      end
+    it "returns 0 when m > 0 long and n == 0" do
+      (0 << (2**40)).should == 0
     end
 
     it "returns 0 when m > 0 bignum and n == 0" do
diff --git a/spec/ruby/core/integer/right_shift_spec.rb b/spec/ruby/core/integer/right_shift_spec.rb
index e91613d8d1..c902674e2f 100644
--- a/spec/ruby/core/integer/right_shift_spec.rb
+++ b/spec/ruby/core/integer/right_shift_spec.rb
@@ -203,10 +203,8 @@ describe "Integer#>> (with n >> m)" do
       (bignum_value >> (2**40)).should == 0
     end
 
-    ruby_bug "#18517", ""..."3.2" do
-      it "returns 0 when m < 0 long and n == 0" do
-        (0 >> -(2**40)).should == 0
-      end
+    it "returns 0 when m < 0 long and n == 0" do
+      (0 >> -(2**40)).should == 0
     end
 
     it "returns 0 when m < 0 bignum and n == 0" do
diff --git a/spec/ruby/core/io/path_spec.rb b/spec/ruby/core/io/path_spec.rb
index 8145c32f39..798adb2163 100644
--- a/spec/ruby/core/io/path_spec.rb
+++ b/spec/ruby/core/io/path_spec.rb
@@ -1,14 +1,12 @@
 require_relative '../../spec_helper'
 
 describe "IO#path" do
-  ruby_version_is "3.2" do
-    it "returns the path of the file associated with the IO object" do
-      path = tmp("io_path.txt")
-      File.open(path, "w") do |file|
-        IO.new(file.fileno, path: file.path, autoclose: false).path.should == file.path
-      end
-    ensure
-      File.unlink(path)
+  it "returns the path of the file associated with the IO object" do
+    path = tmp("io_path.txt")
+    File.open(path, "w") do |file|
+      IO.new(file.fileno, path: file.path, autoclose: false).path.should == file.path
     end
+  ensure
+    File.unlink(path)
   end
 end
diff --git a/spec/ruby/core/io/shared/each.rb b/spec/ruby/core/io/shared/each.rb
index aca622834f..0747f31b8a 100644
--- a/spec/ruby/core/io/shared/each.rb
+++ b/spec/ruby/core/io/shared/each.rb
@@ -202,20 +202,10 @@ describe :io_each, shared: true do
   end
 
   describe "when passed chomp and nil as a separator" do
-    ruby_version_is "3.2" do
-      it "yields self's content" do
-        @io.pos = 100
-        @io.send(@method, nil, chomp: true) { |s| ScratchPad << s }
-        ScratchPad.recorded.should == ["qui a linha cinco.\nHere is line six.\n"]
-      end
-    end
-
-    ruby_version_is ""..."3.2" do
-      it "yields self's content without trailing new line character" do
-        @io.pos = 100
-        @io.send(@method, nil, chomp: true) { |s| ScratchPad << s }
-        ScratchPad.recorded.should == ["qui a linha cinco.\nHere is line six."]
-      end
+    it "yields self's content" do
+      @io.pos = 100
+      @io.send(@method, nil, chomp: true) { |s| ScratchPad << s }
+      ScratchPad.recorded.should == ["qui a linha cinco.\nHere is line six.\n"]
     end
   end
 
diff --git a/spec/ruby/core/io/sysread_spec.rb b/spec/ruby/core/io/sysread_spec.rb
index 8851214283..d56a27b3af 100644
--- a/spec/ruby/core/io/sysread_spec.rb
+++ b/spec/ruby/core/io/sysread_spec.rb
@@ -131,9 +131,7 @@ describe "IO#sysread" do
     @read.sysread(3).should == "ab"
   end
 
-  guard_not -> { platform_is :windows and ruby_version_is ""..."3.2" } do # https://bugs.ruby-lang.org/issues/18880
-    it "raises ArgumentError when length is less than 0" do
-      -> { @read.sysread(-1) }.should raise_error(ArgumentError)
-    end
+  it "raises ArgumentError when length is less than 0" do
+    -> { @read.sysread(-1) }.should raise_error(ArgumentError)
   end
 end
diff --git a/spec/ruby/core/kernel/match_spec.rb b/spec/ruby/core/kernel/match_spec.rb
index aa25006163..cd6330fe91 100644
--- a/spec/ruby/core/kernel/match_spec.rb
+++ b/spec/ruby/core/kernel/match_spec.rb
@@ -1,30 +1,7 @@
 require_relative '../../spec_helper'
 
 describe "Kernel#=~" do
-  ruby_version_is ''...'3.2' do
-    it "returns nil matching any object" do
-      o = Object.new
-
-      suppress_warning do
-        (o =~ /Object/).should   be_nil
-        (o =~ 'Object').should   be_nil
-        (o =~ Object).should     be_nil
-        (o =~ Object.new).should be_nil
-        (o =~ nil).should        be_nil
-        (o =~ true).should       be_nil
-      end
-    end
-
-    it "is deprecated" do
-      -> do
-        Object.new =~ /regexp/
-      end.should complain(/deprecated Object#=~ is called on Object/, verbose: true)
-    end
-  end
-
-  ruby_version_is '3.2' do
-    it "is no longer defined" do
-      Object.new.should_not.respond_to?(:=~)
-    end
+  it "is no longer defined" do
+    Object.new.should_not.respond_to?(:=~)
   end
 end
diff --git a/spec/ruby/core/kernel/not_match_spec.rb b/spec/ruby/core/kernel/not_match_spec.rb
index f8dd82fad8..082e56fed7 100644
--- a/spec/ruby/core/kernel/not_match_spec.rb
+++ b/spec/ruby/core/kernel/not_match_spec.rb
@@ -14,18 +14,8 @@ describe "Kernel#!~" do
     (obj !~ :foo).should == false
   end
 
-  ruby_version_is ""..."3.2" do
-    it "returns true if self does not respond to #=~" do
-      suppress_warning do
-        (Object.new !~ :foo).should == true
-      end
-    end
-  end
-
-  ruby_version_is "3.2" do
-    it "raises NoMethodError if self does not respond to #=~" do
-      -> { Object.new !~ :foo }.should raise_error(NoMethodError)
-    end
+  it "raises NoMethodError if self does not respond to #=~" do
+    -> { Object.new !~ :foo }.should raise_error(NoMethodError)
   end
 
   it 'can be overridden in subclasses' do
diff --git a/spec/ruby/core/kernel/open_spec.rb b/spec/ruby/core/kernel/open_spec.rb
index bb42c31f31..6d00af395d 100644
--- a/spec/ruby/core/kernel/open_spec.rb
+++ b/spec/ruby/core/kernel/open_spec.rb
@@ -106,7 +106,7 @@ describe "Kernel#open" do
       ScratchPad.clear
     end
 
-    it "calls #to_path to covert the argument to a String before calling #to_str" do
+    it "calls #to_path to convert the argument to a String before calling #to_str" do
       obj = mock("open to_path")
       obj.should_receive(:to_path).at_least(1).times.and_return(@name)
       obj.should_not_receive(:to_str)
diff --git a/spec/ruby/core/kernel/shared/require.rb b/spec/ruby/core/kernel/shared/require.rb
index b31c89e3bf..52f86f73e5 100644
--- a/spec/ruby/core/kernel/shared/require.rb
+++ b/spec/ruby/core/kernel/shared/require.rb
@@ -296,6 +296,16 @@ describe :kernel_require, shared: true do
       $LOAD_PATH.replace [File.expand_path("b", CODE_LOADING_DIR), CODE_LOADING_DIR]
       @object.require("load_fixture").should be_false
     end
+
+    it "stores the missing path in a LoadError object" do
+      path = "abcd1234"
+
+      -> {
+        @object.send(@method, path)
+      }.should raise_error(LoadError) { |e|
+        e.path.should == path
+      }
+    end
   end
 
   describe "(file extensions)" do
@@ -815,4 +825,24 @@ describe :kernel_require, shared: true do
       e.path.should == path
     }
   end
+
+  platform_is :linux, :darwin do
+    it "does not store the missing path in a LoadError object when c-extension file exists but loading fails and passed absolute path without extension" do
+      # the error message is specific to what dlerror() returns
+      path = File.join CODE_LOADING_DIR, "a", "load_fixture"
+      -> { @object.send(@method, path) }.should raise_error(LoadError) { |e|
+        e.path.should == nil
+      }
+    end
+  end
+
+  platform_is :darwin do
+    it "does not store the missing path in a LoadError object when c-extension file exists but loading fails and passed absolute path with extension" do
+      # the error message is specific to what dlerror() returns
+      path = File.join CODE_LOADING_DIR, "a", "load_fixture.bundle"
+      -> { @object.send(@method, path) }.should raise_error(LoadError) { |e|
+        e.path.should == nil
+      }
+    end
+  end
 end
diff --git a/spec/ruby/core/kernel/shared/sprintf.rb b/spec/ruby/core/kernel/shared/sprintf.rb
index 13dc6e97f0..26bd189593 100644
--- a/spec/ruby/core/kernel/shared/sprintf.rb
+++ b/spec/ruby/core/kernel/shared/sprintf.rb
@@ -22,6 +22,7 @@ describe :kernel_sprintf, shared: true do
       @method.call("%d", "112").should == "112"
       @method.call("%d", "0127").should == "87"
       @method.call("%d", "0xc4").should == "196"
+      @method.call("%d", "0").should == "0"
     end
 
     it "raises TypeError exception if cannot convert to Integer" do
@@ -57,6 +58,11 @@ describe :kernel_sprintf, shared: true do
         it "works well with large numbers" do
           @method.call("%#{f}", 1234567890987654321).should == "1234567890987654321"
         end
+
+        it "converts to the empty string if precision is 0 and value is 0" do
+          @method.call("%.#{f}", 0).should == ""
+          @method.call("%.0#{f}", 0).should == ""
+        end
       end
     end
 
@@ -289,28 +295,12 @@ describe :kernel_sprintf, shared: true do
         @method.call("%c", "a").should == "a"
       end
 
-      ruby_version_is ""..."3.2" do
-        it "raises ArgumentError if argument is a string of several characters" do
-          -> {
-            @method.call("%c", "abc")
-          }.should raise_error(ArgumentError, /%c requires a character/)
-        end
-
-        it "raises ArgumentError if argument is an empty string" do
-          -> {
-            @method.call("%c", "")
-          }.should raise_error(ArgumentError, /%c requires a character/)
-        end
+      it "displays only the first character if argument is a string of several characters" do
+        @method.call("%c", "abc").should == "a"
       end
 
-      ruby_version_is "3.2" do
-        it "displays only the first character if argument is a string of several characters" do
-          @method.call("%c", "abc").should == "a"
-        end
-
-        it "displays no characters if argument is an empty string" do
-          @method.call("%c", "").should == ""
-        end
+      it "displays no characters if argument is an empty string" do
+        @method.call("%c", "").should == ""
       end
 
       it "raises TypeError if argument is not String or Integer and cannot be converted to them" do
diff --git a/spec/ruby/core/kernel/taint_spec.rb b/spec/ruby/core/kernel/taint_spec.rb
index 0c16b1dbbf..9a2efbaea0 100644
--- a/spec/ruby/core/kernel/taint_spec.rb
+++ b/spec/ruby/core/kernel/taint_spec.rb
@@ -2,26 +2,7 @@ require_relative '../../spec_helper'
 require_relative 'fixtures/classes'
 
 describe "Kernel#taint" do
-  ruby_version_is ""..."3.2" do
-    it "is a no-op" do
-      suppress_warning do
-        o = Object.new
-        o.taint
-        o.should_not.tainted?
-      end
-    end
-
-    it "warns in verbose mode" do
-      -> {
-        obj = mock("tainted")
-        obj.taint
-      }.should complain(/Object#taint is deprecated and will be removed in Ruby 3.2/, verbose: true)
-    end
-  end
-
-  ruby_version_is "3.2" do
-    it "has been removed" do
-      Object.new.should_not.respond_to?(:taint)
-    end
+  it "has been removed" do
+    Object.new.should_not.respond_to?(:taint)
   end
 end
diff --git a/spec/ruby/core/kernel/tainted_spec.rb b/spec/ruby/core/kernel/tainted_spec.rb
index fcae433069..837eb1dafb 100644
--- a/spec/ruby/core/kernel/tainted_spec.rb
+++ b/spec/ruby/core/kernel/tainted_spec.rb
@@ -2,28 +2,7 @@ require_relative '../../spec_helper'
 require_relative 'fixtures/classes'
 
 describe "Kernel#tainted?" do
-  ruby_version_is ""..."3.2" do
-    it "is a no-op" do
-      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
-      -> {
-        o = mock('o')
-        o.tainted?
-      }.should complain(/Object#tainted\? is deprecated and will be removed in Ruby 3.2/, verbose: true)
-    end
-  end
-
-  ruby_version_is "3.2" do
-    it "has been removed" do
-      Object.new.should_not.respond_to?(:tainted?)
-    end
+  it "has been removed" do
+    Object.new.should_not.respond_to?(:tainted?)
   end
 end
diff --git a/spec/ruby/core/kernel/trust_spec.rb b/spec/ruby/core/kernel/trust_spec.rb
index db6f17e0fb..ef3fa9a3e1 100644
--- a/spec/ruby/core/kernel/trust_spec.rb
+++ b/spec/ruby/core/kernel/trust_spec.rb
@@ -2,27 +2,7 @@ require_relative '../../spec_helper'
 require_relative 'fixtures/classes'
 
 describe "Kernel#trust" do
-  ruby_version_is ""..."3.2" do
-    it "is a no-op" do
-      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
-      -> {
-        o = Object.new.untrust
-        o.trust
-      }.should complain(/Object#trust is deprecated and will be removed in Ruby 3.2/, verbose: true)
-    end
-  end
-
-  ruby_version_is "3.2" do
-    it "has been removed" do
-      Object.new.should_not.respond_to?(:trust)
-    end
+  it "has been removed" do
+    Object.new.should_not.respond_to?(:trust)
   end
 end
diff --git a/spec/ruby/core/kernel/untaint_spec.rb b/spec/ruby/core/kernel/untaint_spec.rb
index 26b2aabbe9..47e8544bd4 100644
--- a/spec/ruby/core/kernel/untaint_spec.rb
+++ b/spec/ruby/core/kernel/untaint_spec.rb
@@ -2,27 +2,7 @@ require_relative '../../spec_helper'
 require_relative 'fixtures/classes'
 
 describe "Kernel#untaint" do
-  ruby_version_is ""..."3.2" do
-    it "is a no-op" do
-      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
-      -> {
-        o = Object.new.taint
-        o.untaint
-      }.should complain(/Object#untaint is deprecated and will be removed in Ruby 3.2/, verbose: true)
-    end
-  end
-
-  ruby_version_is "3.2" do
-    it "has been removed" do
-      Object.new.should_not.respond_to?(:untaint)
-    end
+  it "has been removed" do
+    Object.new.should_not.respond_to?(:untaint)
   end
 end
diff --git a/spec/ruby/core/kernel/untrust_spec.rb b/spec/ruby/core/kernel/untrust_spec.rb
index 5310cd8eb4..8787ab3fc9 100644
--- a/spec/ruby/core/kernel/untrust_spec.rb
+++ b/spec/ruby/core/kernel/untrust_spec.rb
@@ -2,26 +2,7 @@ require_relative '../../spec_helper'
 require_relative 'fixtures/classes'
 
 describe "Kernel#untrust" do
-  ruby_version_is ""..."3.2" do
-    it "is a no-op" do
-      suppress_warning do
-        o = Object.new
-        o.untrust
-        o.should_not.untrusted?
-      end
-    end
-
-    it "warns in verbose mode" do
-      -> {
-        o = Object.new
-        o.untrust
-      }.should complain(/Object#untrust is deprecated and will be removed in Ruby 3.2/, verbose: true)
-    end
-  end
-
-  ruby_version_is "3.2" do
-    it "has been removed" do
-      Object.new.should_not.respond_to?(:untrust)
-    end
+  it "has been removed" do
+    Object.new.should_not.respond_to?(:untrust)
   end
 end
diff --git a/spec/ruby/core/kernel/untrusted_spec.rb b/spec/ruby/core/kernel/untrusted_spec.rb
index ea36d6c98c..29261be9c4 100644
--- a/spec/ruby/core/kernel/untrusted_spec.rb
+++ b/spec/ruby/core/kernel/untrusted_spec.rb
@@ -2,27 +2,7 @@ require_relative '../../spec_helper'
 require_relative 'fixtures/classes'
 
 describe "Kernel#untrusted?" do
-  ruby_version_is ""..."3.2" do
-    it "is a no-op" do
-      suppress_warning do
-        o = mock('o')
-        o.should_not.untrusted?
-        o.untrust
-        o.should_not.untrusted?
-      end
-    end
-
-    it "warns in verbose mode" do
-      -> {
-        o = mock('o')
-        o.untrusted?
-      }.should complain(/Object#untrusted\? is deprecated and will be removed in Ruby 3.2/, verbose: true)
-    end
-  end
-
-  ruby_version_is "3.2" do
-    it "has been removed" do
-      Object.new.should_not.respond_to?(:untrusted?)
-    end
+  it "has been removed" do
+    Object.new.should_not.respond_to?(:untrusted?)
   end
 end
diff --git a/spec/ruby/core/main/using_spec.rb b/spec/ruby/core/main/using_spec.rb
index 8a23970c4b..5b9a751595 100644
--- a/spec/ruby/core/main/using_spec.rb
+++ b/spec/ruby/core/main/using_spec.rb
@@ -142,11 +142,9 @@ describe "main.using" do
     end.should raise_error(RuntimeError)
   end
 
-  ruby_version_is "3.2" do
-    it "does not raise error when wrapped with module" do
-      -> do
-        load File.expand_path('../fixtures/using.rb', __FILE__), true
-      end.should_not raise_error
-    end
+  it "does not raise error when wrapped with module" do
+    -> do
+      load File.expand_path('../fixtures/using.rb', __FILE__), true
+    end.should_not raise_error
   end
 end
diff --git a/spec/ruby/core/marshal/dump_spec.rb b/spec/ruby/core/marshal/dump_spec.rb
index c2a2b77999..efc2293d9a 100644
--- a/spec/ruby/core/marshal/dump_spec.rb
+++ b/spec/ruby/core/marshal/dump_spec.rb
@@ -361,30 +361,28 @@ describe "Marshal.dump" do
     end
   end
 
-  ruby_version_is "3.2" do
-    describe "with a Data" do
-      it "dumps a Data" do
-        Marshal.dump(MarshalSpec::DataSpec::Measure.new(100, 'km')).should == "\x04\bS:#MarshalSpec::DataSpec::Measure\a:\vamountii:\tunit\"\akm"
-      end
+  describe "with a Data" do
+    it "dumps a Data" do
+      Marshal.dump(MarshalSpec::DataSpec::Measure.new(100, 'km')).should == "\x04\bS:#MarshalSpec::DataSpec::Measure\a:\vamountii:\tunit\"\akm"
+    end
 
-      it "dumps an extended Data" do
-        obj = MarshalSpec::DataSpec::MeasureExtended.new(100, "km")
-        Marshal.dump(obj).should == "\x04\bS:+MarshalSpec::DataSpec::MeasureExtended\a:\vamountii:\tunit\"\akm"
-      end
+    it "dumps an extended Data" do
+      obj = MarshalSpec::DataSpec::MeasureExtended.new(100, "km")
+      Marshal.dump(obj).should == "\x04\bS:+MarshalSpec::DataSpec::MeasureExtended\a:\vamountii:\tunit\"\akm"
+    end
 
-      it "ignores overridden name method" do
-        obj = MarshalSpec::DataSpec::MeasureWithOverriddenName.new(100, "km")
-        Marshal.dump(obj).should == "\x04\bS:5MarshalSpec::DataSpec::MeasureWithOverriddenName\a:\vamountii:\tunit\"\akm"
-      end
+    it "ignores overridden name method" do
+      obj = MarshalSpec::DataSpec::MeasureWithOverriddenName.new(100, "km")
+      Marshal.dump(obj).should == "\x04\bS:5MarshalSpec::DataSpec::MeasureWithOverriddenName\a:\vamountii:\tunit\"\akm"
+    end
 
-      it "uses object links for objects repeatedly dumped" do
-        d = MarshalSpec::DataSpec::Measure.new(100, 'km')
-        Marshal.dump([d, d]).should == "\x04\b[\aS:#MarshalSpec::DataSpec::Measure\a:\vamountii:\tunit\"\akm@\x06" # @\x06 is a link to the object
-      end
+    it "uses object links for objects repeatedly dumped" do
+      d = MarshalSpec::DataSpec::Measure.new(100, 'km')
+      Marshal.dump([d, d]).should == "\x04\b[\aS:#MarshalSpec::DataSpec::Measure\a:\vamountii:\tunit\"\akm@\x06" # @\x06 is a link to the object
+    end
 
-      it "raises TypeError with an anonymous Struct" do
-        -> { Marshal.dump(Data.define(:a).new(1)) }.should raise_error(TypeError, /can't dump anonymous class/)
-      end
+    it "raises TypeError with an anonymous Struct" do
+      -> { Marshal.dump(Data.define(:a).new(1)) }.should raise_error(TypeError, /can't dump anonymous class/)
     end
   end
 
diff --git a/spec/ruby/core/marshal/fixtures/marshal_data.rb b/spec/ruby/core/marshal/fixtures/marshal_data.rb
index 3ba85aa6eb..124eb9ecd6 100644
--- a/spec/ruby/core/marshal/fixtures/marshal_data.rb
+++ b/spec/ruby/core/marshal/fixtures/marshal_data.rb
@@ -532,18 +532,16 @@ module MarshalSpec
     "Random" => random_data,
   }
 
-  if defined? Data # TODO: remove the condition when minimal supported version is 3.2
-    module DataSpec
-      Measure = Data.define(:amount, :unit)
-      Empty = Data.define
-
-      MeasureExtended = Class.new(Measure)
-      MeasureExtended.extend(Enumerable)
-
-      class MeasureWithOverriddenName < Measure
-        def self.name
-          "Foo"
-        end
+  module DataSpec
+    Measure = Data.define(:amount, :unit)
+    Empty = Data.define
+
+    MeasureExtended = Class.new(Measure)
+    MeasureExtended.extend(Enumerable)
+
+    class MeasureWithOverriddenName < Measure
+      def self.name
+        "Foo"
       end
     end
   end
diff --git a/spec/ruby/core/marshal/shared/load.rb b/spec/ruby/core/marshal/shared/load.rb
index f73fa67e9a..6d79f7c3ef 100644
--- a/spec/ruby/core/marshal/shared/load.rb
+++ b/spec/ruby/core/marshal/shared/load.rb
@@ -139,7 +139,7 @@ describe :marshal_load, shared: true do
       end
     end
 
-    ruby_bug "#19427", "3.1"..."3.3" do
+    ruby_bug "#19427", ""..."3.3" do
       it "returns frozen object having #_dump method" do
         object = Marshal.send(@method, Marshal.dump(UserDefined.new), freeze: true)
         object.should.frozen?
@@ -739,31 +739,29 @@ describe :marshal_load, shared: true do
     end
   end
 
-  ruby_version_is "3.2" do
-    describe "for a Data" do
-      it "loads a Data" do
-        obj = MarshalSpec::DataSpec::Measure.new(100, 'km')
-        dumped = "\x04\bS:#MarshalSpec::DataSpec::Measure\a:\vamountii:\tunit\"\akm"
-        Marshal.dump(obj).should == dumped
+  describe "for a Data" do
+    it "loads a Data" do
+      obj = MarshalSpec::DataSpec::Measure.new(100, 'km')
+      dumped = "\x04\bS:#MarshalSpec::DataSpec::Measure\a:\vamountii:\tunit\"\akm"
+      Marshal.dump(obj).should == dumped
 
-        Marshal.send(@method, dumped).should == obj
-      end
+      Marshal.send(@method, dumped).should == obj
+    end
 
-      it "loads an extended Data" do
-        obj = MarshalSpec::DataSpec::MeasureExtended.new(100, "km")
-        dumped = "\x04\bS:+MarshalSpec::DataSpec::MeasureExtended\a:\vamountii:\tunit\"\akm"
-        Marshal.dump(obj).should == dumped
+    it "loads an extended Data" do
+      obj = MarshalSpec::DataSpec::MeasureExtended.new(100, "km")
+      dumped = "\x04\bS:+MarshalSpec::DataSpec::MeasureExtended\a:\vamountii:\tunit\"\akm"
+      Marshal.dump(obj).should == dumped
 
-        Marshal.send(@method, dumped).should == obj
-      end
+      Marshal.send(@method, dumped).should == obj
+    end
 
-      it "returns a frozen object" do
-        obj = MarshalSpec::DataSpec::Measure.new(100, 'km')
-        dumped = "\x04\bS:#MarshalSpec::DataSpec::Measure\a:\vamountii:\tunit\"\akm"
-        Marshal.dump(obj).should == dumped
+    it "returns a frozen object" do
+      obj = MarshalSpec::DataSpec::Measure.new(100, 'km')
+      dumped = "\x04\bS:#MarshalSpec::DataSpec::Measure\a:\vamountii:\tunit\"\akm"
+      Marshal.dump(obj).should == dumped
 
-        Marshal.send(@method, dumped).should.frozen?
-      end
+      Marshal.send(@method, dumped).should.frozen?
     end
   end
 
diff --git a/spec/ruby/core/matchdata/byteoffset_spec.rb b/spec/ruby/core/matchdata/byteoffset_spec.rb
index b27267fd0e..fb8f5fb67d 100644
--- a/spec/ruby/core/matchdata/byteoffset_spec.rb
+++ b/spec/ruby/core/matchdata/byteoffset_spec.rb
@@ -1,95 +1,93 @@
 require_relative '../../spec_helper'
 
 describe "MatchData#byteoffset" do
-  ruby_version_is "3.2" do
-    it "returns beginning and ending byte-based offset of whole matched substring for 0 element" do
-      m = /(.)(.)(\d+)(\d)/.match("THX1138.")
-      m.byteoffset(0).should == [1, 7]
-    end
+  it "returns beginning and ending byte-based offset of whole matched substring for 0 element" do
+    m = /(.)(.)(\d+)(\d)/.match("THX1138.")
+    m.byteoffset(0).should == [1, 7]
+  end
 
-    it "returns beginning and ending byte-based offset of n-th match, all the subsequent elements are capturing groups" do
-      m = /(.)(.)(\d+)(\d)/.match("THX1138.")
+  it "returns beginning and ending byte-based offset of n-th match, all the subsequent elements are capturing groups" do
+    m = /(.)(.)(\d+)(\d)/.match("THX1138.")
 
-      m.byteoffset(2).should == [2, 3]
-      m.byteoffset(3).should == [3, 6]
-      m.byteoffset(4).should == [6, 7]
-    end
+    m.byteoffset(2).should == [2, 3]
+    m.byteoffset(3).should == [3, 6]
+    m.byteoffset(4).should == [6, 7]
+  end
 
-    it "accepts String as a reference to a named capture" do
-      m = /(?<f>foo)(?<b>bar)/.match("foobar")
+  it "accepts String as a reference to a named capture" do
+    m = /(?<f>foo)(?<b>bar)/.match("foobar")
 
-      m.byteoffset("f").should == [0, 3]
-      m.byteoffset("b").should == [3, 6]
-    end
+    m.byteoffset("f").should == [0, 3]
+    m.byteoffset("b").should == [3, 6]
+  end
 
-    it "accepts Symbol as a reference to a named capture" do
-      m = /(?<f>foo)(?<b>bar)/.match("foobar")
+  it "accepts Symbol as a reference to a named capture" do
+    m = /(?<f>foo)(?<b>bar)/.match("foobar")
 
-      m.byteoffset(:f).should == [0, 3]
-      m.byteoffset(:b).should == [3, 6]
-    end
+    m.byteoffset(:f).should == [0, 3]
+    m.byteoffset(:b).should == [3, 6]
+  end
 
-    it "returns [nil, nil] if a capturing group is optional and doesn't match" do
-      m = /(?<x>q..)?/.match("foobarbaz")
+  it "returns [nil, nil] if a capturing group is optional and doesn't match" do
+    m = /(?<x>q..)?/.match("foobarbaz")
 
-      m.byteoffset("x").should == [nil, nil]
-      m.byteoffset(1).should == [nil, nil]
-    end
+    m.byteoffset("x").should == [nil, nil]
+    m.byteoffset(1).should == [nil, nil]
+  end
 
-    it "returns correct beginning and ending byte-based offset for multi-byte strings" do
-      m = /\A\u3042(.)(.)?(.)\z/.match("\u3042\u3043\u3044")
+  it "returns correct beginning and ending byte-based offset for multi-byte strings" do
+    m = /\A\u3042(.)(.)?(.)\z/.match("\u3042\u3043\u3044")
 
-      m.byteoffset(1).should == [3, 6]
-      m.byteoffset(3).should == [6, 9]
-    end
+    m.byteoffset(1).should == [3, 6]
+    m.byteoffset(3).should == [6, 9]
+  end
 
-    it "returns [nil, nil] if a capturing group is optional and doesn't match for multi-byte string" do
-      m = /\A\u3042(.)(.)?(.)\z/.match("\u3042\u3043\u3044")
+  it "returns [nil, nil] if a capturing group is optional and doesn't match for multi-byte string" do
+    m = /\A\u3042(.)(.)?(.)\z/.match("\u3042\u3043\u3044")
 
-      m.byteoffset(2).should == [nil, nil]
-    end
+    m.byteoffset(2).should == [nil, nil]
+  end
 
-    it "converts argument into integer if is not String nor Symbol" do
-      m = /(?<f>foo)(?<b>bar)/.match("foobar")
+  it "converts argument into integer if is not String nor Symbol" do
+    m = /(?<f>foo)(?<b>bar)/.match("foobar")
 
-      obj = Object.new
-      def obj.to_int; 2; end
+    obj = Object.new
+    def obj.to_int; 2; end
 
-      m.byteoffset(1r).should == [0, 3]
-      m.byteoffset(1.1).should == [0, 3]
-      m.byteoffset(obj).should == [3, 6]
-    end
+    m.byteoffset(1r).should == [0, 3]
+    m.byteoffset(1.1).should == [0, 3]
+    m.byteoffset(obj).should == [3, 6]
+  end
 
-    it "raises IndexError if there is no group with the provided name" do
-      m = /(?<f>foo)(?<b>bar)/.match("foobar")
+  it "raises IndexError if there is no group with the provided name" do
+    m = /(?<f>foo)(?<b>bar)/.match("foobar")
 
-      -> {
-        m.byteoffset("y")
-      }.should raise_error(IndexError, "undefined group name reference: y")
+    -> {
+      m.byteoffset("y")
+    }.should raise_error(IndexError, "undefined group name reference: y")
 
-      -> {
-        m.byteoffset(:y)
-      }.should raise_error(IndexError, "undefined group name reference: y")
-    end
+    -> {
+      m.byteoffset(:y)
+    }.should raise_error(IndexError, "undefined group name reference: y")
+  end
 
-    it "raises IndexError if index is out of bounds" do
-      m = /(?<f>foo)(?<b>bar)/.match("foobar")
+  it "raises IndexError if index is out of bounds" do
+    m = /(?<f>foo)(?<b>bar)/.match("foobar")
 
-      -> {
-        m.byteoffset(-1)
-      }.should raise_error(IndexError, "index -1 out of matches")
+    -> {
+      m.byteoffset(-1)
+    }.should raise_error(IndexError, "index -1 out of matches")
 
-      -> {
-        m.byteoffset(3)
-      }.should raise_error(IndexError, "index 3 out of matches")
-    end
+    -> {
+      m.byteoffset(3)
+    }.should raise_error(IndexError, "index 3 out of matches")
+  end
 
-    it "raises TypeError if can't convert argument into Integer" do
-      m = /(?<f>foo)(?<b>bar)/.match("foobar")
+  it "raises TypeError if can't convert argument into Integer" do
+    m = /(?<f>foo)(?<b>bar)/.match("foobar")
 
-      -> {
-        m.byteoffset([])
-      }.should raise_error(TypeError, "no implicit conversion of Array into Integer")
-    end
+    -> {
+      m.byteoffset([])
+    }.should raise_error(TypeError, "no implicit conversion of Array into Integer")
   end
 end
diff --git a/spec/ruby/core/matchdata/deconstruct_keys_spec.rb b/spec/ruby/core/matchdata/deconstruct_keys_spec.rb
index 5b68f886c7..bf22bc33ff 100644
--- a/spec/ruby/core/matchdata/deconstruct_keys_spec.rb
+++ b/spec/ruby/core/matchdata/deconstruct_keys_spec.rb
@@ -1,65 +1,63 @@
 require_relative '../../spec_helper'
 
 describe "MatchData#deconstruct_keys" do
-  ruby_version_is "3.2" do
-    it "returns whole hash for nil as an argument" do
-      m = /(?<f>foo)(?<b>bar)/.match("foobar")
+  it "returns whole hash for nil as an argument" do
+    m = /(?<f>foo)(?<b>bar)/.match("foobar")
 
-      m.deconstruct_keys(nil).should == { f: "foo", b: "bar" }
-    end
+    m.deconstruct_keys(nil).should == { f: "foo", b: "bar" }
+  end
 
-    it "returns only specified keys" do
-      m = /(?<f>foo)(?<b>bar)/.match("foobar")
+  it "returns only specified keys" do
+    m = /(?<f>foo)(?<b>bar)/.match("foobar")
 
-      m.deconstruct_keys([:f]).should == { f: "foo" }
-    end
+    m.deconstruct_keys([:f]).should == { f: "foo" }
+  end
 
-    it "requires one argument" do
-      m = /l/.match("l")
+  it "requires one argument" do
+    m = /l/.match("l")
 
-      -> {
-        m.deconstruct_keys
-      }.should raise_error(ArgumentError, "wrong number of arguments (given 0, expected 1)")
-    end
+    -> {
+      m.deconstruct_keys
+    }.should raise_error(ArgumentError, "wrong number of arguments (given 0, expected 1)")
+  end
 
-    it "it raises error when argument is neither nil nor array" do
-      m = /(?<f>foo)(?<b>bar)/.match("foobar")
+  it "it raises error when argument is neither nil nor array" do
+    m = /(?<f>foo)(?<b>bar)/.match("foobar")
 
-      -> { m.deconstruct_keys(1) }.should raise_error(TypeError, "wrong argument type Integer (expected Array)")
-      -> { m.deconstruct_keys("asd") }.should raise_error(TypeError, "wrong argument type String (expected Array)")
-      -> { m.deconstruct_keys(:x) }.should raise_error(TypeError, "wrong argument type Symbol (expected Array)")
-      -> { m.deconstruct_keys({}) }.should raise_error(TypeError, "wrong argument type Hash (expected Array)")
-    end
+    -> { m.deconstruct_keys(1) }.should raise_error(TypeError, "wrong argument type Integer (expected Array)")
+    -> { m.deconstruct_keys("asd") }.should raise_error(TypeError, "wrong argument type String (expected Array)")
+    -> { m.deconstruct_keys(:x) }.should raise_error(TypeError, "wrong argument type Symbol (expected Array)")
+    -> { m.deconstruct_keys({}) }.should raise_error(TypeError, "wrong argument type Hash (expected Array)")
+  end
 
-    it "returns {} when passed []" do
-      m = /(?<f>foo)(?<b>bar)/.match("foobar")
+  it "returns {} when passed []" do
+    m = /(?<f>foo)(?<b>bar)/.match("foobar")
 
-      m.deconstruct_keys([]).should == {}
-    end
+    m.deconstruct_keys([]).should == {}
+  end
 
-    it "does not accept non-Symbol keys" do
-      m = /(?<f>foo)(?<b>bar)/.match("foobar")
+  it "does not accept non-Symbol keys" do
+    m = /(?<f>foo)(?<b>bar)/.match("foobar")
 
-      -> {
-        m.deconstruct_keys(['year', :foo])
-      }.should raise_error(TypeError, "wrong argument type String (expected Symbol)")
-    end
+    -> {
+      m.deconstruct_keys(['year', :foo])
+    }.should raise_error(TypeError, "wrong argument type String (expected Symbol)")
+  end
 
-    it "process keys till the first non-existing one" do
-      m = /(?<f>foo)(?<b>bar)(?<c>baz)/.match("foobarbaz")
+  it "process keys till the first non-existing one" do
+    m = /(?<f>foo)(?<b>bar)(?<c>baz)/.match("foobarbaz")
 
-      m.deconstruct_keys([:f, :a, :b]).should == { f: "foo" }
-    end
+    m.deconstruct_keys([:f, :a, :b]).should == { f: "foo" }
+  end
 
-    it "returns {} when there are no named captured groups at all" do
-      m = /foo.+/.match("foobar")
+  it "returns {} when there are no named captured groups at all" do
+    m = /foo.+/.match("foobar")
 
-      m.deconstruct_keys(nil).should == {}
-    end
+    m.deconstruct_keys(nil).should == {}
+  end
 
-    it "returns {} when passed more keys than named captured groups" do
-      m = /(?<f>foo)(?<b>bar)/.match("foobar")
-      m.deconstruct_keys([:f, :b, :c]).should == {}
-    end
+  it "returns {} when passed more keys than named captured groups" do
+    m = /(?<f>foo)(?<b>bar)/.match("foobar")
+    m.deconstruct_keys([:f, :b, :c]).should == {}
   end
 end
diff --git a/spec/ruby/core/matchdata/deconstruct_spec.rb b/spec/ruby/core/matchdata/deconstruct_spec.rb
index 6af55113b6..c55095665d 100644
--- a/spec/ruby/core/matchdata/deconstruct_spec.rb
+++ b/spec/ruby/core/matchdata/deconstruct_spec.rb
@@ -2,7 +2,5 @@ require_relative '../../spec_helper'
 require_relative 'shared/captures'
 
 describe "MatchData#deconstruct" do
-  ruby_version_is "3.2" do
-    it_behaves_like :matchdata_captures, :deconstruct
-  end
+  it_behaves_like :matchdata_captures, :deconstruct
 end
diff --git a/spec/ruby/core/method/owner_spec.rb b/spec/ruby/core/method/owner_spec.rb
index 05422f1697..1cdc4edfa7 100644
--- a/spec/ruby/core/method/owner_spec.rb
+++ b/spec/ruby/core/method/owner_spec.rb
@@ -24,9 +24,7 @@ describe "Method#owner" do
     end
   end
 
-  ruby_version_is "3.2" do
-    it "returns the class on which public was called for a private method in ancestor" do
-      MethodSpecs::InheritedMethods::C.new.method(:derp).owner.should == MethodSpecs::InheritedMethods::C
-    end
+  it "returns the class on which public was called for a private method in ancestor" do
+    MethodSpecs::InheritedMethods::C.new.method(:derp).owner.should == MethodSpecs::InheritedMethods::C
   end
 end
diff --git a/spec/ruby/core/method/parameters_spec.rb b/spec/ruby/core/method/parameters_spec.rb
index 0178a61de6..f1c2523cf0 100644
--- a/spec/ruby/core/method/parameters_spec.rb
+++ b/spec/ruby/core/method/parameters_spec.rb
@@ -233,28 +233,14 @@ describe "Method#parameters" do
     m.method(:handled_via_method_missing).parameters.should == [[:rest]]
   end
 
-  ruby_version_is '3.2' do
-    it "adds rest arg with name * for \"star\" argument" do
-      m = MethodSpecs::Methods.new
-      m.method(:one_unnamed_splat).parameters.should == [[:rest, :*]]
-    end
-
-    it "adds keyrest arg with ** as a name for \"double star\" argument" do
-      m = MethodSpecs::Methods.new
-      m.method(:one_unnamed_keyrest).parameters.should == [[:keyrest, :**]]
-    end
+  it "adds rest arg with name * for \"star\" argument" do
+    m = MethodSpecs::Methods.new
+    m.method(:one_unnamed_splat).parameters.should == [[:rest, :*]]
   end
 
-  ruby_version_is ''...'3.2' do
-    it "adds nameless rest arg for \"star\" argument" do
-      m = MethodSpecs::Methods.new
-      m.method(:one_unnamed_splat).parameters.should == [[:rest]]
-    end
-
-    it "adds nameless keyrest arg for \"double star\" argument" do
-      m = MethodSpecs::Methods.new
-      m.method(:one_unnamed_keyrest).parameters.should == [[:keyrest]]
-    end
+  it "adds keyrest arg with ** as a name for \"double star\" argument" do
+    m = MethodSpecs::Methods.new
+    m.method(:one_unnamed_keyrest).parameters.should == [[:keyrest, :**]]
   end
 
   it "adds block arg with name & for anonymous block argument" do
diff --git a/spec/ruby/core/method/private_spec.rb b/spec/ruby/core/method/private_spec.rb
index 9b67a77243..e708542b2e 100644
--- a/spec/ruby/core/method/private_spec.rb
+++ b/spec/ruby/core/method/private_spec.rb
@@ -2,27 +2,8 @@ require_relative '../../spec_helper'
 require_relative 'fixtures/classes'
 
 describe "Method#private?" do
-  ruby_version_is ""..."3.2" do
-    it "returns false when the method is public" do
-      obj = MethodSpecs::Methods.new
-      obj.method(:my_public_method).private?.should == false
-    end
-
-    it "returns false when the method is protected" do
-      obj = MethodSpecs::Methods.new
-      obj.method(:my_protected_method).private?.should == false
-    end
-
-    it "returns true when the method is private" do
-      obj = MethodSpecs::Methods.new
-      obj.method(:my_private_method).private?.should == true
-    end
-  end
-
-  ruby_version_is "3.2" do
-    it "has been removed" do
-      obj = MethodSpecs::Methods.new
-      obj.method(:my_private_method).should_not.respond_to?(:private?)
-    end
+  it "has been removed" do
+    obj = MethodSpecs::Methods.new
+    obj.method(:my_private_method).should_not.respond_to?(:private?)
   end
 end
diff --git a/spec/ruby/core/method/protected_spec.rb b/spec/ruby/core/method/protected_spec.rb
index 28c60c7536..f9e422ae3d 100644
--- a/spec/ruby/core/method/protected_spec.rb
+++ b/spec/ruby/core/method/protected_spec.rb
@@ -2,27 +2,8 @@ require_relative '../../spec_helper'
 require_relative 'fixtures/classes'
 
 describe "Method#protected?" do
-  ruby_version_is ""..."3.2" do
-    it "returns false when the method is public" do
-      obj = MethodSpecs::Methods.new
-      obj.method(:my_public_method).protected?.should == false
-    end
-
-    it "returns true when the method is protected" do
-      obj = MethodSpecs::Methods.new
-      obj.method(:my_protected_method).protected?.should == true
-    end
-
-    it "returns false when the method is private" do
-      obj = MethodSpecs::Methods.new
-      obj.method(:my_private_method).protected?.should == false
-    end
-  end
-
-  ruby_version_is "3.2" do
-    it "has been removed" do
-      obj = MethodSpecs::Methods.new
-      obj.method(:my_protected_method).should_not.respond_to?(:protected?)
-    end
+  it "has been removed" do
+    obj = MethodSpecs::Methods.new
+    obj.method(:my_protected_method).should_not.respond_to?(:protected?)
   end
 end
diff --git a/spec/ruby/core/method/public_spec.rb b/spec/ruby/core/method/public_spec.rb
index 4844f4b90b..4cb23f4cf1 100644
--- a/spec/ruby/core/method/public_spec.rb
+++ b/spec/ruby/core/method/public_spec.rb
@@ -2,27 +2,8 @@ require_relative '../../spec_helper'
 require_relative 'fixtures/classes'
 
 describe "Method#public?" do
-  ruby_version_is ""..."3.2" do
-    it "returns true when the method is public" do
-      obj = MethodSpecs::Methods.new
-      obj.method(:my_public_method).public?.should == true
-    end
-
-    it "returns false when the method is protected" do
-      obj = MethodSpecs::Methods.new
-      obj.method(:my_protected_method).public?.should == false
-    end
-
-    it "returns false when the method is private" do
-      obj = MethodSpecs::Methods.new
-      obj.method(:my_private_method).public?.should == false
-    end
-  end
-
-  ruby_version_is "3.2" do
-    it "has been removed" do
-      obj = MethodSpecs::Methods.new
-      obj.method(:my_public_method).should_not.respond_to?(:public?)
-    end
+  it "has been removed" do
+    obj = MethodSpecs::Methods.new
+    obj.method(:my_public_method).should_not.respond_to?(:public?)
   end
 end
diff --git a/spec/ruby/core/method/unbind_spec.rb b/spec/ruby/core/method/unbind_spec.rb
index bdedd513ce..0b630e4d88 100644
--- a/spec/ruby/core/method/unbind_spec.rb
+++ b/spec/ruby/core/method/unbind_spec.rb
@@ -27,16 +27,8 @@ describe "Method#unbind" do
       @string.should =~ /MethodSpecs::MyMod/
     end
 
-    ruby_version_is ""..."3.2" do
-      it "returns a String containing the Module the method is referenced from" do
-        @string.should =~ /MethodSpecs::MySub/
-      end
-    end
-
-    ruby_version_is "3.2" do
-      it "returns a String containing the Module the method is referenced from" do
-        @string.should =~ /MethodSpecs::MyMod/
-      end
+    it "returns a String containing the Module the method is referenced from" do
+      @string.should =~ /MethodSpecs::MyMod/
     end
   end
 
diff --git a/spec/ruby/core/module/autoload_spec.rb b/spec/ruby/core/module/autoload_spec.rb
index 3cdc48f9ba..bba911e752 100644
--- a/spec/ruby/core/module/autoload_spec.rb
+++ b/spec/ruby/core/module/autoload_spec.rb
@@ -603,32 +603,30 @@ describe "Module#autoload" do
       end
     end
 
-    ruby_version_is "3.2" do
-      it "warns once in verbose mode if the constant was defined in a parent scope" do
-        ScratchPad.record -> {
-          ModuleSpecs::DeclaredInCurrentDefinedInParent = :declared_in_current_defined_in_parent
-        }
+    it "warns once in verbose mode if the constant was defined in a parent scope" do
+      ScratchPad.record -> {
+        ModuleSpecs::DeclaredInCurrentDefinedInParent = :declared_in_current_defined_in_parent
+      }
 
-        module ModuleSpecs
-          module Autoload
-            autoload :DeclaredInCurrentDefinedInParent, fixture(__FILE__, "autoload_callback.rb")
-            self.autoload?(:DeclaredInCurrentDefinedInParent).should == fixture(__FILE__, "autoload_callback.rb")
-            const_defined?(:DeclaredInCurrentDefinedInParent).should == true
-
-            -> {
-              DeclaredInCurrentDefinedInParent
-            }.should complain(
-              /Expected .*autoload_callback.rb to define ModuleSpecs::Autoload::DeclaredInCurrentDefinedInParent but it didn't/,
-              verbose: true,
-            )
-
-            -> {
-              DeclaredInCurrentDefinedInParent
-            }.should_not complain(/.*/, verbose: true)
-            self.autoload?(:DeclaredInCurrentDefinedInParent).should == nil
-            const_defined?(:DeclaredInCurrentDefinedInParent).should == false
-            ModuleSpecs.const_defined?(:DeclaredInCurrentDefinedInParent).should == true
-          end
+      module ModuleSpecs
+        module Autoload
+          autoload :DeclaredInCurrentDefinedInParent, fixture(__FILE__, "autoload_callback.rb")
+          self.autoload?(:DeclaredInCurrentDefinedInParent).should == fixture(__FILE__, "autoload_callback.rb")
+          const_defined?(:DeclaredInCurrentDefinedInParent).should == true
+
+          -> {
+            DeclaredInCurrentDefinedInParent
+          }.should complain(
+            /Expected .*autoload_callback.rb to define ModuleSpecs::Autoload::DeclaredInCurrentDefinedInParent but it didn't/,
+            verbose: true,
+          )
+
+          -> {
+            DeclaredInCurrentDefinedInParent
+          }.should_not complain(/.*/, verbose: true)
+          self.autoload?(:DeclaredInCurrentDefinedInParent).should == nil
+          const_defined?(:DeclaredInCurrentDefinedInParent).should == false
+          ModuleSpecs.const_defined?(:DeclaredInCurrentDefinedInParent).should == true
         end
       end
     end
diff --git a/spec/ruby/core/module/const_added_spec.rb b/spec/ruby/core/module/const_added_spec.rb
index dfa2e011cc..739be3ead8 100644
--- a/spec/ruby/core/module/const_added_spec.rb
+++ b/spec/ruby/core/module/const_added_spec.rb
@@ -3,236 +3,234 @@ require_relative 'fixtures/classes'
 require_relative 'fixtures/const_added'
 
 describe "Module#const_added" do
-  ruby_version_is "3.2" do
-    it "is a private instance method" do
-      Module.should have_private_instance_method(:const_added)
+  it "is a private instance method" do
+    Module.should have_private_instance_method(:const_added)
+  end
+
+  it "returns nil in the default implementation" do
+    Module.new do
+      const_added(:TEST).should == nil
     end
+  end
+
+  it "for a class defined with the `class` keyword, const_added runs before inherited" do
+    ScratchPad.record []
 
-    it "returns nil in the default implementation" do
-      Module.new do
-        const_added(:TEST).should == nil
+    mod = Module.new do
+      def self.const_added(_)
+        ScratchPad << :const_added
       end
     end
 
-    it "is called when a new constant is assigned on self" do
-      ScratchPad.record []
-
-      mod = Module.new do
-        def self.const_added(name)
-          ScratchPad << name
-        end
+    parent = Class.new do
+      def self.inherited(_)
+        ScratchPad << :inherited
       end
+    end
 
-      mod.module_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-        TEST = 1
-      RUBY
+    class mod::C < parent; end
 
-      ScratchPad.recorded.should == [:TEST]
-    end
+    ScratchPad.recorded.should == [:const_added, :inherited]
+  end
 
-    it "is called when a new constant is assigned on self through const_set" do
-      ScratchPad.record []
+  it "the superclass of a class assigned to a constant is set before const_added is called" do
+    ScratchPad.record []
 
-      mod = Module.new do
-        def self.const_added(name)
-          ScratchPad << name
-        end
+    parent = Class.new do
+      def self.const_added(name)
+        ScratchPad << name
+        ScratchPad << const_get(name).superclass
       end
+    end
 
-      mod.const_set(:TEST, 1)
+    class parent::C < parent; end
 
-      ScratchPad.recorded.should == [:TEST]
-    end
+    ScratchPad.recorded.should == [:C, parent]
+  end
 
-    it "is called when a new module is defined under self" do
-      ScratchPad.record []
+  it "is called when a new constant is assigned on self" do
+    ScratchPad.record []
 
-      mod = Module.new do
-        def self.const_added(name)
-          ScratchPad << name
-        end
+    mod = Module.new do
+      def self.const_added(name)
+        ScratchPad << name
       end
+    end
 
-      mod.module_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-        module SubModule
-        end
+    mod.module_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+      TEST = 1
+    RUBY
 
-        module SubModule
-        end
-      RUBY
+    ScratchPad.recorded.should == [:TEST]
+  end
+
+  it "is called when a new constant is assigned on self through const_set" do
+    ScratchPad.record []
 
-      ScratchPad.recorded.should == [:SubModule]
+    mod = Module.new do
+      def self.const_added(name)
+        ScratchPad << name
+      end
     end
 
-    it "is called when a new module is defined under a named module (assigned to a constant)" do
-      ScratchPad.record []
+    mod.const_set(:TEST, 1)
 
-      ModuleSpecs::ConstAddedSpecs::NamedModule = Module.new do
-        def self.const_added(name)
-          ScratchPad << name
-        end
+    ScratchPad.recorded.should == [:TEST]
+  end
 
-        module self::A
-          def self.const_added(name)
-            ScratchPad << name
-          end
+  it "is called when a new module is defined under self" do
+    ScratchPad.record []
 
-          module self::B
-          end
-        end
+    mod = Module.new do
+      def self.const_added(name)
+        ScratchPad << name
       end
-
-      ScratchPad.recorded.should == [:A, :B]
     end
 
-    it "is called when a new class is defined under self" do
-      ScratchPad.record []
-
-      mod = Module.new do
-        def self.const_added(name)
-          ScratchPad << name
-        end
+    mod.module_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+      module SubModule
       end
 
-      mod.module_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-        class SubClass
-        end
+      module SubModule
+      end
+    RUBY
 
-        class SubClass
-        end
-      RUBY
+    ScratchPad.recorded.should == [:SubModule]
+  end
 
-      ScratchPad.recorded.should == [:SubClass]
-    end
+  it "is called when a new module is defined under a named module (assigned to a constant)" do
+    ScratchPad.record []
 
-    it "is called when a new class is defined under a named module (assigned to a constant)" do
-      ScratchPad.record []
+    ModuleSpecs::ConstAddedSpecs::NamedModule = Module.new do
+      def self.const_added(name)
+        ScratchPad << name
+      end
 
-      ModuleSpecs::ConstAddedSpecs::NamedModuleB = Module.new do
+      module self::A
         def self.const_added(name)
           ScratchPad << name
         end
 
-        class self::A
-          def self.const_added(name)
-            ScratchPad << name
-          end
-
-          class self::B
-          end
+        module self::B
         end
       end
-
-      ScratchPad.recorded.should == [:A, :B]
     end
 
-    it "is called when an autoload is defined" do
-      ScratchPad.record []
+    ScratchPad.recorded.should == [:A, :B]
+  end
 
-      mod = Module.new do
-        def self.const_added(name)
-          ScratchPad << name
-        end
-      end
+  it "is called when a new class is defined under self" do
+    ScratchPad.record []
 
-      mod.autoload :Autoload, "foo"
-      ScratchPad.recorded.should == [:Autoload]
+    mod = Module.new do
+      def self.const_added(name)
+        ScratchPad << name
+      end
     end
 
-    it "is called with a precise caller location with the line of definition" do
-      ScratchPad.record []
+    mod.module_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+      class SubClass
+      end
 
-      mod = Module.new do
-        def self.const_added(name)
-          location = caller_locations(1, 1)[0]
-          ScratchPad << location.lineno
-        end
+      class SubClass
       end
+    RUBY
 
-      line = __LINE__
-      mod.module_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-        TEST = 1
+    ScratchPad.recorded.should == [:SubClass]
+  end
 
-        module SubModule
-        end
+  it "is called when a new class is defined under a named module (assigned to a constant)" do
+    ScratchPad.record []
 
-        class SubClass
-        end
-      RUBY
+    ModuleSpecs::ConstAddedSpecs::NamedModuleB = Module.new do
+      def self.const_added(name)
+        ScratchPad << name
+      end
 
-      mod.const_set(:CONST_SET, 1)
+      class self::A
+        def self.const_added(name)
+          ScratchPad << name
+        end
 
-      ScratchPad.recorded.should == [line + 2, line + 4, line + 7, line + 11]
+        class self::B
+        end
+      end
     end
 
-    it "is called when the constant is already assigned a value" do
-      ScratchPad.record []
+    ScratchPad.recorded.should == [:A, :B]
+  end
 
-      mod = Module.new do
-        def self.const_added(name)
-          ScratchPad.record const_get(name)
-        end
+  it "is called when an autoload is defined" do
+    ScratchPad.record []
+
+    mod = Module.new do
+      def self.const_added(name)
+        ScratchPad << name
       end
+    end
 
-      mod.module_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-        TEST = 123
-      RUBY
+    mod.autoload :Autoload, "foo"
+    ScratchPad.recorded.should == [:Autoload]
+  end
 
-      ScratchPad.recorded.should == 123
+  it "is called with a precise caller location with the line of definition" do
+    ScratchPad.record []
+
+    mod = Module.new do
+      def self.const_added(name)
+        location = caller_locations(1, 1)[0]
+        ScratchPad << location.lineno
+      end
     end
 
-    it "records re-definition of existing constants" do
-      ScratchPad.record []
+    line = __LINE__
+    mod.module_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+      TEST = 1
 
-      mod = Module.new do
-        def self.const_added(name)
-          ScratchPad << const_get(name)
-        end
+      module SubModule
       end
 
-      -> {
-        mod.module_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-          TEST = 123
-          TEST = 456
-        RUBY
-      }.should complain(/warning: already initialized constant .+::TEST/)
+      class SubClass
+      end
+    RUBY
 
-      ScratchPad.recorded.should == [123, 456]
-    end
+    mod.const_set(:CONST_SET, 1)
 
-    it "for a class defined with the `class` keyword, const_added runs before inherited" do
-      ScratchPad.record []
+    ScratchPad.recorded.should == [line + 2, line + 4, line + 7, line + 11]
+  end
 
-      mod = Module.new do
-        def self.const_added(_)
-          ScratchPad << :const_added
-        end
-      end
+  it "is called when the constant is already assigned a value" do
+    ScratchPad.record []
 
-      parent = Class.new do
-        def self.inherited(_)
-          ScratchPad << :inherited
-        end
+    mod = Module.new do
+      def self.const_added(name)
+        ScratchPad.record const_get(name)
       end
+    end
 
-      class mod::C < parent; end
+    mod.module_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+      TEST = 123
+    RUBY
 
-      ScratchPad.recorded.should == [:const_added, :inherited]
-    end
+    ScratchPad.recorded.should == 123
+  end
 
-    it "the superclass of a class assigned to a constant is set before const_added is called" do
-      ScratchPad.record []
+  it "records re-definition of existing constants" do
+    ScratchPad.record []
 
-      parent = Class.new do
-        def self.const_added(name)
-          ScratchPad << name
-          ScratchPad << const_get(name).superclass
-        end
+    mod = Module.new do
+      def self.const_added(name)
+        ScratchPad << const_get(name)
       end
+    end
 
-      class parent::C < parent; end
+    -> {
+      mod.module_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+        TEST = 123
+        TEST = 456
+      RUBY
+    }.should complain(/warning: already initialized constant .+::TEST/)
 
-      ScratchPad.recorded.should == [:C, parent]
-    end
+    ScratchPad.recorded.should == [123, 456]
   end
 end
diff --git a/spec/ruby/core/module/include_spec.rb b/spec/ruby/core/module/include_spec.rb
index a1bfd3a6f5..210918b2e7 100644
--- a/spec/ruby/core/module/include_spec.rb
+++ b/spec/ruby/core/module/include_spec.rb
@@ -51,32 +51,16 @@ describe "Module#include" do
     ModuleSpecs::SubclassSpec.send(:remove_const, :AClass)
   end
 
-  ruby_version_is ""..."3.2" do
-    it "raises ArgumentError when the argument is a refinement" do
-      refinement = nil
+  it "raises a TypeError when the argument is a refinement" do
+    refinement = nil
 
-      Module.new do
-        refine String do
-          refinement = self
-        end
+    Module.new do
+      refine String do
+        refinement = self
       end
-
-      -> { ModuleSpecs::Basic.include(refinement) }.should raise_error(ArgumentError, "refinement module is not allowed")
     end
-  end
-
-  ruby_version_is "3.2" do
-    it "raises a TypeError when the argument is a refinement" do
-      refinement = nil
 
-      Module.new do
-        refine String do
-          refinement = self
-        end
-      end
-
-      -> { ModuleSpecs::Basic.include(refinement) }.should raise_error(TypeError, "Cannot include refinement")
-    end
+    -> { ModuleSpecs::Basic.include(refinement) }.should raise_error(TypeError, "Cannot include refinement")
   end
 
   it "imports constants to modules and classes" do
diff --git a/spec/ruby/core/module/instance_method_spec.rb b/spec/ruby/core/module/instance_method_spec.rb
index 8d006e647e..182cdf5c54 100644
--- a/spec/ruby/core/module/instance_method_spec.rb
+++ b/spec/ruby/core/module/instance_method_spec.rb
@@ -48,11 +48,6 @@ describe "Module#instance_method" do
 
     @mod_um.inspect.should =~ /\bbar\b/
     @mod_um.inspect.should =~ /\bModuleSpecs::InstanceMethMod\b/
-
-    ruby_version_is ""..."3.2" do
-      @child_um.inspect.should =~ /\bModuleSpecs::InstanceMethChild\b/
-      @mod_um.inspect.should =~ /\bModuleSpecs::InstanceMethChild\b/
-    end
   end
 
   it "raises a TypeError if the given name is not a String/Symbol" do
diff --git a/spec/ruby/core/module/name_spec.rb b/spec/ruby/core/module/name_spec.rb
index b5c1f771f8..fd28ee0a33 100644
--- a/spec/ruby/core/module/name_spec.rb
+++ b/spec/ruby/core/module/name_spec.rb
@@ -153,45 +153,43 @@ describe "Module#name" do
     ModuleSpecs::Anonymous.send(:remove_const, :StoredInMultiplePlaces)
   end
 
-  ruby_version_is "3.2" do
-    it "is set in #const_added callback when a module defined in the top-level scope" do
-      ruby_exe(<<~RUBY, args: "2>&1").chomp.should == "TEST1\nTEST2"
-        class Module
-          def const_added(name)
-            puts const_get(name).name
-          end
+  it "is set in #const_added callback when a module defined in the top-level scope" do
+    ruby_exe(<<~RUBY, args: "2>&1").chomp.should == "TEST1\nTEST2"
+      class Module
+        def const_added(name)
+          puts const_get(name).name
         end
+      end
 
-        # module with name
-        module TEST1
-        end
+      # module with name
+      module TEST1
+      end
 
-        # anonymous module
-        TEST2 = Module.new
-      RUBY
-    end
+      # anonymous module
+      TEST2 = Module.new
+    RUBY
+  end
 
-    it "is set in #const_added callback for a nested module when an outer module defined in the top-level scope" do
-      ScratchPad.record []
+  it "is set in #const_added callback for a nested module when an outer module defined in the top-level scope" do
+    ScratchPad.record []
 
-      ModuleSpecs::NameSpecs::NamedModule = Module.new do
+    ModuleSpecs::NameSpecs::NamedModule = Module.new do
+      def self.const_added(name)
+        ScratchPad << const_get(name).name
+      end
+
+      module self::A
         def self.const_added(name)
           ScratchPad << const_get(name).name
         end
 
-        module self::A
-          def self.const_added(name)
-            ScratchPad << const_get(name).name
-          end
-
-          module self::B
-          end
+        module self::B
         end
       end
-
-      ScratchPad.recorded.should.one?(/#<Module.+>::A$/)
-      ScratchPad.recorded.should.one?(/#<Module.+>::A::B$/)
     end
+
+    ScratchPad.recorded.should.one?(/#<Module.+>::A$/)
+    ScratchPad.recorded.should.one?(/#<Module.+>::A::B$/)
   end
 
   it "returns a frozen String" do
diff --git a/spec/ruby/core/module/prepend_spec.rb b/spec/ruby/core/module/prepend_spec.rb
index 9508fbf182..71e82c513e 100644
--- a/spec/ruby/core/module/prepend_spec.rb
+++ b/spec/ruby/core/module/prepend_spec.rb
@@ -455,32 +455,16 @@ describe "Module#prepend" do
     ModuleSpecs::SubclassSpec.send(:remove_const, :AClass)
   end
 
-  ruby_version_is ""..."3.2" do
-    it "raises ArgumentError when the argument is a refinement" do
-      refinement = nil
+  it "raises a TypeError when the argument is a refinement" do
+    refinement = nil
 
-      Module.new do
-        refine String do
-          refinement = self
-        end
+    Module.new do
+      refine String do
+        refinement = self
       end
-
-      -> { ModuleSpecs::Basic.prepend(refinement) }.should raise_error(ArgumentError, "refinement module is not allowed")
     end
-  end
-
-  ruby_version_is "3.2" do
-    it "raises a TypeError when the argument is a refinement" do
-      refinement = nil
 
-      Module.new do
-        refine String do
-          refinement = self
-        end
-      end
-
-      -> { ModuleSpecs::Basic.prepend(refinement) }.should raise_error(TypeError, "Cannot prepend refinement")
-    end
+    -> { ModuleSpecs::Basic.prepend(refinement) }.should raise_error(TypeError, "Cannot prepend refinement")
   end
 
   it "imports constants" do
diff --git a/spec/ruby/core/module/refine_spec.rb b/spec/ruby/core/module/refine_spec.rb
index 7a5d607c4f..d219b98825 100644
--- a/spec/ruby/core/module/refine_spec.rb
+++ b/spec/ruby/core/module/refine_spec.rb
@@ -243,32 +243,6 @@ describe "Module#refine" do
       result.should == "foo from singleton class"
     end
 
-    ruby_version_is ""..."3.2" do
-      it "looks in the included modules for builtin methods" do
-        result = ruby_exe(<<-RUBY)
-          a = Module.new do
-            def /(other) quo(other) end
-          end
-
-          refinement = Module.new do
-            refine Integer do
-              include a
-            end
-          end
-
-          result = nil
-          Module.new do
-            using refinement
-            result = 1 / 2
-          end
-
-          print result.class
-        RUBY
-
-        result.should == 'Rational'
-      end
-    end
-
     it "looks in later included modules of the refined module first" do
       a = Module.new do
         def foo
diff --git a/spec/ruby/core/module/refinements_spec.rb b/spec/ruby/core/module/refinements_spec.rb
index 5648fcbd6f..05658a8b0e 100644
--- a/spec/ruby/core/module/refinements_spec.rb
+++ b/spec/ruby/core/module/refinements_spec.rb
@@ -1,45 +1,43 @@
 require_relative '../../spec_helper'
 
 describe "Module#refinements" do
-  ruby_version_is "3.2" do
-    it "returns refinements defined in a module" do
-      ScratchPad.record []
-
-      m = Module.new do
-        refine String do
-          ScratchPad << self
-        end
-
-        refine Array do
-          ScratchPad << self
-        end
+  it "returns refinements defined in a module" do
+    ScratchPad.record []
+
+    m = Module.new do
+      refine String do
+        ScratchPad << self
       end
 
-      m.refinements.sort_by(&:object_id).should == ScratchPad.recorded.sort_by(&:object_id)
+      refine Array do
+        ScratchPad << self
+      end
     end
 
-    it "does not return refinements defined in the included module" do
-      ScratchPad.record []
+    m.refinements.sort_by(&:object_id).should == ScratchPad.recorded.sort_by(&:object_id)
+  end
 
-      m1 = Module.new do
-        refine Integer do
-          nil
-        end
+  it "does not return refinements defined in the included module" do
+    ScratchPad.record []
+
+    m1 = Module.new do
+      refine Integer do
+        nil
       end
+    end
 
-      m2 = Module.new do
-        include m1
+    m2 = Module.new do
+      include m1
 
-        refine String do
-          ScratchPad << self
-        end
+      refine String do
+        ScratchPad << self
       end
-
-      m2.refinements.should == ScratchPad.recorded
     end
 
-    it "returns an empty array if no refinements defined in a module" do
-      Module.new.refinements.should == []
-    end
+    m2.refinements.should == ScratchPad.recorded
+  end
+
+  it "returns an empty array if no refinements defined in a module" do
+    Module.new.refinements.should == []
   end
 end
diff --git a/spec/ruby/core/module/ruby2_keywords_spec.rb b/spec/ruby/core/module/ruby2_keywords_spec.rb
index aca419f522..a9afad4aee 100644
--- a/spec/ruby/core/module/ruby2_keywords_spec.rb
+++ b/spec/ruby/core/module/ruby2_keywords_spec.rb
@@ -76,122 +76,60 @@ describe "Module#ruby2_keywords" do
     Hash.ruby2_keywords_hash?(marked).should == true
   end
 
-  ruby_version_is "3.2" do
-    it "makes a copy and unmark the Hash when calling a method taking (*args)" do
-      obj = Object.new
-      obj.singleton_class.class_exec do
-        def splat(*args)
-          args.last
-        end
-
-        def splat1(arg, *args)
-          args.last
-        end
+  it "makes a copy and unmark the Hash when calling a method taking (*args)" do
+    obj = Object.new
+    obj.singleton_class.class_exec do
+      def splat(*args)
+        args.last
+      end
 
-        def proc_call(*args)
-          -> *a { a.last }.call(*args)
-        end
+      def splat1(arg, *args)
+        args.last
       end
 
-      h = { a: 1 }
-      args = mark(**h)
-      marked = args.last
-      Hash.ruby2_keywords_hash?(marked).should == true
-
-      after_usage = obj.splat(*args)
-      after_usage.should == h
-      after_usage.should_not.equal?(h)
-      after_usage.should_not.equal?(marked)
-      Hash.ruby2_keywords_hash?(after_usage).should == false
-      Hash.ruby2_keywords_hash?(marked).should == true
-
-      args = mark(1, **h)
-      marked = args.last
-      after_usage = obj.splat1(*args)
-      after_usage.should == h
-      after_usage.should_not.equal?(h)
-      after_usage.should_not.equal?(marked)
-      Hash.ruby2_keywords_hash?(after_usage).should == false
-      Hash.ruby2_keywords_hash?(marked).should == true
-
-      args = mark(**h)
-      marked = args.last
-      after_usage = obj.proc_call(*args)
-      after_usage.should == h
-      after_usage.should_not.equal?(h)
-      after_usage.should_not.equal?(marked)
-      Hash.ruby2_keywords_hash?(after_usage).should == false
-      Hash.ruby2_keywords_hash?(marked).should == true
-
-      args = mark(**h)
-      marked = args.last
-      after_usage = obj.send(:splat, *args)
-      after_usage.should == h
-      after_usage.should_not.equal?(h)
-      after_usage.should_not.equal?(marked)
-      Hash.ruby2_keywords_hash?(after_usage).should == false
-      Hash.ruby2_keywords_hash?(marked).should == true
+      def proc_call(*args)
+        -> *a { a.last }.call(*args)
+      end
     end
-  end
 
-  ruby_version_is ""..."3.2" do
-    # https://bugs.ruby-lang.org/issues/18625
-    it "does NOT copy the Hash when calling a method taking (*args)" do
-      obj = Object.new
-      obj.singleton_class.class_exec do
-        def splat(*args)
-          args.last
-        end
+    h = { a: 1 }
+    args = mark(**h)
+    marked = args.last
+    Hash.ruby2_keywords_hash?(marked).should == true
 
-        def splat1(arg, *args)
-          args.last
-        end
+    after_usage = obj.splat(*args)
+    after_usage.should == h
+    after_usage.should_not.equal?(h)
+    after_usage.should_not.equal?(marked)
+    Hash.ruby2_keywords_hash?(after_usage).should == false
+    Hash.ruby2_keywords_hash?(marked).should == true
 
-        def proc_call(*args)
-          -> *a { a.last }.call(*args)
-        end
-      end
+    args = mark(1, **h)
+    marked = args.last
+    after_usage = obj.splat1(*args)
+    after_usage.should == h
+    after_usage.should_not.equal?(h)
+    after_usage.should_not.equal?(marked)
+    Hash.ruby2_keywords_hash?(after_usage).should == false
+    Hash.ruby2_keywords_hash?(marked).should == true
 
-      h = { a: 1 }
-      args = mark(**h)
-      marked = args.last
-      Hash.ruby2_keywords_hash?(marked).should == true
-
-      after_usage = obj.splat(*args)
-      after_usage.should == h
-      after_usage.should_not.equal?(h)
-      after_usage.should.equal?(marked) # https://bugs.ruby-lang.org/issues/18625
-      Hash.ruby2_keywords_hash?(after_usage).should == true # https://bugs.ruby-lang.org/issues/18625
-      Hash.ruby2_keywords_hash?(marked).should == true
-
-      args = mark(1, **h)
-      marked = args.last
-      after_usage = obj.splat1(*args)
-      after_usage.should == h
-      after_usage.should_not.equal?(h)
-      after_usage.should.equal?(marked) # https://bugs.ruby-lang.org/issues/18625
-      Hash.ruby2_keywords_hash?(after_usage).should == true # https://bugs.ruby-lang.org/issues/18625
-      Hash.ruby2_keywords_hash?(marked).should == true
-
-      args = mark(**h)
-      marked = args.last
-      after_usage = obj.proc_call(*args)
-      after_usage.should == h
-      after_usage.should_not.equal?(h)
-      after_usage.should.equal?(marked) # https://bugs.ruby-lang.org/issues/18625
-      Hash.ruby2_keywords_hash?(after_usage).should == true # https://bugs.ruby-lang.org/issues/18625
-      Hash.ruby2_keywords_hash?(marked).should == true
-
-      args = mark(**h)
-      marked = args.last
-      after_usage = obj.send(:splat, *args)
-      after_usage.should == h
-      after_usage.should_not.equal?(h)
-      send_copies = RUBY_ENGINE == "ruby" # inconsistent with Proc#call above for CRuby
-      after_usage.equal?(marked).should == !send_copies
-      Hash.ruby2_keywords_hash?(after_usage).should == !send_copies
-      Hash.ruby2_keywords_hash?(marked).should == true
-    end
+    args = mark(**h)
+    marked = args.last
+    after_usage = obj.proc_call(*args)
+    after_usage.should == h
+    after_usage.should_not.equal?(h)
+    after_usage.should_not.equal?(marked)
+    Hash.ruby2_keywords_hash?(after_usage).should == false
+    Hash.ruby2_keywords_hash?(marked).should == true
+
+    args = mark(**h)
+    marked = args.last
+    after_usage = obj.send(:splat, *args)
+    after_usage.should == h
+    after_usage.should_not.equal?(h)
+    after_usage.should_not.equal?(marked)
+    Hash.ruby2_keywords_hash?(after_usage).should == false
+    Hash.ruby2_keywords_hash?(marked).should == true
   end
 
   it "applies to the underlying method and applies across aliasing" do
diff --git a/spec/ruby/core/module/undefined_instance_methods_spec.rb b/spec/ruby/core/module/undefined_instance_methods_spec.rb
index 3be860d053..d33ee93fc1 100644
--- a/spec/ruby/core/module/undefined_instance_methods_spec.rb
+++ b/spec/ruby/core/module/undefined_instance_methods_spec.rb
@@ -2,25 +2,23 @@ require_relative '../../spec_helper'
 require_relative 'fixtures/classes'
 
 describe "Module#undefined_instance_methods" do
-  ruby_version_is "3.2" do
-    it "returns methods undefined in the class" do
-      methods = ModuleSpecs::UndefinedInstanceMethods::Parent.undefined_instance_methods
-      methods.should == [:undefed_method]
-    end
+  it "returns methods undefined in the class" do
+    methods = ModuleSpecs::UndefinedInstanceMethods::Parent.undefined_instance_methods
+    methods.should == [:undefed_method]
+  end
 
-    it "returns inherited methods undefined in the class" do
-      methods = ModuleSpecs::UndefinedInstanceMethods::Child.undefined_instance_methods
-      methods.should include(:parent_method, :another_parent_method)
-    end
+  it "returns inherited methods undefined in the class" do
+    methods = ModuleSpecs::UndefinedInstanceMethods::Child.undefined_instance_methods
+    methods.should include(:parent_method, :another_parent_method)
+  end
 
-    it "returns methods from an included module that are undefined in the class" do
-      methods = ModuleSpecs::UndefinedInstanceMethods::Grandchild.undefined_instance_methods
-      methods.should include(:super_included_method)
-    end
+  it "returns methods from an included module that are undefined in the class" do
+    methods = ModuleSpecs::UndefinedInstanceMethods::Grandchild.undefined_instance_methods
+    methods.should include(:super_included_method)
+  end
 
-    it "does not returns ancestors undefined methods" do
-      methods = ModuleSpecs::UndefinedInstanceMethods::Grandchild.undefined_instance_methods
-      methods.should_not include(:parent_method, :another_parent_method)
-    end
+  it "does not returns ancestors undefined methods" do
+    methods = ModuleSpecs::UndefinedInstanceMethods::Grandchild.undefined_instance_methods
+    methods.should_not include(:parent_method, :another_parent_method)
   end
 end
diff --git a/spec/ruby/core/module/used_refinements_spec.rb b/spec/ruby/core/module/used_refinements_spec.rb
index c16cab0e3c..40dd4a444e 100644
--- a/spec/ruby/core/module/used_refinements_spec.rb
+++ b/spec/ruby/core/module/used_refinements_spec.rb
@@ -1,87 +1,85 @@
 require_relative '../../spec_helper'
 
 describe "Module.used_refinements" do
-  ruby_version_is "3.2" do
-    it "returns list of all refinements imported in the current scope" do
-      refinement_int = nil
-      refinement_str = nil
-      ScratchPad.record []
-
-      m1 = Module.new do
-        refine Integer do
-          refinement_int = self
-        end
+  it "returns list of all refinements imported in the current scope" do
+    refinement_int = nil
+    refinement_str = nil
+    ScratchPad.record []
+
+    m1 = Module.new do
+      refine Integer do
+        refinement_int = self
       end
+    end
 
-      m2 = Module.new do
-        refine String do
-          refinement_str = self
-        end
+    m2 = Module.new do
+      refine String do
+        refinement_str = self
       end
+    end
 
-      Module.new do
-        using m1
-        using m2
+    Module.new do
+      using m1
+      using m2
 
-        Module.used_refinements.each { |r| ScratchPad << r }
-      end
-
-      ScratchPad.recorded.sort_by(&:object_id).should == [refinement_int, refinement_str].sort_by(&:object_id)
+      Module.used_refinements.each { |r| ScratchPad << r }
     end
 
-    it "returns empty array if does not have any refinements imported" do
-      used_refinements = nil
+    ScratchPad.recorded.sort_by(&:object_id).should == [refinement_int, refinement_str].sort_by(&:object_id)
+  end
 
-      Module.new do
-        used_refinements = Module.used_refinements
-      end
+  it "returns empty array if does not have any refinements imported" do
+    used_refinements = nil
 
-      used_refinements.should == []
+    Module.new do
+      used_refinements = Module.used_refinements
     end
 
-    it "ignores refinements imported in a module that is included into the current one" do
-      used_refinements = nil
+    used_refinements.should == []
+  end
 
-      m1 = Module.new do
-        refine Integer do
-          nil
-        end
-      end
+  it "ignores refinements imported in a module that is included into the current one" do
+    used_refinements = nil
 
-      m2 = Module.new do
-        using m1
+    m1 = Module.new do
+      refine Integer do
+        nil
       end
+    end
 
-      Module.new do
-        include m2
+    m2 = Module.new do
+      using m1
+    end
 
-        used_refinements = Module.used_refinements
-      end
+    Module.new do
+      include m2
 
-      used_refinements.should == []
+      used_refinements = Module.used_refinements
     end
 
-    it "returns refinements even not defined directly in a module refinements are imported from" do
-      used_refinements = nil
-      ScratchPad.record []
+    used_refinements.should == []
+  end
 
-      m1 = Module.new do
-        refine Integer do
-          ScratchPad << self
-        end
-      end
+  it "returns refinements even not defined directly in a module refinements are imported from" do
+    used_refinements = nil
+    ScratchPad.record []
 
-      m2 = Module.new do
-        include m1
+    m1 = Module.new do
+      refine Integer do
+        ScratchPad << self
       end
+    end
 
-      Module.new do
-        using m2
+    m2 = Module.new do
+      include m1
+    end
 
-        used_refinements = Module.used_refinements
-      end
+    Module.new do
+      using m2
 
-      used_refinements.should == ScratchPad.recorded
+      used_refinements = Module.used_refinements
     end
+
+    used_refinements.should == ScratchPad.recorded
   end
 end
diff --git a/spec/ruby/core/proc/parameters_spec.rb b/spec/ruby/core/proc/parameters_spec.rb
index 7a2723487d..e9bc9a1c57 100644
--- a/spec/ruby/core/proc/parameters_spec.rb
+++ b/spec/ruby/core/proc/parameters_spec.rb
@@ -20,29 +20,27 @@ describe "Proc#parameters" do
     proc {|x| }.parameters.first.first.should == :opt
   end
 
-  ruby_version_is "3.2" do
-    it "sets the first element of each sub-Array to :req for required argument if lambda keyword used" do
-      proc {|x| }.parameters(lambda: true).first.first.should == :req
-      proc {|y,*x| }.parameters(lambda: true).first.first.should == :req
-    end
+  it "sets the first element of each sub-Array to :req for required argument if lambda keyword used" do
+    proc {|x| }.parameters(lambda: true).first.first.should == :req
+    proc {|y,*x| }.parameters(lambda: true).first.first.should == :req
+  end
 
-    it "regards named parameters in procs as required if lambda keyword used" do
-      proc {|x| }.parameters(lambda: true).first.first.should == :req
-    end
+  it "regards named parameters in procs as required if lambda keyword used" do
+    proc {|x| }.parameters(lambda: true).first.first.should == :req
+  end
 
-    it "regards named parameters in lambda as optional if lambda: false keyword used" do
-      -> x { }.parameters(lambda: false).first.first.should == :opt
-    end
+  it "regards named parameters in lambda as optional if lambda: false keyword used" do
+    -> x { }.parameters(lambda: false).first.first.should == :opt
+  end
 
-    it "regards named parameters in procs and lambdas as required if lambda keyword is truthy" do
-      proc {|x| }.parameters(lambda: 123).first.first.should == :req
-      -> x { }.parameters(lambda: 123).first.first.should == :req
-    end
+  it "regards named parameters in procs and lambdas as required if lambda keyword is truthy" do
+    proc {|x| }.parameters(lambda: 123).first.first.should == :req
+    -> x { }.parameters(lambda: 123).first.first.should == :req
+  end
 
-    it "ignores the lambda keyword if it is nil" do
-      proc {|x|}.parameters(lambda: nil).first.first.should == :opt
-      -> x { }.parameters(lambda: nil).first.first.should == :req
-    end
+  it "ignores the lambda keyword if it is nil" do
+    proc {|x|}.parameters(lambda: nil).first.first.should == :opt
+    -> x { }.parameters(lambda: nil).first.first.should == :req
   end
 
   it "regards optional keyword parameters in procs as optional" do
@@ -110,24 +108,12 @@ describe "Proc#parameters" do
     -> x { }.parameters.should == [[:req, :x]]
   end
 
-  ruby_version_is '3.2' do
-    it "adds rest arg with name * for \"star\" argument" do
-      -> * {}.parameters.should == [[:rest, :*]]
-    end
-
-    it "adds keyrest arg with ** as a name for \"double star\" argument" do
-      -> ** {}.parameters.should == [[:keyrest, :**]]
-    end
+  it "adds rest arg with name * for \"star\" argument" do
+    -> * {}.parameters.should == [[:rest, :*]]
   end
 
-  ruby_version_is ''...'3.2' do
-    it "adds nameless rest arg for \"star\" argument" do
-      -> * {}.parameters.should == [[:rest]]
-    end
-
-    it "adds nameless keyrest arg for \"double star\" argument" do
-      -> ** {}.parameters.should == [[:keyrest]]
-    end
+  it "adds keyrest arg with ** as a name for \"double star\" argument" do
+    -> ** {}.parameters.should == [[:keyrest, :**]]
   end
 
   it "adds block arg with name & for anonymous block argument" do
diff --git a/spec/ruby/core/proc/shared/dup.rb b/spec/ruby/core/proc/shared/dup.rb
index 818f5b858e..1266337f94 100644
--- a/spec/ruby/core/proc/shared/dup.rb
+++ b/spec/ruby/core/proc/shared/dup.rb
@@ -8,12 +8,10 @@ describe :proc_dup, shared: true do
     a.call.should == b.call
   end
 
-  ruby_version_is "3.2" do
-    it "returns an instance of subclass" do
-      cl = Class.new(Proc)
+  it "returns an instance of subclass" do
+    cl = Class.new(Proc)
 
-      cl.new{}.send(@method).class.should == cl
-    end
+    cl.new{}.send(@method).class.should == cl
   end
 
   ruby_version_is "3.4" do
diff --git a/spec/ruby/core/process/_fork_spec.rb b/spec/ruby/core/process/_fork_spec.rb
index 8e907f54bb..e1f45e2656 100644
--- a/spec/ruby/core/process/_fork_spec.rb
+++ b/spec/ruby/core/process/_fork_spec.rb
@@ -5,6 +5,8 @@ describe "Process._fork" do
     Process.respond_to?(:_fork).should == Process.respond_to?(:fork)
   end
 
+  # Using respond_to? in a guard here is OK because the correct semantics
+  # are that _fork is implemented if and only if fork is (see above).
   guard_not -> { Process.respond_to?(:fork) } do
     it "raises a NotImplementedError when called" do
       -> { Process._fork }.should raise_error(NotImplementedError)
diff --git a/spec/ruby/core/queue/deq_spec.rb b/spec/ruby/core/queue/deq_spec.rb
index f84d4220ea..a2784e6a63 100644
--- a/spec/ruby/core/queue/deq_spec.rb
+++ b/spec/ruby/core/queue/deq_spec.rb
@@ -7,7 +7,5 @@ describe "Queue#deq" do
 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
+  it_behaves_like :rb_num2dbl_fails, nil, -> v { q = Queue.new; q.push(1); q.deq(timeout: v) }
 end
diff --git a/spec/ruby/core/queue/pop_spec.rb b/spec/ruby/core/queue/pop_spec.rb
index d344740834..3dff7db242 100644
--- a/spec/ruby/core/queue/pop_spec.rb
+++ b/spec/ruby/core/queue/pop_spec.rb
@@ -7,7 +7,5 @@ describe "Queue#pop" do
 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
+  it_behaves_like :rb_num2dbl_fails, nil, -> v { q = Queue.new; q.push(1); q.pop(timeout: v) }
 end
diff --git a/spec/ruby/core/queue/shift_spec.rb b/spec/ruby/core/queue/shift_spec.rb
index 64165e0b61..c105da74b2 100644
--- a/spec/ruby/core/queue/shift_spec.rb
+++ b/spec/ruby/core/queue/shift_spec.rb
@@ -7,7 +7,5 @@ describe "Queue#shift" do
 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
+  it_behaves_like :rb_num2dbl_fails, nil, -> v { q = Queue.new; q.push(1); q.shift(timeout: v) }
 end
diff --git a/spec/ruby/core/random/default_spec.rb b/spec/ruby/core/random/default_spec.rb
index 01d7430df8..9e4845986d 100644
--- a/spec/ruby/core/random/default_spec.rb
+++ b/spec/ruby/core/random/default_spec.rb
@@ -1,35 +1,7 @@
 require_relative '../../spec_helper'
 
 describe "Random::DEFAULT" do
-  ruby_version_is ''...'3.2' do
-    it "returns a random number generator" do
-      suppress_warning do
-        Random::DEFAULT.should respond_to(:rand)
-      end
-    end
-
-    it "changes seed on reboot" do
-      seed1 = ruby_exe('p Random::DEFAULT.seed', options: '--disable-gems')
-      seed2 = ruby_exe('p Random::DEFAULT.seed', options: '--disable-gems')
-      seed1.should != seed2
-    end
-
-    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
-  end
-
-  ruby_version_is '3.2' do
-    it "is no longer defined" do
-      Random.should_not.const_defined?(:DEFAULT)
-    end
+  it "is no longer defined" do
+    Random.should_not.const_defined?(:DEFAULT)
   end
 end
diff --git a/spec/ruby/core/range/case_compare_spec.rb b/spec/ruby/core/range/case_compare_spec.rb
index 65878aaabe..c9b253f0a5 100644
--- a/spec/ruby/core/range/case_compare_spec.rb
+++ b/spec/ruby/core/range/case_compare_spec.rb
@@ -11,7 +11,7 @@ describe "Range#===" do
   it_behaves_like :range_cover_and_include, :===
   it_behaves_like :range_cover, :===
 
-  ruby_bug "#19533", "3.2"..."3.3" do
+  ruby_bug "#19533", ""..."3.3" do
     it "returns true on any value if begin and end are both nil" do
       (nil..nil).should === 1
     end
diff --git a/spec/ruby/core/range/last_spec.rb b/spec/ruby/core/range/last_spec.rb
index 6698686dd5..82b3e2ff53 100644
--- a/spec/ruby/core/range/last_spec.rb
+++ b/spec/ruby/core/range/last_spec.rb
@@ -8,10 +8,8 @@ describe "Range#last" do
     (1..5).last(3).should == [3, 4, 5]
   end
 
-  ruby_bug '#18994', '2.7'...'3.2' do
-    it "returns the specified number if elements for single element inclusive range" do
-      (1..1).last(1).should == [1]
-    end
+  it "returns the specified number if elements for single element inclusive range" do
+    (1..1).last(1).should == [1]
   end
 
   it "returns an empty array for an empty Range" do
diff --git a/spec/ruby/core/range/size_spec.rb b/spec/ruby/core/range/size_spec.rb
index a1fe3ce17d..1a3ddd197e 100644
--- a/spec/ruby/core/range/size_spec.rb
+++ b/spec/ruby/core/range/size_spec.rb
@@ -22,16 +22,7 @@ describe "Range#size" do
     eval("('z'..)").size.should == nil
   end
 
-  ruby_version_is ""..."3.2" do
-    it 'returns Float::INFINITY for all beginless ranges' do
-      (..1).size.should == Float::INFINITY
-      (...0.5).size.should == Float::INFINITY
-      (..nil).size.should == Float::INFINITY
-      (...'o').size.should == Float::INFINITY
-    end
-  end
-
-  ruby_version_is "3.2"..."3.4" do
+  ruby_version_is ""..."3.4" do
     it 'returns Float::INFINITY for all beginless ranges if the end is numeric' do
       (..1).size.should == Float::INFINITY
       (...0.5).size.should == Float::INFINITY
diff --git a/spec/ruby/core/refinement/append_features_spec.rb b/spec/ruby/core/refinement/append_features_spec.rb
index fb84f245bd..f7e5f32bc1 100644
--- a/spec/ruby/core/refinement/append_features_spec.rb
+++ b/spec/ruby/core/refinement/append_features_spec.rb
@@ -1,20 +1,18 @@
 require_relative '../../spec_helper'
 
 describe "Refinement#append_features" do
-  ruby_version_is "3.2" do
-    it "is not defined" do
-      Refinement.should_not have_private_instance_method(:append_features)
-    end
+  it "is not defined" do
+    Refinement.should_not have_private_instance_method(:append_features)
+  end
 
-    it "is not called by Module#include" do
-      c = Class.new
-      Module.new do
-        refine c do
-          called = false
-          define_method(:append_features){called = true}
-          proc{c.include(self)}.should raise_error(TypeError)
-          called.should == false
-        end
+  it "is not called by Module#include" do
+    c = Class.new
+    Module.new do
+      refine c do
+        called = false
+        define_method(:append_features){called = true}
+        proc{c.include(self)}.should raise_error(TypeError)
+        called.should == false
       end
     end
   end
diff --git a/spec/ruby/core/refinement/extend_object_spec.rb b/spec/ruby/core/refinement/extend_object_spec.rb
index 6c2a0af4f3..4da8b359cc 100644
--- a/spec/ruby/core/refinement/extend_object_spec.rb
+++ b/spec/ruby/core/refinement/extend_object_spec.rb
@@ -1,22 +1,20 @@
 require_relative '../../spec_helper'
 
 describe "Refinement#extend_object" do
-  ruby_version_is "3.2" do
-    it "is not defined" do
-      Refinement.should_not have_private_instance_method(:extend_object)
-    end
+  it "is not defined" do
+    Refinement.should_not have_private_instance_method(:extend_object)
+  end
 
-    it "is not called by Object#extend" do
-      c = Class.new
-      Module.new do
-        refine c do
-          called = false
-          define_method(:extend_object) { called = true }
-          -> {
-            c.extend(self)
-          }.should raise_error(TypeError)
-          called.should == false
-        end
+  it "is not called by Object#extend" do
+    c = Class.new
+    Module.new do
+      refine c do
+        called = false
+        define_method(:extend_object) { called = true }
+        -> {
+          c.extend(self)
+        }.should raise_error(TypeError)
+        called.should == false
       end
     end
   end
diff --git a/spec/ruby/core/refinement/include_spec.rb b/spec/ruby/core/refinement/include_spec.rb
index d20ab47e33..57451bd9bc 100644
--- a/spec/ruby/core/refinement/include_spec.rb
+++ b/spec/ruby/core/refinement/include_spec.rb
@@ -1,26 +1,12 @@
 require_relative '../../spec_helper'
 
 describe "Refinement#include" do
-  ruby_version_is ""..."3.2" do
-    it "warns about deprecation" do
-      Module.new do
-        refine String do
-          -> {
-            include Module.new
-          }.should complain(/warning: Refinement#include is deprecated and will be removed in Ruby 3.2/)
-        end
-      end
-    end
-  end
-
-  ruby_version_is "3.2" do
-    it "raises a TypeError" do
-      Module.new do
-        refine String do
-          -> {
-            include Module.new
-          }.should raise_error(TypeError, "Refinement#include has been removed")
-        end
+  it "raises a TypeError" do
+    Module.new do
+      refine String do
+        -> {
+          include Module.new
+        }.should raise_error(TypeError, "Refinement#include has been removed")
       end
     end
   end
diff --git a/spec/ruby/core/refinement/prepend_features_spec.rb b/spec/ruby/core/refinement/prepend_features_spec.rb
index 9fdea199a2..fbc431bbd2 100644
--- a/spec/ruby/core/refinement/prepend_features_spec.rb
+++ b/spec/ruby/core/refinement/prepend_features_spec.rb
@@ -1,20 +1,18 @@
 require_relative '../../spec_helper'
 
 describe "Refinement#prepend_features" do
-  ruby_version_is "3.2" do
-    it "is not defined" do
-      Refinement.should_not have_private_instance_method(:prepend_features)
-    end
+  it "is not defined" do
+    Refinement.should_not have_private_instance_method(:prepend_features)
+  end
 
-    it "is not called by Module#prepend" do
-      c = Class.new
-      Module.new do
-        refine c do
-          called = false
-          define_method(:prepend_features){called = true}
-          proc{c.prepend(self)}.should raise_error(TypeError)
-          called.should == false
-        end
+  it "is not called by Module#prepend" do
+    c = Class.new
+    Module.new do
+      refine c do
+        called = false
+        define_method(:prepend_features){called = true}
+        proc{c.prepend(self)}.should raise_error(TypeError)
+        called.should == false
       end
     end
   end
diff --git a/spec/ruby/core/refinement/prepend_spec.rb b/spec/ruby/core/refinement/prepend_spec.rb
index 5d66766689..64cf7cd17f 100644
--- a/spec/ruby/core/refinement/prepend_spec.rb
+++ b/spec/ruby/core/refinement/prepend_spec.rb
@@ -1,26 +1,12 @@
 require_relative '../../spec_helper'
 
 describe "Refinement#prepend" do
-  ruby_version_is ""..."3.2" do
-    it "warns about deprecation" do
-      Module.new do
-        refine String do
-          -> {
-            prepend Module.new
-          }.should complain(/warning: Refinement#prepend is deprecated and will be removed in Ruby 3.2/)
-        end
-      end
-    end
-  end
-
-  ruby_version_is "3.2" do
-    it "raises a TypeError" do
-      Module.new do
-        refine String do
-          -> {
-            prepend Module.new
-          }.should raise_error(TypeError, "Refinement#prepend has been removed")
-        end
+  it "raises a TypeError" do
+    Module.new do
+      refine String do
+        -> {
+          prepend Module.new
+        }.should raise_error(TypeError, "Refinement#prepend has been removed")
       end
     end
   end
diff --git a/spec/ruby/core/refinement/refined_class_spec.rb b/spec/ruby/core/refinement/refined_class_spec.rb
index acc6e2cb2b..60a58380cc 100644
--- a/spec/ruby/core/refinement/refined_class_spec.rb
+++ b/spec/ruby/core/refinement/refined_class_spec.rb
@@ -2,7 +2,7 @@ require_relative "../../spec_helper"
 require_relative 'shared/target'
 
 describe "Refinement#refined_class" do
-  ruby_version_is "3.2"..."3.3" do
+  ruby_version_is ""..."3.3" do
     it_behaves_like :refinement_target, :refined_class
   end
 
diff --git a/spec/ruby/core/regexp/linear_time_spec.rb b/spec/ruby/core/regexp/linear_time_spec.rb
index 4dc436264f..a6f8dccd46 100644
--- a/spec/ruby/core/regexp/linear_time_spec.rb
+++ b/spec/ruby/core/regexp/linear_time_spec.rb
@@ -1,25 +1,23 @@
 require_relative '../../spec_helper'
 
-ruby_version_is "3.2" do
-  describe "Regexp.linear_time?" do
-    it "returns true if matching can be done in linear time" do
-      Regexp.linear_time?(/a/).should == true
-      Regexp.linear_time?('a').should == true
-    end
+describe "Regexp.linear_time?" do
+  it "returns true if matching can be done in linear time" do
+    Regexp.linear_time?(/a/).should == true
+    Regexp.linear_time?('a').should == true
+  end
 
-    it "return false if matching can't be done in linear time" do
-      Regexp.linear_time?(/(a)\1/).should == false
-      Regexp.linear_time?("(a)\\1").should == false
-    end
+  it "return false if matching can't be done in linear time" do
+    Regexp.linear_time?(/(a)\1/).should == false
+    Regexp.linear_time?("(a)\\1").should == false
+  end
 
-    it "accepts flags for string argument" do
-      Regexp.linear_time?('a', Regexp::IGNORECASE).should == true
-    end
+  it "accepts flags for string argument" do
+    Regexp.linear_time?('a', Regexp::IGNORECASE).should == true
+  end
 
-    it "warns about flags being ignored for regexp arguments" do
-      -> {
-        Regexp.linear_time?(/a/, Regexp::IGNORECASE)
-      }.should complain(/warning: flags ignored/)
-    end
+  it "warns about flags being ignored for regexp arguments" do
+    -> {
+      Regexp.linear_time?(/a/, Regexp::IGNORECASE)
+    }.should complain(/warning: flags ignored/)
   end
 end
diff --git a/spec/ruby/core/regexp/shared/new.rb b/spec/ruby/core/regexp/shared/new.rb
index 3ca50d5a47..44b339100e 100644
--- a/spec/ruby/core/regexp/shared/new.rb
+++ b/spec/ruby/core/regexp/shared/new.rb
@@ -123,140 +123,67 @@ describe :regexp_new_string, shared: true do
     (r.options & Regexp::EXTENDED).should_not == 0
   end
 
-  ruby_version_is ""..."3.2" do
-    it "does not try to convert the second argument to Integer with #to_int method call" do
-      ScratchPad.clear
-      obj = Object.new
-      def obj.to_int() ScratchPad.record(:called) end
+  it "does not try to convert the second argument to Integer with #to_int method call" do
+    ScratchPad.clear
+    obj = Object.new
+    def obj.to_int() ScratchPad.record(:called) end
 
+    -> {
       Regexp.send(@method, "Hi", obj)
+    }.should complain(/expected true or false as ignorecase/, {verbose: true})
 
-      ScratchPad.recorded.should == nil
-    end
-  end
-
-  ruby_version_is "3.2" do
-    it "does not try to convert the second argument to Integer with #to_int method call" do
-      ScratchPad.clear
-      obj = Object.new
-      def obj.to_int() ScratchPad.record(:called) end
-
-      -> {
-        Regexp.send(@method, "Hi", obj)
-      }.should complain(/expected true or false as ignorecase/, {verbose: true})
-
-      ScratchPad.recorded.should == nil
-    end
+    ScratchPad.recorded.should == nil
   end
 
-  ruby_version_is ""..."3.2" do
-    it "treats any non-Integer, non-nil, non-false second argument as IGNORECASE" do
+  it "warns any non-Integer, non-nil, non-false second argument" do
+    r = nil
+    -> {
       r = Regexp.send(@method, 'Hi', Object.new)
-      (r.options & Regexp::IGNORECASE).should_not == 0
-      (r.options & Regexp::MULTILINE).should == 0
-      not_supported_on :opal do
-        (r.options & Regexp::EXTENDED).should == 0
-      end
-    end
-  end
-
-  ruby_version_is "3.2" do
-    it "warns any non-Integer, non-nil, non-false second argument" do
-      r = nil
-      -> {
-        r = Regexp.send(@method, 'Hi', Object.new)
-      }.should complain(/expected true or false as ignorecase/, {verbose: true})
-      (r.options & Regexp::IGNORECASE).should_not == 0
-      (r.options & Regexp::MULTILINE).should == 0
-      not_supported_on :opal do
-        (r.options & Regexp::EXTENDED).should == 0
-      end
-    end
-
-    it "accepts a String of supported flags as the second argument" do
-      r = Regexp.send(@method, 'Hi', 'i')
-      (r.options & Regexp::IGNORECASE).should_not == 0
-      (r.options & Regexp::MULTILINE).should == 0
-      not_supported_on :opal do
-        (r.options & Regexp::EXTENDED).should == 0
-      end
-
-      r = Regexp.send(@method, 'Hi', 'imx')
-      (r.options & Regexp::IGNORECASE).should_not == 0
-      (r.options & Regexp::MULTILINE).should_not == 0
-      not_supported_on :opal do
-        (r.options & Regexp::EXTENDED).should_not == 0
-      end
-
-      r = Regexp.send(@method, 'Hi', 'mimi')
-      (r.options & Regexp::IGNORECASE).should_not == 0
-      (r.options & Regexp::MULTILINE).should_not == 0
-      not_supported_on :opal do
-        (r.options & Regexp::EXTENDED).should == 0
-      end
-
-      r = Regexp.send(@method, 'Hi', '')
-      (r.options & Regexp::IGNORECASE).should == 0
-      (r.options & Regexp::MULTILINE).should == 0
-      not_supported_on :opal do
-        (r.options & Regexp::EXTENDED).should == 0
-      end
-    end
-
-    it "raises an Argument error if the second argument contains unsupported chars" do
-      -> { Regexp.send(@method, 'Hi', 'e') }.should raise_error(ArgumentError, "unknown regexp option: e")
-      -> { Regexp.send(@method, 'Hi', 'n') }.should raise_error(ArgumentError, "unknown regexp option: n")
-      -> { Regexp.send(@method, 'Hi', 's') }.should raise_error(ArgumentError, "unknown regexp option: s")
-      -> { Regexp.send(@method, 'Hi', 'u') }.should raise_error(ArgumentError, "unknown regexp option: u")
-      -> { Regexp.send(@method, 'Hi', 'j') }.should raise_error(ArgumentError, "unknown regexp option: j")
-      -> { Regexp.send(@method, 'Hi', 'mjx') }.should raise_error(ArgumentError, /unknown regexp option: mjx\b/)
+    }.should complain(/expected true or false as ignorecase/, {verbose: true})
+    (r.options & Regexp::IGNORECASE).should_not == 0
+    (r.options & Regexp::MULTILINE).should == 0
+    not_supported_on :opal do
+      (r.options & Regexp::EXTENDED).should == 0
     end
   end
 
-  ruby_version_is ""..."3.2" do
-    it "ignores the third argument if it is 'e' or 'euc' (case-insensitive)" do
-      -> {
-        Regexp.send(@method, 'Hi', nil, 'e').encoding.should == Encoding::US_ASCII
-        Regexp.send(@method, 'Hi', nil, 'euc').encoding.should == Encoding::US_ASCII
-        Regexp.send(@method, 'Hi', nil, 'E').encoding.should == Encoding::US_ASCII
-        Regexp.send(@method, 'Hi', nil, 'EUC').encoding.should == Encoding::US_ASCII
-      }.should complain(/encoding option is ignored/)
+  it "accepts a String of supported flags as the second argument" do
+    r = Regexp.send(@method, 'Hi', 'i')
+    (r.options & Regexp::IGNORECASE).should_not == 0
+    (r.options & Regexp::MULTILINE).should == 0
+    not_supported_on :opal do
+      (r.options & Regexp::EXTENDED).should == 0
     end
 
-    it "ignores the third argument if it is 's' or 'sjis' (case-insensitive)" do
-      -> {
-        Regexp.send(@method, 'Hi', nil, 's').encoding.should == Encoding::US_ASCII
-        Regexp.send(@method, 'Hi', nil, 'sjis').encoding.should == Encoding::US_ASCII
-        Regexp.send(@method, 'Hi', nil, 'S').encoding.should == Encoding::US_ASCII
-        Regexp.send(@method, 'Hi', nil, 'SJIS').encoding.should == Encoding::US_ASCII
-      }.should complain(/encoding option is ignored/)
+    r = Regexp.send(@method, 'Hi', 'imx')
+    (r.options & Regexp::IGNORECASE).should_not == 0
+    (r.options & Regexp::MULTILINE).should_not == 0
+    not_supported_on :opal do
+      (r.options & Regexp::EXTENDED).should_not == 0
     end
 
-    it "ignores the third argument if it is 'u' or 'utf8' (case-insensitive)" do
-      -> {
-        Regexp.send(@method, 'Hi', nil, 'u').encoding.should == Encoding::US_ASCII
-        Regexp.send(@method, 'Hi', nil, 'utf8').encoding.should == Encoding::US_ASCII
-        Regexp.send(@method, 'Hi', nil, 'U').encoding.should == Encoding::US_ASCII
-        Regexp.send(@method, 'Hi', nil, 'UTF8').encoding.should == Encoding::US_ASCII
-      }.should complain(/encoding option is ignored/)
+    r = Regexp.send(@method, 'Hi', 'mimi')
+    (r.options & Regexp::IGNORECASE).should_not == 0
+    (r.options & Regexp::MULTILINE).should_not == 0
+    not_supported_on :opal do
+      (r.options & Regexp::EXTENDED).should == 0
     end
 
-    it "uses US_ASCII encoding if third argument is 'n' or 'none' (case insensitive) and only ascii characters" do
-      Regexp.send(@method, 'Hi', nil, 'n').encoding.should == Encoding::US_ASCII
-      Regexp.send(@method, 'Hi', nil, 'none').encoding.should == Encoding::US_ASCII
-      Regexp.send(@method, 'Hi', nil, 'N').encoding.should == Encoding::US_ASCII
-      Regexp.send(@method, 'Hi', nil, 'NONE').encoding.should == Encoding::US_ASCII
+    r = Regexp.send(@method, 'Hi', '')
+    (r.options & Regexp::IGNORECASE).should == 0
+    (r.options & Regexp::MULTILINE).should == 0
+    not_supported_on :opal do
+      (r.options & Regexp::EXTENDED).should == 0
     end
+  end
 
-    it "uses ASCII_8BIT encoding if third argument is 'n' or 'none' (case insensitive) and non-ascii characters" do
-      a = "(?:[\x8E\xA1-\xFE])"
-      str = "\A(?:#{a}|x*)\z"
-
-      Regexp.send(@method, str, nil, 'N').encoding.should == Encoding::BINARY
-      Regexp.send(@method, str, nil, 'n').encoding.should == Encoding::BINARY
-      Regexp.send(@method, str, nil, 'none').encoding.should == Encoding::BINARY
-      Regexp.send(@method, str, nil, 'NONE').encoding.should == Encoding::BINARY
-    end
+  it "raises an Argument error if the second argument contains unsupported chars" do
+    -> { Regexp.send(@method, 'Hi', 'e') }.should raise_error(ArgumentError, "unknown regexp option: e")
+    -> { Regexp.send(@method, 'Hi', 'n') }.should raise_error(ArgumentError, "unknown regexp option: n")
+    -> { Regexp.send(@method, 'Hi', 's') }.should raise_error(ArgumentError, "unknown regexp option: s")
+    -> { Regexp.send(@method, 'Hi', 'u') }.should raise_error(ArgumentError, "unknown regexp option: u")
+    -> { Regexp.send(@method, 'Hi', 'j') }.should raise_error(ArgumentError, "unknown regexp option: j")
+    -> { Regexp.send(@method, 'Hi', 'mjx') }.should raise_error(ArgumentError, /unknown regexp option: mjx\b/)
   end
 
   describe "with escaped characters" do
@@ -623,11 +550,5 @@ describe :regexp_new_regexp, shared: true do
     it "sets the encoding to US-ASCII if the Regexp literal has the 'n' option and the source String is ASCII only" do
       Regexp.send(@method, /Hi/n).encoding.should == Encoding::US_ASCII
     end
-
-    ruby_version_is ''...'3.2' do
-      it "sets the encoding to source String's encoding if the Regexp literal has the 'n' option and the source String is not ASCII only" do
-        Regexp.send(@method, Regexp.new("\\xff", nil, 'n')).encoding.should == Encoding::BINARY
-      end
-    end
   end
 end
diff --git a/spec/ruby/core/regexp/timeout_spec.rb b/spec/ruby/core/regexp/timeout_spec.rb
index 6fce261814..c64103c82c 100644
--- a/spec/ruby/core/regexp/timeout_spec.rb
+++ b/spec/ruby/core/regexp/timeout_spec.rb
@@ -1,35 +1,33 @@
 require_relative '../../spec_helper'
 
-ruby_version_is "3.2" do
-  describe "Regexp.timeout" do
-    after :each do
-      Regexp.timeout = nil
-    end
+describe "Regexp.timeout" do
+  after :each do
+    Regexp.timeout = nil
+  end
 
-    it "returns global timeout" do
-      Regexp.timeout = 3
-      Regexp.timeout.should == 3
-    end
+  it "returns global timeout" do
+    Regexp.timeout = 3
+    Regexp.timeout.should == 3
+  end
 
-    it "raises Regexp::TimeoutError after global timeout elapsed" do
-      Regexp.timeout = 0.001
-      Regexp.timeout.should == 0.001
+  it "raises Regexp::TimeoutError after global timeout elapsed" do
+    Regexp.timeout = 0.001
+    Regexp.timeout.should == 0.001
 
-      -> {
-        # A typical ReDoS case
-        /^(a*)*$/ =~ "a" * 1000000 + "x"
-      }.should raise_error(Regexp::TimeoutError, "regexp match timeout")
-    end
+    -> {
+      # A typical ReDoS case
+      /^(a*)*$/ =~ "a" * 1000000 + "x"
+    }.should raise_error(Regexp::TimeoutError, "regexp match timeout")
+  end
 
-    it "raises Regexp::TimeoutError after timeout keyword value elapsed" do
-      Regexp.timeout = 3 # This should be ignored
-      Regexp.timeout.should == 3
+  it "raises Regexp::TimeoutError after timeout keyword value elapsed" do
+    Regexp.timeout = 3 # This should be ignored
+    Regexp.timeout.should == 3
 
-      re = Regexp.new("^a*b?a*$", timeout: 0.001)
+    re = Regexp.new("^a*b?a*$", timeout: 0.001)
 
-      -> {
-        re =~ "a" * 1000000 + "x"
-      }.should raise_error(Regexp::TimeoutError, "regexp match timeout")
-    end
+    -> {
+      re =~ "a" * 1000000 + "x"
+    }.should raise_error(Regexp::TimeoutError, "regexp match timeout")
   end
 end
diff --git a/spec/ruby/core/set/add_spec.rb b/spec/ruby/core/set/add_spec.rb
new file mode 100644
index 0000000000..73662acfd1
--- /dev/null
+++ b/spec/ruby/core/set/add_spec.rb
@@ -0,0 +1,26 @@
+require_relative '../../spec_helper'
+require_relative 'shared/add'
+
+describe "Set#add" do
+  it_behaves_like :set_add, :add
+end
+
+describe "Set#add?" do
+  before :each do
+    @set = Set.new
+  end
+
+  it "adds the passed Object to self" do
+    @set.add?("cat")
+    @set.should include("cat")
+  end
+
+  it "returns self when the Object has not yet been added to self" do
+    @set.add?("cat").should equal(@set)
+  end
+
+  it "returns nil when the Object has already been added to self" do
+    @set.add?("cat")
+    @set.add?("cat").should be_nil
+  end
+end
diff --git a/spec/ruby/core/set/append_spec.rb b/spec/ruby/core/set/append_spec.rb
new file mode 100644
index 0000000000..82d34d9130
--- /dev/null
+++ b/spec/ruby/core/set/append_spec.rb
@@ -0,0 +1,6 @@
+require_relative '../../spec_helper'
+require_relative 'shared/add'
+
+describe "Set#<<" do
+  it_behaves_like :set_add, :<<
+end
diff --git a/spec/ruby/core/set/case_compare_spec.rb b/spec/ruby/core/set/case_compare_spec.rb
new file mode 100644
index 0000000000..3781b1b963
--- /dev/null
+++ b/spec/ruby/core/set/case_compare_spec.rb
@@ -0,0 +1,11 @@
+require_relative '../../spec_helper'
+require_relative 'shared/include'
+
+describe "Set#===" do
+  it_behaves_like :set_include, :===
+
+  it "is an alias for include?" do
+    set = Set.new
+    set.method(:===).should == set.method(:include?)
+  end
+end
diff --git a/spec/ruby/core/set/case_equality_spec.rb b/spec/ruby/core/set/case_equality_spec.rb
new file mode 100644
index 0000000000..19c1fb6b9c
--- /dev/null
+++ b/spec/ruby/core/set/case_equality_spec.rb
@@ -0,0 +1,6 @@
+require_relative '../../spec_helper'
+require_relative 'shared/include'
+
+describe "Set#===" do
+  it_behaves_like :set_include, :===
+end
diff --git a/spec/ruby/core/set/classify_spec.rb b/spec/ruby/core/set/classify_spec.rb
new file mode 100644
index 0000000000..d86ea2722d
--- /dev/null
+++ b/spec/ruby/core/set/classify_spec.rb
@@ -0,0 +1,26 @@
+require_relative '../../spec_helper'
+
+describe "Set#classify" do
+  before :each do
+    @set = Set["one", "two", "three", "four"]
+  end
+
+  it "yields each Object in self" do
+    res = []
+    @set.classify { |x| res << x }
+    res.sort.should == ["one", "two", "three", "four"].sort
+  end
+
+  it "returns an Enumerator when passed no block" do
+    enum = @set.classify
+    enum.should be_an_instance_of(Enumerator)
+
+    classified = enum.each { |x| x.length }
+    classified.should == { 3 => Set["one", "two"], 4 => Set["four"], 5 => Set["three"] }
+  end
+
+  it "classifies the Objects in self based on the block's return value" do
+    classified = @set.classify { |x| x.length }
+    classified.should == { 3 => Set["one", "two"], 4 => Set["four"], 5 => Set["three"] }
+  end
+end
diff --git a/spec/ruby/core/set/clear_spec.rb b/spec/ruby/core/set/clear_spec.rb
new file mode 100644
index 0000000000..ebeac211d3
--- /dev/null
+++ b/spec/ruby/core/set/clear_spec.rb
@@ -0,0 +1,16 @@
+require_relative '../../spec_helper'
+
+describe "Set#clear" do
+  before :each do
+    @set = Set["one", "two", "three", "four"]
+  end
+
+  it "removes all elements from self" do
+    @set.clear
+    @set.should be_empty
+  end
+
+  it "returns self" do
+    @set.clear.should equal(@set)
+  end
+end
diff --git a/spec/ruby/core/set/collect_spec.rb b/spec/ruby/core/set/collect_spec.rb
new file mode 100644
index 0000000000..d186f1a0d9
--- /dev/null
+++ b/spec/ruby/core/set/collect_spec.rb
@@ -0,0 +1,6 @@
+require_relative '../../spec_helper'
+require_relative 'shared/collect'
+
+describe "Set#collect!" do
+  it_behaves_like :set_collect_bang, :collect!
+end
diff --git a/spec/ruby/core/set/compare_by_identity_spec.rb b/spec/ruby/core/set/compare_by_identity_spec.rb
new file mode 100644
index 0000000000..00bb8e4e6a
--- /dev/null
+++ b/spec/ruby/core/set/compare_by_identity_spec.rb
@@ -0,0 +1,153 @@
+require_relative '../../spec_helper'
+
+describe "Set#compare_by_identity" do
+  it "compares its members by identity" do
+    a = "a"
+    b1 = "b"
+    b2 = b1.dup
+
+    set = Set.new
+    set.compare_by_identity
+    set.merge([a, a, b1, b2])
+    set.to_a.sort.should == [a, b1, b2].sort
+  end
+
+  it "causes future comparisons on the receiver to be made by identity" do
+    elt = [1]
+    set = Set.new
+    set << elt
+    set.member?(elt.dup).should be_true
+    set.compare_by_identity
+    set.member?(elt.dup).should be_false
+  end
+
+  it "rehashes internally so that old members can be looked up" do
+    set = Set.new
+    (1..10).each { |k| set << k }
+    o = Object.new
+    def o.hash; 123; end
+    set << o
+    set.compare_by_identity
+    set.member?(o).should be_true
+  end
+
+  it "returns self" do
+    set = Set.new
+    result = set.compare_by_identity
+    result.should equal(set)
+  end
+
+  it "is idempotent and has no effect on an already compare_by_identity set" do
+    set = Set.new.compare_by_identity
+    set << :foo
+    set.compare_by_identity.should equal(set)
+    set.should.compare_by_identity?
+    set.to_a.should == [:foo]
+  end
+
+  it "uses the semantics of BasicObject#equal? to determine members identity" do
+    :a.equal?(:a).should == true
+    Set.new.compare_by_identity.merge([:a, :a]).to_a.should == [:a]
+
+    ary1 = [1]
+    ary2 = [1]
+    ary1.equal?(ary2).should == false
+    Set.new.compare_by_identity.merge([ary1, ary2]).to_a.sort.should == [ary1, ary2].sort
+  end
+
+  it "uses #equal? semantics, but doesn't actually call #equal? to determine identity" do
+    set = Set.new.compare_by_identity
+    obj = mock("equal")
+    obj.should_not_receive(:equal?)
+    set << :foo
+    set << obj
+    set.to_a.should == [:foo, obj]
+  end
+
+  it "does not call #hash on members" do
+    elt = mock("element")
+    elt.should_not_receive(:hash)
+    set = Set.new.compare_by_identity
+    set << elt
+    set.member?(elt).should be_true
+  end
+
+  it "regards #dup'd objects as having different identities" do
+    a1 = "a"
+    a2 = a1.dup
+
+    set = Set.new.compare_by_identity
+    set.merge([a1, a2])
+    set.to_a.sort.should == [a1, a2].sort
+  end
+
+  it "regards #clone'd objects as having different identities" do
+    a1 = "a"
+    a2 = a1.clone
+
+    set = Set.new.compare_by_identity
+    set.merge([a1, a2])
+    set.to_a.sort.should == [a1, a2].sort
+  end
+
+  ruby_version_is "3.5" do
+    it "raises a FrozenError on frozen sets" do
+      set = Set.new.freeze
+      -> {
+        set.compare_by_identity
+      }.should raise_error(FrozenError, "can't modify frozen Set: #<Set: {}>")
+    end
+  end
+
+  ruby_version_is ""..."3.5" do
+    it "raises a FrozenError on frozen sets" do
+      set = Set.new.freeze
+      -> {
+        set.compare_by_identity
+      }.should raise_error(FrozenError, /frozen Hash/)
+    end
+  end
+
+  it "persists over #dups" do
+    set = Set.new.compare_by_identity
+    set << :a
+    set_dup = set.dup
+    set_dup.should == set
+    set_dup << :a
+    set_dup.to_a.should == [:a]
+  end
+
+  it "persists over #clones" do
+    set = Set.new.compare_by_identity
+    set << :a
+    set_clone = set.clone
+    set_clone.should == set
+    set_clone << :a
+    set_clone.to_a.should == [:a]
+  end
+
+  it "is not equal to set what does not compare by identity" do
+    Set.new([1, 2]).should == Set.new([1, 2])
+    Set.new([1, 2]).should_not == Set.new([1, 2]).compare_by_identity
+  end
+end
+
+describe "Set#compare_by_identity?" do
+  it "returns false by default" do
+    Set.new.should_not.compare_by_identity?
+  end
+
+  it "returns true once #compare_by_identity has been invoked on self" do
+    set = Set.new
+    set.compare_by_identity
+    set.should.compare_by_identity?
+  end
+
+  it "returns true when called multiple times on the same set" do
+    set = Set.new
+    set.compare_by_identity
+    set.should.compare_by_identity?
+    set.should.compare_by_identity?
+    set.should.compare_by_identity?
+  end
+end
diff --git a/spec/ruby/core/set/comparison_spec.rb b/spec/ruby/core/set/comparison_spec.rb
new file mode 100644
index 0000000000..62059b70b3
--- /dev/null
+++ b/spec/ruby/core/set/comparison_spec.rb
@@ -0,0 +1,26 @@
+require_relative '../../spec_helper'
+
+describe "Set#<=>" do
+  it "returns 0 if the sets are equal" do
+    (Set[] <=> Set[]).should == 0
+    (Set[:a, :b, :c] <=> Set[:a, :b, :c]).should == 0
+  end
+
+  it "returns -1 if the set is a proper subset of the other set" do
+    (Set[] <=> Set[1]).should == -1
+    (Set[1, 2] <=> Set[1, 2, 3]).should == -1
+  end
+
+  it "returns +1 if the set is a proper superset of other set" do
+    (Set[1] <=> Set[]).should == +1
+    (Set[1, 2, 3] <=> Set[1, 2]).should == +1
+  end
+
+  it "returns nil if the set has unique elements" do
+    (Set[1, 2, 3] <=> Set[:a, :b, :c]).should be_nil
+  end
+
+  it "returns nil when the argument is not set-like" do
+    (Set[] <=> false).should be_nil
+  end
+end
diff --git a/spec/ruby/core/set/constructor_spec.rb b/spec/ruby/core/set/constructor_spec.rb
new file mode 100644
index 0000000000..365081ad39
--- /dev/null
+++ b/spec/ruby/core/set/constructor_spec.rb
@@ -0,0 +1,14 @@
+require_relative '../../spec_helper'
+
+describe "Set[]" do
+  it "returns a new Set populated with the passed Objects" do
+    set = Set[1, 2, 3]
+
+    set.instance_of?(Set).should be_true
+    set.size.should eql(3)
+
+    set.should include(1)
+    set.should include(2)
+    set.should include(3)
+  end
+end
diff --git a/spec/ruby/core/set/delete_if_spec.rb b/spec/ruby/core/set/delete_if_spec.rb
new file mode 100644
index 0000000000..beda73a5e5
--- /dev/null
+++ b/spec/ruby/core/set/delete_if_spec.rb
@@ -0,0 +1,37 @@
+require_relative '../../spec_helper'
+
+describe "Set#delete_if" do
+  before :each do
+    @set = Set["one", "two", "three"]
+  end
+
+  it "yields every element of self" do
+    ret = []
+    @set.delete_if { |x| ret << x }
+    ret.sort.should == ["one", "two", "three"].sort
+  end
+
+  it "deletes every element from self for which the passed block returns true" do
+    @set.delete_if { |x| x.size == 3 }
+    @set.size.should eql(1)
+
+    @set.should_not include("one")
+    @set.should_not include("two")
+    @set.should include("three")
+  end
+
+  it "returns self" do
+    @set.delete_if { |x| x }.should equal(@set)
+  end
+
+  it "returns an Enumerator when passed no block" do
+    enum = @set.delete_if
+    enum.should be_an_instance_of(Enumerator)
+
+    enum.each { |x| x.size == 3 }
+
+    @set.should_not include("one")
+    @set.should_not include("two")
+    @set.should include("three")
+  end
+end
diff --git a/spec/ruby/core/set/delete_spec.rb b/spec/ruby/core/set/delete_spec.rb
new file mode 100644
index 0000000000..a2543ecbee
--- /dev/null
+++ b/spec/ruby/core/set/delete_spec.rb
@@ -0,0 +1,36 @@
+require_relative '../../spec_helper'
+
+describe "Set#delete" do
+  before :each do
+    @set = Set["a", "b", "c"]
+  end
+
+  it "deletes the passed Object from self" do
+    @set.delete("a")
+    @set.should_not include("a")
+  end
+
+  it "returns self" do
+    @set.delete("a").should equal(@set)
+    @set.delete("x").should equal(@set)
+  end
+end
+
+describe "Set#delete?" do
+  before :each do
+    @set = Set["a", "b", "c"]
+  end
+
+  it "deletes the passed Object from self" do
+    @set.delete?("a")
+    @set.should_not include("a")
+  end
+
+  it "returns self when the passed Object is in self" do
+    @set.delete?("a").should equal(@set)
+  end
+
+  it "returns nil when the passed Object is not in self" do
+    @set.delete?("x").should be_nil
+  end
+end
diff --git a/spec/ruby/core/set/difference_spec.rb b/spec/ruby/core/set/difference_spec.rb
new file mode 100644
index 0000000000..149f946592
--- /dev/null
+++ b/spec/ruby/core/set/difference_spec.rb
@@ -0,0 +1,6 @@
+require_relative '../../spec_helper'
+require_relative 'shared/difference'
+
+describe "Set#difference" do
+  it_behaves_like :set_difference, :difference
+end
diff --git a/spec/ruby/core/set/disjoint_spec.rb b/spec/ruby/core/set/disjoint_spec.rb
new file mode 100644
index 0000000000..89a3c4b157
--- /dev/null
+++ b/spec/ruby/core/set/disjoint_spec.rb
@@ -0,0 +1,22 @@
+require_relative '../../spec_helper'
+require_relative 'fixtures/set_like'
+
+describe "Set#disjoint?" do
+  it "returns false when two Sets have at least one element in common" do
+    Set[1, 2].disjoint?(Set[2, 3]).should == false
+  end
+
+  it "returns true when two Sets have no element in common" do
+    Set[1, 2].disjoint?(Set[3, 4]).should == true
+  end
+
+  context "when comparing to a Set-like object" do
+    it "returns false when a Set has at least one element in common with a Set-like object" do
+      Set[1, 2].disjoint?(SetSpecs::SetLike.new([2, 3])).should be_false
+    end
+
+    it "returns true when a Set has no element in common with a Set-like object" do
+      Set[1, 2].disjoint?(SetSpecs::SetLike.new([3, 4])).should be_true
+    end
+  end
+end
diff --git a/spec/ruby/core/set/divide_spec.rb b/spec/ruby/core/set/divide_spec.rb
new file mode 100644
index 0000000000..cbe0042f16
--- /dev/null
+++ b/spec/ruby/core/set/divide_spec.rb
@@ -0,0 +1,68 @@
+require_relative '../../spec_helper'
+
+describe "Set#divide" do
+  it "divides self into a set of subsets based on the blocks return values" do
+    set = Set["one", "two", "three", "four", "five"].divide { |x| x.length }
+    set.map { |x| x.to_a.sort }.sort.should == [["five", "four"], ["one", "two"], ["three"]]
+  end
+
+  it "yields each Object to the block" do
+    ret = []
+    Set["one", "two", "three", "four", "five"].divide { |x| ret << x }
+    ret.sort.should == ["five", "four", "one", "three", "two"]
+  end
+
+  it "returns an enumerator when not passed a block" do
+    ret = Set[1, 2, 3, 4].divide
+    ret.should be_kind_of(Enumerator)
+    ret.each(&:even?).should == Set[Set[1, 3], Set[2, 4]]
+  end
+end
+
+describe "Set#divide when passed a block with an arity of 2" do
+  it "divides self into a set of subsets based on the blocks return values" do
+    set = Set[1, 3, 4, 6, 9, 10, 11].divide { |x, y| (x - y).abs == 1 }
+    set.map{ |x| x.to_a.sort }.sort.should == [[1], [3, 4], [6], [9, 10, 11]]
+  end
+
+  ruby_version_is "3.5" do
+    it "yields each two Object to the block" do
+      ret = []
+      Set[1, 2].divide { |x, y| ret << [x, y] }
+      ret.sort.should == [[1, 2], [2, 1]]
+    end
+  end
+
+  ruby_version_is ""..."3.5" do
+    it "yields each two Object to the block" do
+      ret = []
+      Set[1, 2].divide { |x, y| ret << [x, y] }
+      ret.sort.should == [[1, 1], [1, 2], [2, 1], [2, 2]]
+    end
+  end
+
+  it "returns an enumerator when not passed a block" do
+    ret = Set[1, 2, 3, 4].divide
+    ret.should be_kind_of(Enumerator)
+    ret.each { |a, b| (a + b).even? }.should == Set[Set[1, 3], Set[2, 4]]
+  end
+end
+
+describe "Set#divide when passed a block with an arity of > 2" do
+  it "only uses the first element if the arity > 2" do
+    set = Set["one", "two", "three", "four", "five"].divide do |x, y, z|
+      y.should be_nil
+      z.should be_nil
+      x.length
+    end
+    set.map { |x| x.to_a.sort }.sort.should == [["five", "four"], ["one", "two"], ["three"]]
+  end
+
+  it "only uses the first element if the arity = -1" do
+    set = Set["one", "two", "three", "four", "five"].divide do |*xs|
+      xs.size.should == 1
+      xs.first.length
+    end
+    set.map { |x| x.to_a.sort }.sort.should == [["five", "four"], ["one", "two"], ["three"]]
+  end
+end
diff --git a/spec/ruby/core/set/each_spec.rb b/spec/ruby/core/set/each_spec.rb
new file mode 100644
index 0000000000..3d9cdc2d46
--- /dev/null
+++ b/spec/ruby/core/set/each_spec.rb
@@ -0,0 +1,26 @@
+require_relative '../../spec_helper'
+
+describe "Set#each" do
+  before :each do
+    @set = Set[1, 2, 3]
+  end
+
+  it "yields each Object in self" do
+    ret = []
+    @set.each { |x| ret << x }
+    ret.sort.should == [1, 2, 3]
+  end
+
+  it "returns self" do
+    @set.each { |x| x }.should equal(@set)
+  end
+
+  it "returns an Enumerator when not passed a block" do
+    enum = @set.each
+    enum.should be_an_instance_of(Enumerator)
+
+    ret = []
+    enum.each { |x| ret << x }
+    ret.sort.should == [1, 2, 3]
+  end
+end
diff --git a/spec/ruby/core/set/empty_spec.rb b/spec/ruby/core/set/empty_spec.rb
new file mode 100644
index 0000000000..4b55658e20
--- /dev/null
+++ b/spec/ruby/core/set/empty_spec.rb
@@ -0,0 +1,9 @@
+require_relative '../../spec_helper'
+
+describe "Set#empty?" do
+  it "returns true if self is empty" do
+    Set[].empty?.should be_true
+    Set[1].empty?.should be_false
+    Set[1,2,3].empty?.should be_false
+  end
+end
diff --git a/spec/ruby/core/set/enumerable/to_set_spec.rb b/spec/ruby/core/set/enumerable/to_set_spec.rb
new file mode 100644
index 0000000000..f139e1c025
--- /dev/null
+++ b/spec/ruby/core/set/enumerable/to_set_spec.rb
@@ -0,0 +1,12 @@
+require_relative '../../../spec_helper'
+
+describe "Enumerable#to_set" do
+  it "returns a new Set created from self" do
+    [1, 2, 3].to_set.should == Set[1, 2, 3]
+    {a: 1, b: 2}.to_set.should == Set[[:b, 2], [:a, 1]]
+  end
+
+  it "passes down passed blocks" do
+    [1, 2, 3].to_set { |x| x * x }.should == Set[1, 4, 9]
+  end
+end
diff --git a/spec/ruby/core/set/eql_spec.rb b/spec/ruby/core/set/eql_spec.rb
new file mode 100644
index 0000000000..4ad5c3aa5a
--- /dev/null
+++ b/spec/ruby/core/set/eql_spec.rb
@@ -0,0 +1,14 @@
+require_relative '../../spec_helper'
+
+describe "Set#eql?" do
+  it "returns true when the passed argument is a Set and contains the same elements" do
+    Set[].should eql(Set[])
+    Set[1, 2, 3].should eql(Set[1, 2, 3])
+    Set[1, 2, 3].should eql(Set[3, 2, 1])
+    Set["a", :b, ?c].should eql(Set[?c, :b, "a"])
+
+    Set[1, 2, 3].should_not eql(Set[1.0, 2, 3])
+    Set[1, 2, 3].should_not eql(Set[2, 3])
+    Set[1, 2, 3].should_not eql(Set[])
+  end
+end
diff --git a/spec/ruby/core/set/equal_value_spec.rb b/spec/ruby/core/set/equal_value_spec.rb
new file mode 100644
index 0000000000..e3514928c8
--- /dev/null
+++ b/spec/ruby/core/set/equal_value_spec.rb
@@ -0,0 +1,34 @@
+require_relative '../../spec_helper'
+require_relative 'fixtures/set_like'
+
+describe "Set#==" do
+  it "returns true when the passed Object is a Set and self and the Object contain the same elements" do
+    Set[].should == Set[]
+    Set[1, 2, 3].should == Set[1, 2, 3]
+    Set["1", "2", "3"].should == Set["1", "2", "3"]
+
+    Set[1, 2, 3].should_not == Set[1.0, 2, 3]
+    Set[1, 2, 3].should_not == [1, 2, 3]
+  end
+
+  it "does not depend on the order of the elements" do
+    Set[1, 2, 3].should == Set[3, 2, 1]
+    Set[:a, "b", ?c].should == Set[?c, "b", :a]
+  end
+
+  it "does not depend on the order of nested Sets" do
+    Set[Set[1], Set[2], Set[3]].should == Set[Set[3], Set[2], Set[1]]
+
+    set1 = Set[Set["a", "b"], Set["c", "d"], Set["e", "f"]]
+    set2 = Set[Set["c", "d"], Set["a", "b"], Set["e", "f"]]
+    set1.should == set2
+  end
+
+  ruby_version_is ""..."3.5" do
+    context "when comparing to a Set-like object" do
+      it "returns true when a Set and a Set-like object contain the same elements" do
+        Set[1, 2, 3].should == SetSpecs::SetLike.new([1, 2, 3])
+      end
+    end
+  end
+end
diff --git a/spec/ruby/core/set/exclusion_spec.rb b/spec/ruby/core/set/exclusion_spec.rb
new file mode 100644
index 0000000000..bbc29afa95
--- /dev/null
+++ b/spec/ruby/core/set/exclusion_spec.rb
@@ -0,0 +1,17 @@
+require_relative '../../spec_helper'
+
+describe "Set#^" do
+  before :each do
+    @set = Set[1, 2, 3, 4]
+  end
+
+  it "returns a new Set containing elements that are not in both self and the passed Enumerable" do
+    (@set ^ Set[3, 4, 5]).should == Set[1, 2, 5]
+    (@set ^ [3, 4, 5]).should == Set[1, 2, 5]
+  end
+
+  it "raises an ArgumentError when passed a non-Enumerable" do
+    -> { @set ^ 3 }.should raise_error(ArgumentError)
+    -> { @set ^ Object.new }.should raise_error(ArgumentError)
+  end
+end
diff --git a/spec/ruby/core/set/filter_spec.rb b/spec/ruby/core/set/filter_spec.rb
new file mode 100644
index 0000000000..779254ad68
--- /dev/null
+++ b/spec/ruby/core/set/filter_spec.rb
@@ -0,0 +1,6 @@
+require_relative '../../spec_helper'
+require_relative 'shared/select'
+
+describe "Set#filter!" do
+  it_behaves_like :set_select_bang, :filter!
+end
diff --git a/spec/ruby/core/set/fixtures/set_like.rb b/spec/ruby/core/set/fixtures/set_like.rb
new file mode 100644
index 0000000000..86dec2ed52
--- /dev/null
+++ b/spec/ruby/core/set/fixtures/set_like.rb
@@ -0,0 +1,30 @@
+
+module SetSpecs
+  # This class is used to test the interaction of "Set-like" objects with real Sets
+  #
+  # These "Set-like" objects reply to is_a?(Set) with true and thus real Set objects are able to transparently
+  # interoperate with them in a duck-typing manner.
+  class SetLike
+    include Enumerable
+
+    def is_a?(klass)
+      super || klass == ::Set
+    end
+
+    def initialize(entries)
+      @entries = entries
+    end
+
+    def each(&block)
+      @entries.each(&block)
+    end
+
+    def inspect
+      "#<#{self.class}: {#{map(&:inspect).join(", ")}}>"
+    end
+
+    def size
+      @entries.size
+    end
+  end
+end
diff --git a/spec/ruby/core/set/flatten_merge_spec.rb b/spec/ruby/core/set/flatten_merge_spec.rb
new file mode 100644
index 0000000000..d7c2b30657
--- /dev/null
+++ b/spec/ruby/core/set/flatten_merge_spec.rb
@@ -0,0 +1,24 @@
+require_relative '../../spec_helper'
+
+describe "Set#flatten_merge" do
+  ruby_version_is ""..."3.5" do
+    it "is protected" do
+      Set.should have_protected_instance_method("flatten_merge")
+    end
+
+    it "flattens the passed Set and merges it into self" do
+      set1 = Set[1, 2]
+      set2 = Set[3, 4, Set[5, 6]]
+
+      set1.send(:flatten_merge, set2).should == Set[1, 2, 3, 4, 5, 6]
+    end
+
+    it "raises an ArgumentError when trying to flatten a recursive Set" do
+      set1 = Set[1, 2, 3]
+      set2 = Set[5, 6, 7]
+      set2 << set2
+
+      -> { set1.send(:flatten_merge, set2) }.should raise_error(ArgumentError)
+    end
+  end
+end
diff --git a/spec/ruby/core/set/flatten_spec.rb b/spec/ruby/core/set/flatten_spec.rb
new file mode 100644
index 0000000000..870eccc2f1
--- /dev/null
+++ b/spec/ruby/core/set/flatten_spec.rb
@@ -0,0 +1,59 @@
+require_relative '../../spec_helper'
+require_relative 'fixtures/set_like'
+set_version = defined?(Set::VERSION) ? Set::VERSION : '1.0.0'
+
+describe "Set#flatten" do
+  it "returns a copy of self with each included Set flattened" do
+    set = Set[1, 2, Set[3, 4, Set[5, 6, Set[7, 8]]], 9, 10]
+    flattened_set = set.flatten
+
+    flattened_set.should_not equal(set)
+    flattened_set.should == Set[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+  end
+
+  it "raises an ArgumentError when self is recursive" do
+    (set = Set[]) << set
+    -> { set.flatten }.should raise_error(ArgumentError)
+  end
+
+  ruby_version_is ""..."3.5" do
+    context "when Set contains a Set-like object" do
+      it "returns a copy of self with each included Set-like object flattened" do
+        Set[SetSpecs::SetLike.new([1])].flatten.should == Set[1]
+      end
+    end
+  end
+end
+
+describe "Set#flatten!" do
+  it "flattens self" do
+    set = Set[1, 2, Set[3, 4, Set[5, 6, Set[7, 8]]], 9, 10]
+    set.flatten!
+    set.should == Set[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+  end
+
+  it "returns self when self was modified" do
+    set = Set[1, 2, Set[3, 4]]
+    set.flatten!.should equal(set)
+  end
+
+  it "returns nil when self was not modified" do
+    set = Set[1, 2, 3, 4]
+    set.flatten!.should be_nil
+  end
+
+  it "raises an ArgumentError when self is recursive" do
+    (set = Set[]) << set
+    -> { set.flatten! }.should raise_error(ArgumentError)
+  end
+
+  version_is(set_version, ""..."1.1.0") do #ruby_version_is ""..."3.3" do
+    ruby_version_is ""..."3.5" do
+      context "when Set contains a Set-like object" do
+        it "flattens self, including Set-like objects" do
+          Set[SetSpecs::SetLike.new([1])].flatten!.should == Set[1]
+        end
+      end
+    end
+  end
+end
diff --git a/spec/ruby/core/set/hash_spec.rb b/spec/ruby/core/set/hash_spec.rb
new file mode 100644
index 0000000000..4b4696e34c
--- /dev/null
+++ b/spec/ruby/core/set/hash_spec.rb
@@ -0,0 +1,19 @@
+require_relative '../../spec_helper'
+
+describe "Set#hash" do
+  it "is static" do
+    Set[].hash.should == Set[].hash
+    Set[1, 2, 3].hash.should == Set[1, 2, 3].hash
+    Set[:a, "b", ?c].hash.should == Set[?c, "b", :a].hash
+
+    Set[].hash.should_not == Set[1, 2, 3].hash
+    Set[1, 2, 3].hash.should_not == Set[:a, "b", ?c].hash
+  end
+
+  ruby_version_is ""..."3.5" do
+    # see https://github.com/jruby/jruby/issues/8393
+    it "is equal to nil.hash for an uninitialized Set" do
+      Set.allocate.hash.should == nil.hash
+    end
+  end
+end
diff --git a/spec/ruby/core/set/include_spec.rb b/spec/ruby/core/set/include_spec.rb
new file mode 100644
index 0000000000..dd33bbc3bd
--- /dev/null
+++ b/spec/ruby/core/set/include_spec.rb
@@ -0,0 +1,6 @@
+require_relative '../../spec_helper'
+require_relative 'shared/include'
+
+describe "Set#include?" do
+  it_behaves_like :set_include, :include?
+end
diff --git a/spec/ruby/core/set/initialize_clone_spec.rb b/spec/ruby/core/set/initialize_clone_spec.rb
new file mode 100644
index 0000000000..13abb7ee4e
--- /dev/null
+++ b/spec/ruby/core/set/initialize_clone_spec.rb
@@ -0,0 +1,15 @@
+require_relative '../../spec_helper'
+
+describe "Set#initialize_clone" do
+  # See https://bugs.ruby-lang.org/issues/14266
+  it "does not freeze the new Set when called from clone(freeze: false)" do
+    set1 = Set[1, 2]
+    set1.freeze
+    set2 = set1.clone(freeze: false)
+    set1.frozen?.should == true
+    set2.frozen?.should == false
+    set2.add 3
+    set1.should == Set[1, 2]
+    set2.should == Set[1, 2, 3]
+  end
+end
diff --git a/spec/ruby/core/set/initialize_spec.rb b/spec/ruby/core/set/initialize_spec.rb
new file mode 100644
index 0000000000..ad9e1bd8c9
--- /dev/null
+++ b/spec/ruby/core/set/initialize_spec.rb
@@ -0,0 +1,72 @@
+require_relative '../../spec_helper'
+
+describe "Set#initialize" do
+  it "is private" do
+    Set.should have_private_instance_method(:initialize)
+  end
+
+  it "adds all elements of the passed Enumerable to self" do
+    s = Set.new([1, 2, 3])
+    s.size.should eql(3)
+    s.should include(1)
+    s.should include(2)
+    s.should include(3)
+  end
+
+  it "uses #each_entry on the provided Enumerable" do
+    enumerable = MockObject.new('mock-enumerable')
+    enumerable.should_receive(:each_entry).and_yield(1).and_yield(2).and_yield(3)
+    s = Set.new(enumerable)
+    s.size.should eql(3)
+    s.should include(1)
+    s.should include(2)
+    s.should include(3)
+  end
+
+  it "uses #each on the provided Enumerable if it does not respond to #each_entry" do
+    enumerable = MockObject.new('mock-enumerable')
+    enumerable.should_receive(:each).and_yield(1).and_yield(2).and_yield(3)
+    s = Set.new(enumerable)
+    s.size.should eql(3)
+    s.should include(1)
+    s.should include(2)
+    s.should include(3)
+  end
+
+  it "raises if the provided Enumerable does not respond to #each_entry or #each" do
+    enumerable = MockObject.new('mock-enumerable')
+    -> { Set.new(enumerable) }.should raise_error(ArgumentError, "value must be enumerable")
+  end
+
+  it "should initialize with empty array and set" do
+    s = Set.new([])
+    s.size.should eql(0)
+
+    s = Set.new({})
+    s.size.should eql(0)
+  end
+
+  it "preprocesses all elements by a passed block before adding to self" do
+    s = Set.new([1, 2, 3]) { |x| x * x }
+    s.size.should eql(3)
+    s.should include(1)
+    s.should include(4)
+    s.should include(9)
+  end
+
+  it "should initialize with empty array and block" do
+    s = Set.new([]) { |x| x * x }
+    s.size.should eql(0)
+  end
+
+  it "should initialize with empty set and block" do
+    s = Set.new(Set.new) { |x| x * x }
+    s.size.should eql(0)
+  end
+
+  it "should initialize with just block" do
+    s = Set.new { |x| x * x }
+    s.size.should eql(0)
+    s.should eql(Set.new)
+  end
+end
diff --git a/spec/ruby/core/set/inspect_spec.rb b/spec/ruby/core/set/inspect_spec.rb
new file mode 100644
index 0000000000..0dcce83eb6
--- /dev/null
+++ b/spec/ruby/core/set/inspect_spec.rb
@@ -0,0 +1,6 @@
+require_relative '../../spec_helper'
+require_relative 'shared/inspect'
+
+describe "Set#inspect" do
+  it_behaves_like :set_inspect, :inspect
+end
diff --git a/spec/ruby/core/set/intersect_spec.rb b/spec/ruby/core/set/intersect_spec.rb
new file mode 100644
index 0000000000..0736dea5fd
--- /dev/null
+++ b/spec/ruby/core/set/intersect_spec.rb
@@ -0,0 +1,22 @@
+require_relative '../../spec_helper'
+require_relative 'fixtures/set_like'
+
+describe "Set#intersect?" do
+  it "returns true when two Sets have at least one element in common" do
+    Set[1, 2].intersect?(Set[2, 3]).should == true
+  end
+
+  it "returns false when two Sets have no element in common" do
+    Set[1, 2].intersect?(Set[3, 4]).should == false
+  end
+
+  context "when comparing to a Set-like object" do
+    it "returns true when a Set has at least one element in common with a Set-like object" do
+      Set[1, 2].intersect?(SetSpecs::SetLike.new([2, 3])).should be_true
+    end
+
+    it "returns false when a Set has no element in common with a Set-like object" do
+      Set[1, 2].intersect?(SetSpecs::SetLike.new([3, 4])).should be_false
+    end
+  end
+end
diff --git a/spec/ruby/core/set/intersection_spec.rb b/spec/ruby/core/set/intersection_spec.rb
new file mode 100644
index 0000000000..136b886775
--- /dev/null
+++ b/spec/ruby/core/set/intersection_spec.rb
@@ -0,0 +1,10 @@
+require_relative '../../spec_helper'
+require_relative 'shared/intersection'
+
+describe "Set#intersection" do
+  it_behaves_like :set_intersection, :intersection
+end
+
+describe "Set#&" do
+  it_behaves_like :set_intersection, :&
+end
diff --git a/spec/ruby/core/set/join_spec.rb b/spec/ruby/core/set/join_spec.rb
new file mode 100644
index 0000000000..cdb593597d
--- /dev/null
+++ b/spec/ruby/core/set/join_spec.rb
@@ -0,0 +1,30 @@
+require_relative '../../spec_helper'
+
+describe "Set#join" do
+  it "returns an empty string if the Set is empty" do
+    Set[].join.should == ''
+  end
+
+  it "returns a new string formed by joining elements after conversion" do
+    set = Set[:a, :b, :c]
+    set.join.should == "abc"
+  end
+
+  it "does not separate elements when the passed separator is nil" do
+    set = Set[:a, :b, :c]
+    set.join(nil).should == "abc"
+  end
+
+  it "returns a string formed by concatenating each element separated by the separator" do
+    set = Set[:a, :b, :c]
+    set.join(' | ').should == "a | b | c"
+  end
+
+  ruby_version_is ""..."3.5" do
+    it "calls #to_a to convert the Set in to an Array" do
+      set = Set[:a, :b, :c]
+      set.should_receive(:to_a).and_return([:a, :b, :c])
+      set.join.should == "abc"
+    end
+  end
+end
diff --git a/spec/ruby/core/set/keep_if_spec.rb b/spec/ruby/core/set/keep_if_spec.rb
new file mode 100644
index 0000000000..d6abdd6adc
--- /dev/null
+++ b/spec/ruby/core/set/keep_if_spec.rb
@@ -0,0 +1,37 @@
+require_relative '../../spec_helper'
+
+describe "Set#keep_if" do
+  before :each do
+    @set = Set["one", "two", "three"]
+  end
+
+  it "yields every element of self" do
+    ret = []
+    @set.keep_if { |x| ret << x }
+    ret.sort.should == ["one", "two", "three"].sort
+  end
+
+  it "keeps every element from self for which the passed block returns true" do
+    @set.keep_if { |x| x.size != 3 }
+    @set.size.should eql(1)
+
+    @set.should_not include("one")
+    @set.should_not include("two")
+    @set.should include("three")
+  end
+
+  it "returns self" do
+    @set.keep_if {}.should equal(@set)
+  end
+
+  it "returns an Enumerator when passed no block" do
+    enum = @set.keep_if
+    enum.should be_an_instance_of(Enumerator)
+
+    enum.each { |x| x.size != 3 }
+
+    @set.should_not include("one")
+    @set.should_not include("two")
+    @set.should include("three")
+  end
+end
diff --git a/spec/ruby/core/set/length_spec.rb b/spec/ruby/core/set/length_spec.rb
new file mode 100644
index 0000000000..6bb697b4ca
--- /dev/null
+++ b/spec/ruby/core/set/length_spec.rb
@@ -0,0 +1,6 @@
+require_relative '../../spec_helper'
+require_relative 'shared/length'
+
+describe "Set#length" do
+  it_behaves_like :set_length, :length
+end
diff --git a/spec/ruby/core/set/map_spec.rb b/spec/ruby/core/set/map_spec.rb
new file mode 100644
index 0000000000..996191b0a8
--- /dev/null
+++ b/spec/ruby/core/set/map_spec.rb
@@ -0,0 +1,6 @@
+require_relative '../../spec_helper'
+require_relative 'shared/collect'
+
+describe "Set#map!" do
+  it_behaves_like :set_collect_bang, :map!
+end
diff --git a/spec/ruby/core/set/member_spec.rb b/spec/ruby/core/set/member_spec.rb
new file mode 100644
index 0000000000..5c82e8f826
--- /dev/null
+++ b/spec/ruby/core/set/member_spec.rb
@@ -0,0 +1,6 @@
+require_relative '../../spec_helper'
+require_relative 'shared/include'
+
+describe "Set#member?" do
+  it_behaves_like :set_include, :member?
+end
diff --git a/spec/ruby/core/set/merge_spec.rb b/spec/ruby/core/set/merge_spec.rb
new file mode 100644
index 0000000000..2ee6a4b709
--- /dev/null
+++ b/spec/ruby/core/set/merge_spec.rb
@@ -0,0 +1,30 @@
+require_relative '../../spec_helper'
+
+describe "Set#merge" do
+  it "adds the elements of the passed Enumerable to self" do
+    Set[:a, :b].merge(Set[:b, :c, :d]).should == Set[:a, :b, :c, :d]
+    Set[1, 2].merge([3, 4]).should == Set[1, 2, 3, 4]
+  end
+
+  it "returns self" do
+    set = Set[1, 2]
+    set.merge([3, 4]).should equal(set)
+  end
+
+  it "raises an ArgumentError when passed a non-Enumerable" do
+    -> { Set[1, 2].merge(1) }.should raise_error(ArgumentError)
+    -> { Set[1, 2].merge(Object.new) }.should raise_error(ArgumentError)
+  end
+
+  ruby_version_is ""..."3.3" do
+    it "accepts only a single argument" do
+      -> { Set[].merge([], []) }.should raise_error(ArgumentError, "wrong number of arguments (given 2, expected 1)")
+    end
+  end
+
+  ruby_version_is "3.3" do
+    it "accepts multiple arguments" do
+      Set[:a, :b].merge(Set[:b, :c], [:d]).should == Set[:a, :b, :c, :d]
+    end
+  end
+end
diff --git a/spec/ruby/core/set/minus_spec.rb b/spec/ruby/core/set/minus_spec.rb
new file mode 100644
index 0000000000..72f98f985e
--- /dev/null
+++ b/spec/ruby/core/set/minus_spec.rb
@@ -0,0 +1,6 @@
+require_relative '../../spec_helper'
+require_relative 'shared/difference'
+
+describe "Set#-" do
+  it_behaves_like :set_difference, :-
+end
diff --git a/spec/ruby/core/set/plus_spec.rb b/spec/ruby/core/set/plus_spec.rb
new file mode 100644
index 0000000000..7e44ff0b7e
--- /dev/null
+++ b/spec/ruby/core/set/plus_spec.rb
@@ -0,0 +1,6 @@
+require_relative '../../spec_helper'
+require_relative 'shared/union'
+
+describe "Set#+" do
+  it_behaves_like :set_union, :+
+end
diff --git a/spec/ruby/core/set/pretty_print_cycle_spec.rb b/spec/ruby/core/set/pretty_print_cycle_spec.rb
new file mode 100644
index 0000000000..c3b383fe80
--- /dev/null
+++ b/spec/ruby/core/set/pretty_print_cycle_spec.rb
@@ -0,0 +1,9 @@
+require_relative '../../spec_helper'
+
+describe "Set#pretty_print_cycle" do
+  it "passes the 'pretty print' representation of a self-referencing Set to the pretty print writer" do
+    pp = mock("PrettyPrint")
+    pp.should_receive(:text).with("#<Set: {...}>")
+    Set[1, 2, 3].pretty_print_cycle(pp)
+  end
+end
diff --git a/spec/ruby/core/set/proper_subset_spec.rb b/spec/ruby/core/set/proper_subset_spec.rb
new file mode 100644
index 0000000000..a84c4197c2
--- /dev/null
+++ b/spec/ruby/core/set/proper_subset_spec.rb
@@ -0,0 +1,45 @@
+require_relative '../../spec_helper'
+require_relative 'fixtures/set_like'
+set_version = defined?(Set::VERSION) ? Set::VERSION : '1.0.0'
+
+describe "Set#proper_subset?" do
+  before :each do
+    @set = Set[1, 2, 3, 4]
+  end
+
+  it "returns true if passed a Set that self is a proper subset of" do
+    Set[].proper_subset?(@set).should be_true
+    Set[].proper_subset?(Set[1, 2, 3]).should be_true
+    Set[].proper_subset?(Set["a", :b, ?c]).should be_true
+
+    Set[1, 2, 3].proper_subset?(@set).should be_true
+    Set[1, 3].proper_subset?(@set).should be_true
+    Set[1, 2].proper_subset?(@set).should be_true
+    Set[1].proper_subset?(@set).should be_true
+
+    Set[5].proper_subset?(@set).should be_false
+    Set[1, 5].proper_subset?(@set).should be_false
+    Set[nil].proper_subset?(@set).should be_false
+    Set["test"].proper_subset?(@set).should be_false
+
+    @set.proper_subset?(@set).should be_false
+    Set[].proper_subset?(Set[]).should be_false
+  end
+
+  it "raises an ArgumentError when passed a non-Set" do
+    -> { Set[].proper_subset?([]) }.should raise_error(ArgumentError)
+    -> { Set[].proper_subset?(1) }.should raise_error(ArgumentError)
+    -> { Set[].proper_subset?("test") }.should raise_error(ArgumentError)
+    -> { Set[].proper_subset?(Object.new) }.should raise_error(ArgumentError)
+  end
+
+  version_is(set_version, ""..."1.1.0") do #ruby_version_is ""..."3.3" do
+    ruby_version_is ""..."3.5" do
+      context "when comparing to a Set-like object" do
+        it "returns true if passed a Set-like object that self is a proper subset of" do
+          Set[1, 2, 3].proper_subset?(SetSpecs::SetLike.new([1, 2, 3, 4])).should be_true
+        end
+      end
+    end
+  end
+end
diff --git a/spec/ruby/core/set/proper_superset_spec.rb b/spec/ruby/core/set/proper_superset_spec.rb
new file mode 100644
index 0000000000..653411f6b2
--- /dev/null
+++ b/spec/ruby/core/set/proper_superset_spec.rb
@@ -0,0 +1,42 @@
+require_relative '../../spec_helper'
+require_relative 'fixtures/set_like'
+
+describe "Set#proper_superset?" do
+  before :each do
+    @set = Set[1, 2, 3, 4]
+  end
+
+  it "returns true if passed a Set that self is a proper superset of" do
+    @set.proper_superset?(Set[]).should be_true
+    Set[1, 2, 3].proper_superset?(Set[]).should be_true
+    Set["a", :b, ?c].proper_superset?(Set[]).should be_true
+
+    @set.proper_superset?(Set[1, 2, 3]).should be_true
+    @set.proper_superset?(Set[1, 3]).should be_true
+    @set.proper_superset?(Set[1, 2]).should be_true
+    @set.proper_superset?(Set[1]).should be_true
+
+    @set.proper_superset?(Set[5]).should be_false
+    @set.proper_superset?(Set[1, 5]).should be_false
+    @set.proper_superset?(Set[nil]).should be_false
+    @set.proper_superset?(Set["test"]).should be_false
+
+    @set.proper_superset?(@set).should be_false
+    Set[].proper_superset?(Set[]).should be_false
+  end
+
+  it "raises an ArgumentError when passed a non-Set" do
+    -> { Set[].proper_superset?([]) }.should raise_error(ArgumentError)
+    -> { Set[].proper_superset?(1) }.should raise_error(ArgumentError)
+    -> { Set[].proper_superset?("test") }.should raise_error(ArgumentError)
+    -> { Set[].proper_superset?(Object.new) }.should raise_error(ArgumentError)
+  end
+
+  ruby_version_is ""..."3.5" do
+    context "when comparing to a Set-like object" do
+      it "returns true if passed a Set-like object that self is a proper superset of" do
+        Set[1, 2, 3, 4].proper_superset?(SetSpecs::SetLike.new([1, 2, 3])).should be_true
+      end
+    end
+  end
+end
diff --git a/spec/ruby/core/set/reject_spec.rb b/spec/ruby/core/set/reject_spec.rb
new file mode 100644
index 0000000000..91d0293415
--- /dev/null
+++ b/spec/ruby/core/set/reject_spec.rb
@@ -0,0 +1,41 @@
+require_relative '../../spec_helper'
+
+describe "Set#reject!" do
+  before :each do
+    @set = Set["one", "two", "three"]
+  end
+
+  it "yields every element of self" do
+    ret = []
+    @set.reject! { |x| ret << x }
+    ret.sort.should == ["one", "two", "three"].sort
+  end
+
+  it "deletes every element from self for which the passed block returns true" do
+    @set.reject! { |x| x.size == 3 }
+    @set.size.should eql(1)
+
+    @set.should_not include("one")
+    @set.should_not include("two")
+    @set.should include("three")
+  end
+
+  it "returns self when self was modified" do
+    @set.reject! { |x| true }.should equal(@set)
+  end
+
+  it "returns nil when self was not modified" do
+    @set.reject! { |x| false }.should be_nil
+  end
+
+  it "returns an Enumerator when passed no block" do
+    enum = @set.reject!
+    enum.should be_an_instance_of(Enumerator)
+
+    enum.each { |x| x.size == 3 }
+
+    @set.should_not include("one")
+    @set.should_not include("two")
+    @set.should include("three")
+  end
+end
diff --git a/spec/ruby/core/set/replace_spec.rb b/spec/ruby/core/set/replace_spec.rb
new file mode 100644
index 0000000000..60b33eb0c0
--- /dev/null
+++ b/spec/ruby/core/set/replace_spec.rb
@@ -0,0 +1,16 @@
+require_relative '../../spec_helper'
+
+describe "Set#replace" do
+  before :each do
+    @set = Set[:a, :b, :c]
+  end
+
+  it "replaces the contents with other and returns self" do
+    @set.replace(Set[1, 2, 3]).should == @set
+    @set.should == Set[1, 2, 3]
+  end
+
+  it "accepts any enumerable as other" do
+    @set.replace([1, 2, 3]).should == Set[1, 2, 3]
+  end
+end
diff --git a/spec/ruby/core/set/select_spec.rb b/spec/ruby/core/set/select_spec.rb
new file mode 100644
index 0000000000..b458ffacaa
--- /dev/null
+++ b/spec/ruby/core/set/select_spec.rb
@@ -0,0 +1,6 @@
+require_relative '../../spec_helper'
+require_relative 'shared/select'
+
+describe "Set#select!" do
+  it_behaves_like :set_select_bang, :select!
+end
diff --git a/spec/ruby/core/set/set_spec.rb b/spec/ruby/core/set/set_spec.rb
new file mode 100644
index 0000000000..f1436e6022
--- /dev/null
+++ b/spec/ruby/core/set/set_spec.rb
@@ -0,0 +1,10 @@
+require_relative '../../spec_helper'
+
+describe 'Set' do
+  it 'is available without explicit requiring' do
+    output = ruby_exe(<<~RUBY, options: '--disable-gems', args: '2>&1')
+      puts Set.new([1, 2, 3])
+    RUBY
+    output.chomp.should == "#<Set: {1, 2, 3}>"
+  end
+end
diff --git a/spec/ruby/core/set/shared/add.rb b/spec/ruby/core/set/shared/add.rb
new file mode 100644
index 0000000000..9e797f5df9
--- /dev/null
+++ b/spec/ruby/core/set/shared/add.rb
@@ -0,0 +1,14 @@
+describe :set_add, shared: true do
+  before :each do
+    @set = Set.new
+  end
+
+  it "adds the passed Object to self" do
+    @set.send(@method, "dog")
+    @set.should include("dog")
+  end
+
+  it "returns self" do
+    @set.send(@method, "dog").should equal(@set)
+  end
+end
diff --git a/spec/ruby/core/set/shared/collect.rb b/spec/ruby/core/set/shared/collect.rb
new file mode 100644
index 0000000000..bc58c231be
--- /dev/null
+++ b/spec/ruby/core/set/shared/collect.rb
@@ -0,0 +1,20 @@
+describe :set_collect_bang, shared: true do
+  before :each do
+    @set = Set[1, 2, 3, 4, 5]
+  end
+
+  it "yields each Object in self" do
+    res = []
+    @set.send(@method) { |x| res << x }
+    res.sort.should == [1, 2, 3, 4, 5].sort
+  end
+
+  it "returns self" do
+    @set.send(@method) { |x| x }.should equal(@set)
+  end
+
+  it "replaces self with the return values of the block" do
+    @set.send(@method) { |x| x * 2 }
+    @set.should == Set[2, 4, 6, 8, 10]
+  end
+end
diff --git a/spec/ruby/core/set/shared/difference.rb b/spec/ruby/core/set/shared/difference.rb
new file mode 100644
index 0000000000..f88987ed2a
--- /dev/null
+++ b/spec/ruby/core/set/shared/difference.rb
@@ -0,0 +1,15 @@
+describe :set_difference, shared: true do
+  before :each do
+    @set = Set[:a, :b, :c]
+  end
+
+  it "returns a new Set containing self's elements excluding the elements in the passed Enumerable" do
+    @set.send(@method, Set[:a, :b]).should == Set[:c]
+    @set.send(@method, [:b, :c]).should == Set[:a]
+  end
+
+  it "raises an ArgumentError when passed a non-Enumerable" do
+    -> { @set.send(@method, 1) }.should raise_error(ArgumentError)
+    -> { @set.send(@method, Object.new) }.should raise_error(ArgumentError)
+  end
+end
diff --git a/spec/ruby/core/set/shared/include.rb b/spec/ruby/core/set/shared/include.rb
new file mode 100644
index 0000000000..b4d95cde24
--- /dev/null
+++ b/spec/ruby/core/set/shared/include.rb
@@ -0,0 +1,29 @@
+describe :set_include, shared: true do
+  it "returns true when self contains the passed Object" do
+    set = Set[:a, :b, :c]
+    set.send(@method, :a).should be_true
+    set.send(@method, :e).should be_false
+  end
+
+  describe "member equality" do
+    it "is checked using both #hash and #eql?" do
+      obj = Object.new
+      obj_another = Object.new
+
+      def obj.hash; 42 end
+      def obj_another.hash; 42 end
+      def obj_another.eql?(o) hash == o.hash end
+
+      set = Set["a", "b", "c", obj]
+      set.send(@method, obj_another).should == true
+    end
+
+    it "is not checked using #==" do
+      obj = Object.new
+      set = Set["a", "b", "c"]
+
+      obj.should_not_receive(:==)
+      set.send(@method, obj)
+    end
+  end
+end
diff --git a/spec/ruby/core/set/shared/inspect.rb b/spec/ruby/core/set/shared/inspect.rb
new file mode 100644
index 0000000000..adb6ddb4c9
--- /dev/null
+++ b/spec/ruby/core/set/shared/inspect.rb
@@ -0,0 +1,25 @@
+describe :set_inspect, shared: true do
+  it "returns a String representation of self" do
+    Set[].send(@method).should be_kind_of(String)
+    Set[nil, false, true].send(@method).should be_kind_of(String)
+    Set[1, 2, 3].send(@method).should be_kind_of(String)
+    Set["1", "2", "3"].send(@method).should be_kind_of(String)
+    Set[:a, "b", Set[?c]].send(@method).should be_kind_of(String)
+  end
+
+  it "does include the elements of the set" do
+    Set["1"].send(@method).should == '#<Set: {"1"}>'
+  end
+
+  it "puts spaces between the elements" do
+    Set["1", "2"].send(@method).should include('", "')
+  end
+
+  it "correctly handles cyclic-references" do
+    set1 = Set[]
+    set2 = Set[set1]
+    set1 << set2
+    set1.send(@method).should be_kind_of(String)
+    set1.send(@method).should include("#<Set: {...}>")
+  end
+end
diff --git a/spec/ruby/core/set/shared/intersection.rb b/spec/ruby/core/set/shared/intersection.rb
new file mode 100644
index 0000000000..5ae4199c94
--- /dev/null
+++ b/spec/ruby/core/set/shared/intersection.rb
@@ -0,0 +1,15 @@
+describe :set_intersection, shared: true do
+  before :each do
+    @set = Set[:a, :b, :c]
+  end
+
+  it "returns a new Set containing only elements shared by self and the passed Enumerable" do
+    @set.send(@method, Set[:b, :c, :d, :e]).should == Set[:b, :c]
+    @set.send(@method, [:b, :c, :d]).should == Set[:b, :c]
+  end
+
+  it "raises an ArgumentError when passed a non-Enumerable" do
+    -> { @set.send(@method, 1) }.should raise_error(ArgumentError)
+    -> { @set.send(@method, Object.new) }.should raise_error(ArgumentError)
+  end
+end
diff --git a/spec/ruby/core/set/shared/length.rb b/spec/ruby/core/set/shared/length.rb
new file mode 100644
index 0000000000..a8fcee9f39
--- /dev/null
+++ b/spec/ruby/core/set/shared/length.rb
@@ -0,0 +1,6 @@
+describe :set_length, shared: true do
+  it "returns the number of elements in the set" do
+    set = Set[:a, :b, :c]
+    set.send(@method).should == 3
+  end
+end
diff --git a/spec/ruby/core/set/shared/select.rb b/spec/ruby/core/set/shared/select.rb
new file mode 100644
index 0000000000..467b236ed3
--- /dev/null
+++ b/spec/ruby/core/set/shared/select.rb
@@ -0,0 +1,41 @@
+require_relative '../../../spec_helper'
+
+describe :set_select_bang, shared: true do
+  before :each do
+    @set = Set["one", "two", "three"]
+  end
+
+  it "yields every element of self" do
+    ret = []
+    @set.send(@method) { |x| ret << x }
+    ret.sort.should == ["one", "two", "three"].sort
+  end
+
+  it "keeps every element from self for which the passed block returns true" do
+    @set.send(@method) { |x| x.size != 3 }
+    @set.size.should eql(1)
+
+    @set.should_not include("one")
+    @set.should_not include("two")
+    @set.should include("three")
+  end
+
+  it "returns self when self was modified" do
+    @set.send(@method) { false }.should equal(@set)
+  end
+
+  it "returns nil when self was not modified" do
+    @set.send(@method) { true }.should be_nil
+  end
+
+  it "returns an Enumerator when passed no block" do
+    enum = @set.send(@method)
+    enum.should be_an_instance_of(Enumerator)
+
+    enum.each { |x| x.size != 3 }
+
+    @set.should_not include("one")
+    @set.should_not include("two")
+    @set.should include("three")
+  end
+end
diff --git a/spec/ruby/core/set/shared/union.rb b/spec/ruby/core/set/shared/union.rb
new file mode 100644
index 0000000000..314f0e852d
--- /dev/null
+++ b/spec/ruby/core/set/shared/union.rb
@@ -0,0 +1,15 @@
+describe :set_union, shared: true do
+  before :each do
+    @set = Set[:a, :b, :c]
+  end
+
+  it "returns a new Set containing all elements of self and the passed Enumerable" do
+    @set.send(@method, Set[:b, :d, :e]).should == Set[:a, :b, :c, :d, :e]
+    @set.send(@method, [:b, :e]).should == Set[:a, :b, :c, :e]
+  end
+
+  it "raises an ArgumentError when passed a non-Enumerable" do
+    -> { @set.send(@method, 1) }.should raise_error(ArgumentError)
+    -> { @set.send(@method, Object.new) }.should raise_error(ArgumentError)
+  end
+end
diff --git a/spec/ruby/core/set/size_spec.rb b/spec/ruby/core/set/size_spec.rb
new file mode 100644
index 0000000000..4ae22c5f0a
--- /dev/null
+++ b/spec/ruby/core/set/size_spec.rb
@@ -0,0 +1,6 @@
+require_relative '../../spec_helper'
+require_relative 'shared/length'
+
+describe "Set#size" do
+  it_behaves_like :set_length, :size
+end
diff --git a/spec/ruby/core/set/sortedset/sortedset_spec.rb b/spec/ruby/core/set/sortedset/sortedset_spec.rb
new file mode 100644
index 0000000000..375aada816
--- /dev/null
+++ b/spec/ruby/core/set/sortedset/sortedset_spec.rb
@@ -0,0 +1,11 @@
+require_relative '../../../spec_helper'
+
+describe "SortedSet" do
+  it "raises error including message that it has been extracted from the set stdlib" do
+    -> {
+      SortedSet
+    }.should raise_error(RuntimeError) { |e|
+      e.message.should.include?("The `SortedSet` class has been extracted from the `set` library")
+    }
+  end
+end
diff --git a/spec/ruby/core/set/subset_spec.rb b/spec/ruby/core/set/subset_spec.rb
new file mode 100644
index 0000000000..cde61d7cd7
--- /dev/null
+++ b/spec/ruby/core/set/subset_spec.rb
@@ -0,0 +1,45 @@
+require_relative '../../spec_helper'
+require_relative 'fixtures/set_like'
+set_version = defined?(Set::VERSION) ? Set::VERSION : '1.0.0'
+
+describe "Set#subset?" do
+  before :each do
+    @set = Set[1, 2, 3, 4]
+  end
+
+  it "returns true if passed a Set that is equal to self or self is a subset of" do
+    @set.subset?(@set).should be_true
+    Set[].subset?(Set[]).should be_true
+
+    Set[].subset?(@set).should be_true
+    Set[].subset?(Set[1, 2, 3]).should be_true
+    Set[].subset?(Set["a", :b, ?c]).should be_true
+
+    Set[1, 2, 3].subset?(@set).should be_true
+    Set[1, 3].subset?(@set).should be_true
+    Set[1, 2].subset?(@set).should be_true
+    Set[1].subset?(@set).should be_true
+
+    Set[5].subset?(@set).should be_false
+    Set[1, 5].subset?(@set).should be_false
+    Set[nil].subset?(@set).should be_false
+    Set["test"].subset?(@set).should be_false
+  end
+
+  it "raises an ArgumentError when passed a non-Set" do
+    -> { Set[].subset?([]) }.should raise_error(ArgumentError)
+    -> { Set[].subset?(1) }.should raise_error(ArgumentError)
+    -> { Set[].subset?("test") }.should raise_error(ArgumentError)
+    -> { Set[].subset?(Object.new) }.should raise_error(ArgumentError)
+  end
+
+  version_is(set_version, ""..."1.1.0") do #ruby_version_is ""..."3.3" do
+    ruby_version_is ""..."3.5" do
+      context "when comparing to a Set-like object" do
+        it "returns true if passed a Set-like object that self is a subset of" do
+          Set[1, 2, 3].subset?(SetSpecs::SetLike.new([1, 2, 3, 4])).should be_true
+        end
+      end
+    end
+  end
+end
diff --git a/spec/ruby/core/set/subtract_spec.rb b/spec/ruby/core/set/subtract_spec.rb
new file mode 100644
index 0000000000..ae4bc73d41
--- /dev/null
+++ b/spec/ruby/core/set/subtract_spec.rb
@@ -0,0 +1,16 @@
+require_relative '../../spec_helper'
+
+describe "Set#subtract" do
+  before :each do
+    @set = Set[:a, :b, :c]
+  end
+
+  it "deletes any elements contained in other and returns self" do
+    @set.subtract(Set[:b, :c]).should == @set
+    @set.should == Set[:a]
+  end
+
+  it "accepts any enumerable as other" do
+    @set.subtract([:c]).should == Set[:a, :b]
+  end
+end
diff --git a/spec/ruby/core/set/superset_spec.rb b/spec/ruby/core/set/superset_spec.rb
new file mode 100644
index 0000000000..9d7bab964a
--- /dev/null
+++ b/spec/ruby/core/set/superset_spec.rb
@@ -0,0 +1,42 @@
+require_relative '../../spec_helper'
+require_relative 'fixtures/set_like'
+
+describe "Set#superset?" do
+  before :each do
+    @set = Set[1, 2, 3, 4]
+  end
+
+  it "returns true if passed a Set that equals self or self is a proper superset of" do
+    @set.superset?(@set).should be_true
+    Set[].superset?(Set[]).should be_true
+
+    @set.superset?(Set[]).should be_true
+    Set[1, 2, 3].superset?(Set[]).should be_true
+    Set["a", :b, ?c].superset?(Set[]).should be_true
+
+    @set.superset?(Set[1, 2, 3]).should be_true
+    @set.superset?(Set[1, 3]).should be_true
+    @set.superset?(Set[1, 2]).should be_true
+    @set.superset?(Set[1]).should be_true
+
+    @set.superset?(Set[5]).should be_false
+    @set.superset?(Set[1, 5]).should be_false
+    @set.superset?(Set[nil]).should be_false
+    @set.superset?(Set["test"]).should be_false
+  end
+
+  it "raises an ArgumentError when passed a non-Set" do
+    -> { Set[].superset?([]) }.should raise_error(ArgumentError)
+    -> { Set[].superset?(1) }.should raise_error(ArgumentError)
+    -> { Set[].superset?("test") }.should raise_error(ArgumentError)
+    -> { Set[].superset?(Object.new) }.should raise_error(ArgumentError)
+  end
+
+  ruby_version_is ""..."3.5" do
+    context "when comparing to a Set-like object" do
+      it "returns true if passed a Set-like object that self is a superset of" do
+        Set[1, 2, 3, 4].superset?(SetSpecs::SetLike.new([1, 2, 3])).should be_true
+      end
+    end
+  end
+end
diff --git a/spec/ruby/core/set/to_a_spec.rb b/spec/ruby/core/set/to_a_spec.rb
new file mode 100644
index 0000000000..1e9800167a
--- /dev/null
+++ b/spec/ruby/core/set/to_a_spec.rb
@@ -0,0 +1,7 @@
+require_relative '../../spec_helper'
+
+describe "Set#to_a" do
+  it "returns an array containing elements of self" do
+    Set[1, 2, 3].to_a.sort.should == [1, 2, 3]
+  end
+end
diff --git a/spec/ruby/core/set/to_s_spec.rb b/spec/ruby/core/set/to_s_spec.rb
new file mode 100644
index 0000000000..55b8bfd9b2
--- /dev/null
+++ b/spec/ruby/core/set/to_s_spec.rb
@@ -0,0 +1,11 @@
+require_relative "../../spec_helper"
+require_relative 'shared/inspect'
+
+describe "Set#to_s" do
+  it_behaves_like :set_inspect, :to_s
+
+  it "is an alias of inspect" do
+    set = Set.new
+    set.method(:to_s).should == set.method(:inspect)
+  end
+end
diff --git a/spec/ruby/core/set/union_spec.rb b/spec/ruby/core/set/union_spec.rb
new file mode 100644
index 0000000000..3e77022d4b
--- /dev/null
+++ b/spec/ruby/core/set/union_spec.rb
@@ -0,0 +1,10 @@
+require_relative '../../spec_helper'
+require_relative 'shared/union'
+
+describe "Set#union" do
+  it_behaves_like :set_union, :union
+end
+
+describe "Set#|" do
+  it_behaves_like :set_union, :|
+end
diff --git a/spec/ruby/core/sizedqueue/append_spec.rb b/spec/ruby/core/sizedqueue/append_spec.rb
index 6fffe2f272..c52baa3802 100644
--- a/spec/ruby/core/sizedqueue/append_spec.rb
+++ b/spec/ruby/core/sizedqueue/append_spec.rb
@@ -12,7 +12,5 @@ describe "SizedQueue#<<" do
 end
 
 describe "SizedQueue operations with timeout" do
-  ruby_version_is "3.2" do
-    it_behaves_like :rb_num2dbl_fails, nil, -> v { q = SizedQueue.new(1); q.send(:<<, 1, timeout: v) }
-  end
+  it_behaves_like :rb_num2dbl_fails, nil, -> v { q = SizedQueue.new(1); q.send(:<<, 1, timeout: v) }
 end
diff --git a/spec/ruby/core/sizedqueue/deq_spec.rb b/spec/ruby/core/sizedqueue/deq_spec.rb
index 985d654bb3..2aeb52f8a6 100644
--- a/spec/ruby/core/sizedqueue/deq_spec.rb
+++ b/spec/ruby/core/sizedqueue/deq_spec.rb
@@ -7,7 +7,5 @@ describe "SizedQueue#deq" do
 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
+  it_behaves_like :rb_num2dbl_fails, nil, -> v { q = SizedQueue.new(10); q.push(1); q.deq(timeout: v) }
 end
diff --git a/spec/ruby/core/sizedqueue/enq_spec.rb b/spec/ruby/core/sizedqueue/enq_spec.rb
index 619373e46b..b955909475 100644
--- a/spec/ruby/core/sizedqueue/enq_spec.rb
+++ b/spec/ruby/core/sizedqueue/enq_spec.rb
@@ -12,7 +12,5 @@ describe "SizedQueue#enq" do
 end
 
 describe "SizedQueue operations with timeout" do
-  ruby_version_is "3.2" do
-    it_behaves_like :rb_num2dbl_fails, nil, -> v { q = SizedQueue.new(1); q.enq(1, timeout: v) }
-  end
+  it_behaves_like :rb_num2dbl_fails, nil, -> v { q = SizedQueue.new(1); q.enq(1, timeout: v) }
 end
diff --git a/spec/ruby/core/sizedqueue/pop_spec.rb b/spec/ruby/core/sizedqueue/pop_spec.rb
index 5e7cfea8fb..6338ddbaa0 100644
--- a/spec/ruby/core/sizedqueue/pop_spec.rb
+++ b/spec/ruby/core/sizedqueue/pop_spec.rb
@@ -7,7 +7,5 @@ describe "SizedQueue#pop" do
 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
+  it_behaves_like :rb_num2dbl_fails, nil, -> v { q = SizedQueue.new(10); q.push(1); q.pop(timeout: v) }
 end
diff --git a/spec/ruby/core/sizedqueue/push_spec.rb b/spec/ruby/core/sizedqueue/push_spec.rb
index ce61e89b53..9eaa6beca0 100644
--- a/spec/ruby/core/sizedqueue/push_spec.rb
+++ b/spec/ruby/core/sizedqueue/push_spec.rb
@@ -12,7 +12,5 @@ describe "SizedQueue#push" do
 end
 
 describe "SizedQueue operations with timeout" do
-  ruby_version_is "3.2" do
-    it_behaves_like :rb_num2dbl_fails, nil, -> v { q = SizedQueue.new(1); q.push(1, timeout: v) }
-  end
+  it_behaves_like :rb_num2dbl_fails, nil, -> v { q = SizedQueue.new(1); q.push(1, timeout: v) }
 end
diff --git a/spec/ruby/core/sizedqueue/shift_spec.rb b/spec/ruby/core/sizedqueue/shift_spec.rb
index 3220801f3a..52974c1d99 100644
--- a/spec/ruby/core/sizedqueue/shift_spec.rb
+++ b/spec/ruby/core/sizedqueue/shift_spec.rb
@@ -7,7 +7,5 @@ describe "SizedQueue#shift" do
 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
+  it_behaves_like :rb_num2dbl_fails, nil, -> v { q = SizedQueue.new(10); q.push(1); q.shift(timeout: v) }
 end
diff --git a/spec/ruby/core/string/byteindex_spec.rb b/spec/ruby/core/string/byteindex_spec.rb
index 47c7be1029..d420f3f683 100644
--- a/spec/ruby/core/string/byteindex_spec.rb
+++ b/spec/ruby/core/string/byteindex_spec.rb
@@ -4,301 +4,295 @@ 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 "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 "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 "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_behaves_like :byte_index_common, :byteindex
+  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
 
 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)
+  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
+      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
+      (-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 "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 "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 "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 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"
+  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
+    ["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
+  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
+    "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 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 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 "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 "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'.dup.force_encoding(Encoding::US_ASCII).byteindex('é').should == nil
-    end
+  it "handles a substring in a superset encoding" do
+    'abc'.dup.force_encoding(Encoding::US_ASCII).byteindex('é').should == nil
+  end
 
-    it "handles a substring in a subset encoding" do
-      'été'.byteindex('t'.dup.force_encoding(Encoding::US_ASCII)).should == 2
-    end
+  it "handles a substring in a subset encoding" do
+    'été'.byteindex('t'.dup.force_encoding(Encoding::US_ASCII)).should == 2
   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
+  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
+  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(/.{0}/).should == 0
+    "blablabla".byteindex(/.{6}/).should == 0
+    "blablabla".byteindex(/.{9}/).should == 0
 
-      "blablabla".byteindex(/.*/).should == 0
-      "blablabla".byteindex(/.+/).should == 0
+    "blablabla".byteindex(/.*/).should == 0
+    "blablabla".byteindex(/.+/).should == 0
 
-      "blablabla".byteindex(/lab|b/).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
+    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(/^/).should == 0
+    "\nblablabla".byteindex(/^/).should == 0
+    "b\nablabla".byteindex(/$/).should == 1
+    "bl\nablabla".byteindex(/$/).should == 2
 
-      "blablabla".byteindex(/.l./).should == 0
-    end
+    "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
+  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"
+  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
+    ["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
+  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
+    "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 "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
+  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|
+    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("#")
+      start = spec[0].byteindex("#")
+      str = spec[0].delete("#")
 
-        str.byteindex(re, start).should == spec[1]
-      end
+      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 "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 of a multibyte character" do
+    "ありがとう".byteindex(/が/).should == 6
+  end
 
-    it "returns the character byteindex after offset" do
-      "われわれ".byteindex(/わ/, 3).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
+  it "treats the offset as a byteindex" do
+    "われわわれ".byteindex(/わ/, 6).should == 6
   end
 end
diff --git a/spec/ruby/core/string/byterindex_spec.rb b/spec/ruby/core/string/byterindex_spec.rb
index 34ecbfbd21..983222e35d 100644
--- a/spec/ruby/core/string/byterindex_spec.rb
+++ b/spec/ruby/core/string/byterindex_spec.rb
@@ -4,356 +4,350 @@ 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 "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 "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 "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_behaves_like :byte_index_common, :byterindex
+  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
 
 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)
+  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
+      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
+      (-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)
+  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
+      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
+      (-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 "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 "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 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"
+  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
+    ["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
+  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("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("llo", 0).should == nil
+    "hello".byterindex("llo", 1).should == nil
 
-      "hello".byterindex("el", 0).should == nil
-      "hello".byterindex("ello", 0).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("", -6).should == nil
+    "hello".byterindex("", -7).should == nil
 
-      "hello".byterindex("h", -6).should == nil
-    end
+    "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
+  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
+    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 "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'.dup.force_encoding(Encoding::US_ASCII).byterindex('é').should == nil
-    end
+  it "handles a substring in a superset encoding" do
+    'abc'.dup.force_encoding(Encoding::US_ASCII).byterindex('é').should == nil
+  end
 
-    it "handles a substring in a subset encoding" do
-      'été'.byterindex('t'.dup.force_encoding(Encoding::US_ASCII)).should == 2
-    end
+  it "handles a substring in a subset encoding" do
+    'été'.byterindex('t'.dup.force_encoding(Encoding::US_ASCII)).should == 2
   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
+  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
+  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(/.*/).should == 9
-      "blablabla".byterindex(/.+/).should == 8
+    "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(/bla|a/).should == 8
+    "blablabla".byterindex(/.*/).should == 9
+    "blablabla".byterindex(/.+/).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(/bla|a/).should == 8
 
-      "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
+    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
 
-    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
+    "blablabla".byterindex(/^/).should == 0
+    not_supported_on :opal do
+      "\nblablabla".byterindex(/^/).should == 1
+      "b\nlablabla".byterindex(/^/).should == 2
     end
+    "blablabla".byterindex(/$/).should == 9
 
-    it "starts the search at offset + self.length if offset is negative" do
-      str = "blablabla"
+    "blablabla".byterindex(/.l./).should == 6
+  end
 
-      ["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
+  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 "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
+  it "starts the search at offset + self.length if offset is negative" do
+    str = "blablabla"
 
-      not_supported_on :opal do
-        "blablabla".byterindex(/\Z/, 5).should == nil
-        "blablabla".byterindex(/\z/, 5).should == nil
-        "blablabla\n".byterindex(/\z/, 9).should == nil
+    ["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
-      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
+      "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
+  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
+    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 "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 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
+  it "returns the character index before the finish" do
+    "ありがりがとう".byterindex("が", 9).should == 6
+    "ありがりがとう".byterindex(/が/, 9).should == 6
   end
 end
diff --git a/spec/ruby/core/string/bytesplice_spec.rb b/spec/ruby/core/string/bytesplice_spec.rb
index 5cb3b2c158..2c770e340a 100644
--- a/spec/ruby/core/string/bytesplice_spec.rb
+++ b/spec/ruby/core/string/bytesplice_spec.rb
@@ -3,60 +3,58 @@
 require_relative '../../spec_helper'
 
 describe "String#bytesplice" do
-  ruby_version_is "3.2" do
-    it "raises IndexError when index is less than -bytesize" do
-      -> { "hello".bytesplice(-6, 0, "xxx") }.should raise_error(IndexError, "index -6 out of string")
-    end
+  it "raises IndexError when index is less than -bytesize" do
+    -> { "hello".bytesplice(-6, 0, "xxx") }.should raise_error(IndexError, "index -6 out of string")
+  end
 
-    it "raises IndexError when index is greater than bytesize" do
-      -> { "hello".bytesplice(6, 0, "xxx") }.should raise_error(IndexError, "index 6 out of string")
-    end
+  it "raises IndexError when index is greater than bytesize" do
+    -> { "hello".bytesplice(6, 0, "xxx") }.should raise_error(IndexError, "index 6 out of string")
+  end
 
-    it "raises IndexError for negative length" do
-      -> { "abc".bytesplice(0, -2, "") }.should raise_error(IndexError, "negative length -2")
-    end
+  it "raises IndexError for negative length" do
+    -> { "abc".bytesplice(0, -2, "") }.should raise_error(IndexError, "negative length -2")
+  end
 
-    it "replaces with integer indices" do
-      "hello".bytesplice(-5, 0, "xxx").should == "xxxhello"
-      "hello".bytesplice(0, 0, "xxx").should == "xxxhello"
-      "hello".bytesplice(0, 1, "xxx").should == "xxxello"
-      "hello".bytesplice(0, 5, "xxx").should == "xxx"
-      "hello".bytesplice(0, 6, "xxx").should == "xxx"
-    end
+  it "replaces with integer indices" do
+    "hello".bytesplice(-5, 0, "xxx").should == "xxxhello"
+    "hello".bytesplice(0, 0, "xxx").should == "xxxhello"
+    "hello".bytesplice(0, 1, "xxx").should == "xxxello"
+    "hello".bytesplice(0, 5, "xxx").should == "xxx"
+    "hello".bytesplice(0, 6, "xxx").should == "xxx"
+  end
 
-    it "raises RangeError when range left boundary is less than -bytesize" do
-      -> { "hello".bytesplice(-6...-6, "xxx") }.should raise_error(RangeError, "-6...-6 out of range")
-    end
+  it "raises RangeError when range left boundary is less than -bytesize" do
+    -> { "hello".bytesplice(-6...-6, "xxx") }.should raise_error(RangeError, "-6...-6 out of range")
+  end
 
-    it "replaces with ranges" do
-      "hello".bytesplice(-5...-5, "xxx").should == "xxxhello"
-      "hello".bytesplice(0...0, "xxx").should == "xxxhello"
-      "hello".bytesplice(0..0, "xxx").should == "xxxello"
-      "hello".bytesplice(0...1, "xxx").should == "xxxello"
-      "hello".bytesplice(0..1, "xxx").should == "xxxllo"
-      "hello".bytesplice(0..-1, "xxx").should == "xxx"
-      "hello".bytesplice(0...5, "xxx").should == "xxx"
-      "hello".bytesplice(0...6, "xxx").should == "xxx"
-    end
+  it "replaces with ranges" do
+    "hello".bytesplice(-5...-5, "xxx").should == "xxxhello"
+    "hello".bytesplice(0...0, "xxx").should == "xxxhello"
+    "hello".bytesplice(0..0, "xxx").should == "xxxello"
+    "hello".bytesplice(0...1, "xxx").should == "xxxello"
+    "hello".bytesplice(0..1, "xxx").should == "xxxllo"
+    "hello".bytesplice(0..-1, "xxx").should == "xxx"
+    "hello".bytesplice(0...5, "xxx").should == "xxx"
+    "hello".bytesplice(0...6, "xxx").should == "xxx"
+  end
 
-    it "raises TypeError when integer index is provided without length argument" do
-      -> { "hello".bytesplice(0, "xxx") }.should raise_error(TypeError, "wrong argument type Integer (expected Range)")
-    end
+  it "raises TypeError when integer index is provided without length argument" do
+    -> { "hello".bytesplice(0, "xxx") }.should raise_error(TypeError, "wrong argument type Integer (expected Range)")
+  end
 
-    it "replaces on an empty string" do
-      "".bytesplice(0, 0, "").should == ""
-      "".bytesplice(0, 0, "xxx").should == "xxx"
-    end
+  it "replaces on an empty string" do
+    "".bytesplice(0, 0, "").should == ""
+    "".bytesplice(0, 0, "xxx").should == "xxx"
+  end
 
-    it "mutates self" do
-      s = "hello"
-      s.bytesplice(2, 1, "xxx").should.equal?(s)
-    end
+  it "mutates self" do
+    s = "hello"
+    s.bytesplice(2, 1, "xxx").should.equal?(s)
+  end
 
-    it "raises when string is frozen" do
-      s = "hello".freeze
-      -> { s.bytesplice(2, 1, "xxx") }.should raise_error(FrozenError, "can't modify frozen String: \"hello\"")
-    end
+  it "raises when string is frozen" do
+    s = "hello".freeze
+    -> { s.bytesplice(2, 1, "xxx") }.should raise_error(FrozenError, "can't modify frozen String: \"hello\"")
   end
 
   ruby_version_is "3.3" do
@@ -134,75 +132,73 @@ describe "String#bytesplice" do
 end
 
 describe "String#bytesplice with multibyte characters" do
-  ruby_version_is "3.2" do
-    it "raises IndexError when index is out of byte size boundary" do
-      -> { "こんにちは".bytesplice(-16, 0, "xxx") }.should raise_error(IndexError, "index -16 out of string")
-    end
+  it "raises IndexError when index is out of byte size boundary" do
+    -> { "こんにちは".bytesplice(-16, 0, "xxx") }.should raise_error(IndexError, "index -16 out of string")
+  end
 
-    it "raises IndexError when index is not on a codepoint boundary" do
-      -> { "こんにちは".bytesplice(1, 0, "xxx") }.should raise_error(IndexError, "offset 1 does not land on character boundary")
-    end
+  it "raises IndexError when index is not on a codepoint boundary" do
+    -> { "こんにちは".bytesplice(1, 0, "xxx") }.should raise_error(IndexError, "offset 1 does not land on character boundary")
+  end
 
-    it "raises IndexError when length is not matching the codepoint boundary" do
-      -> { "こんにちは".bytesplice(0, 1, "xxx") }.should raise_error(IndexError, "offset 1 does not land on character boundary")
-      -> { "こんにちは".bytesplice(0, 2, "xxx") }.should raise_error(IndexError, "offset 2 does not land on character boundary")
-    end
+  it "raises IndexError when length is not matching the codepoint boundary" do
+    -> { "こんにちは".bytesplice(0, 1, "xxx") }.should raise_error(IndexError, "offset 1 does not land on character boundary")
+    -> { "こんにちは".bytesplice(0, 2, "xxx") }.should raise_error(IndexError, "offset 2 does not land on character boundary")
+  end
 
-    it "replaces with integer indices" do
-      "こんにちは".bytesplice(-15, 0, "xxx").should == "xxxこんにちは"
-      "こんにちは".bytesplice(0, 0, "xxx").should == "xxxこんにちは"
-      "こんにちは".bytesplice(0, 3, "xxx").should == "xxxんにちは"
-      "こんにちは".bytesplice(3, 3, "はは").should == "こははにちは"
-      "こんにちは".bytesplice(15, 0, "xxx").should == "こんにちはxxx"
-    end
+  it "replaces with integer indices" do
+    "こんにちは".bytesplice(-15, 0, "xxx").should == "xxxこんにちは"
+    "こんにちは".bytesplice(0, 0, "xxx").should == "xxxこんにちは"
+    "こんにちは".bytesplice(0, 3, "xxx").should == "xxxんにちは"
+    "こんにちは".bytesplice(3, 3, "はは").should == "こははにちは"
+    "こんにちは".bytesplice(15, 0, "xxx").should == "こんにちはxxx"
+  end
 
-    it "replaces with range" do
-      "こんにちは".bytesplice(-15...-16, "xxx").should == "xxxこんにちは"
-      "こんにちは".bytesplice(0...0, "xxx").should == "xxxこんにちは"
-      "こんにちは".bytesplice(0..2, "xxx").should == "xxxんにちは"
-      "こんにちは".bytesplice(0...3, "xxx").should == "xxxんにちは"
-      "こんにちは".bytesplice(0..5, "xxx").should == "xxxにちは"
-      "こんにちは".bytesplice(0..-1, "xxx").should == "xxx"
-      "こんにちは".bytesplice(0...15, "xxx").should == "xxx"
-      "こんにちは".bytesplice(0...18, "xxx").should == "xxx"
-    end
+  it "replaces with range" do
+    "こんにちは".bytesplice(-15...-16, "xxx").should == "xxxこんにちは"
+    "こんにちは".bytesplice(0...0, "xxx").should == "xxxこんにちは"
+    "こんにちは".bytesplice(0..2, "xxx").should == "xxxんにちは"
+    "こんにちは".bytesplice(0...3, "xxx").should == "xxxんにちは"
+    "こんにちは".bytesplice(0..5, "xxx").should == "xxxにちは"
+    "こんにちは".bytesplice(0..-1, "xxx").should == "xxx"
+    "こんにちは".bytesplice(0...15, "xxx").should == "xxx"
+    "こんにちは".bytesplice(0...18, "xxx").should == "xxx"
+  end
 
-    it "treats negative length for range as 0" do
-      "こんにちは".bytesplice(0...-100, "xxx").should == "xxxこんにちは"
-      "こんにちは".bytesplice(3...-100, "xxx").should == "こxxxんにちは"
-      "こんにちは".bytesplice(-15...-100, "xxx").should == "xxxこんにちは"
-    end
+  it "treats negative length for range as 0" do
+    "こんにちは".bytesplice(0...-100, "xxx").should == "xxxこんにちは"
+    "こんにちは".bytesplice(3...-100, "xxx").should == "こxxxんにちは"
+    "こんにちは".bytesplice(-15...-100, "xxx").should == "xxxこんにちは"
+  end
 
-    it "raises when ranges not match codepoint boundaries" do
-      -> { "こんにちは".bytesplice(0..0, "x") }.should raise_error(IndexError, "offset 1 does not land on character boundary")
-      -> { "こんにちは".bytesplice(0..1, "x") }.should raise_error(IndexError, "offset 2 does not land on character boundary")
-      # Begin is incorrect
-      -> { "こんにちは".bytesplice(-4..-1, "x") }.should raise_error(IndexError, "offset 11 does not land on character boundary")
-      -> { "こんにちは".bytesplice(-5..-1, "x") }.should raise_error(IndexError, "offset 10 does not land on character boundary")
-      # End is incorrect
-      -> { "こんにちは".bytesplice(-3..-2, "x") }.should raise_error(IndexError, "offset 14 does not land on character boundary")
-      -> { "こんにちは".bytesplice(-3..-3, "x") }.should raise_error(IndexError, "offset 13 does not land on character boundary")
-    end
+  it "raises when ranges not match codepoint boundaries" do
+    -> { "こんにちは".bytesplice(0..0, "x") }.should raise_error(IndexError, "offset 1 does not land on character boundary")
+    -> { "こんにちは".bytesplice(0..1, "x") }.should raise_error(IndexError, "offset 2 does not land on character boundary")
+    # Begin is incorrect
+    -> { "こんにちは".bytesplice(-4..-1, "x") }.should raise_error(IndexError, "offset 11 does not land on character boundary")
+    -> { "こんにちは".bytesplice(-5..-1, "x") }.should raise_error(IndexError, "offset 10 does not land on character boundary")
+    # End is incorrect
+    -> { "こんにちは".bytesplice(-3..-2, "x") }.should raise_error(IndexError, "offset 14 does not land on character boundary")
+    -> { "こんにちは".bytesplice(-3..-3, "x") }.should raise_error(IndexError, "offset 13 does not land on character boundary")
+  end
 
-    it "deals with a different encoded argument" do
-      s = "こんにちは"
-      s.encoding.should == Encoding::UTF_8
-      sub = "xxxxxx"
-      sub.force_encoding(Encoding::US_ASCII)
+  it "deals with a different encoded argument" do
+    s = "こんにちは"
+    s.encoding.should == Encoding::UTF_8
+    sub = "xxxxxx"
+    sub.force_encoding(Encoding::US_ASCII)
 
-      result = s.bytesplice(0, 3, sub)
-      result.should == "xxxxxxんにちは"
-      result.encoding.should == Encoding::UTF_8
+    result = s.bytesplice(0, 3, sub)
+    result.should == "xxxxxxんにちは"
+    result.encoding.should == Encoding::UTF_8
 
-      s = "xxxxxx"
-      s.force_encoding(Encoding::US_ASCII)
-      sub = "こんにちは"
-      sub.encoding.should == Encoding::UTF_8
+    s = "xxxxxx"
+    s.force_encoding(Encoding::US_ASCII)
+    sub = "こんにちは"
+    sub.encoding.should == Encoding::UTF_8
 
-      result = s.bytesplice(0, 3, sub)
-      result.should == "こんにちはxxx"
-      result.encoding.should == Encoding::UTF_8
-    end
+    result = s.bytesplice(0, 3, sub)
+    result.should == "こんにちはxxx"
+    result.encoding.should == Encoding::UTF_8
   end
 
   ruby_version_is "3.3" do
diff --git a/spec/ruby/core/string/dedup_spec.rb b/spec/ruby/core/string/dedup_spec.rb
index 57d2be2cfd..2b31d80708 100644
--- a/spec/ruby/core/string/dedup_spec.rb
+++ b/spec/ruby/core/string/dedup_spec.rb
@@ -2,7 +2,5 @@ require_relative '../../spec_helper'
 require_relative 'shared/dedup'
 
 describe 'String#dedup' do
-  ruby_version_is '3.2' do
-    it_behaves_like :string_dedup, :dedup
-  end
+  it_behaves_like :string_dedup, :dedup
 end
diff --git a/spec/ruby/core/string/modulo_spec.rb b/spec/ruby/core/string/modulo_spec.rb
index 33c2141812..46e0aa0f36 100644
--- a/spec/ruby/core/string/modulo_spec.rb
+++ b/spec/ruby/core/string/modulo_spec.rb
@@ -391,16 +391,8 @@ describe "String#%" do
     ("%c" % 'A').should == "A"
   end
 
-  ruby_version_is ""..."3.2" do
-    it "raises an exception for multiple character strings as argument for %c" do
-      -> { "%c" % 'AA' }.should raise_error(ArgumentError)
-    end
-  end
-
-  ruby_version_is "3.2" do
-    it "supports only the first character as argument for %c" do
-      ("%c" % 'AA').should == "A"
-    end
+  it "supports only the first character as argument for %c" do
+    ("%c" % 'AA').should == "A"
   end
 
   it "calls to_str on argument for %c formats" do
diff --git a/spec/ruby/core/string/rstrip_spec.rb b/spec/ruby/core/string/rstrip_spec.rb
index 6d46eb590e..55773f5238 100644
--- a/spec/ruby/core/string/rstrip_spec.rb
+++ b/spec/ruby/core/string/rstrip_spec.rb
@@ -68,27 +68,13 @@ describe "String#rstrip!" do
     -> { "".freeze.rstrip!      }.should raise_error(FrozenError)
   end
 
-  ruby_version_is "3.2" do
-    it "raises an Encoding::CompatibilityError if the last non-space codepoint is invalid" do
-      s = "abc\xDF".force_encoding(Encoding::UTF_8)
-      s.valid_encoding?.should be_false
-      -> { s.rstrip! }.should raise_error(Encoding::CompatibilityError)
+  it "raises an Encoding::CompatibilityError if the last non-space codepoint is invalid" do
+    s = "abc\xDF".force_encoding(Encoding::UTF_8)
+    s.valid_encoding?.should be_false
+    -> { s.rstrip! }.should raise_error(Encoding::CompatibilityError)
 
-      s = "abc\xDF   ".force_encoding(Encoding::UTF_8)
-      s.valid_encoding?.should be_false
-      -> { s.rstrip! }.should raise_error(Encoding::CompatibilityError)
-    end
-  end
-
-  ruby_version_is ""..."3.2" do
-    it "raises an ArgumentError if the last non-space codepoint is invalid" do
-      s = "abc\xDF".force_encoding(Encoding::UTF_8)
-      s.valid_encoding?.should be_false
-      -> { s.rstrip! }.should raise_error(ArgumentError)
-
-      s = "abc\xDF   ".force_encoding(Encoding::UTF_8)
-      s.valid_encoding?.should be_false
-      -> { s.rstrip! }.should raise_error(ArgumentError)
-    end
+    s = "abc\xDF   ".force_encoding(Encoding::UTF_8)
+    s.valid_encoding?.should be_false
+    -> { s.rstrip! }.should raise_error(Encoding::CompatibilityError)
   end
 end
diff --git a/spec/ruby/core/string/to_c_spec.rb b/spec/ruby/core/string/to_c_spec.rb
index 4864a98e39..1813890e72 100644
--- a/spec/ruby/core/string/to_c_spec.rb
+++ b/spec/ruby/core/string/to_c_spec.rb
@@ -13,9 +13,7 @@ describe "String#to_c" do
 
   it "ignores trailing garbage" do
     '79+4iruby'.to_c.should == Complex(79, 4)
-    ruby_bug "[Bug #19087]", ""..."3.2" do
-      '7__9+4__0i'.to_c.should == Complex(7, 0)
-    end
+    '7__9+4__0i'.to_c.should == Complex(7, 0)
   end
 
   context "it treats special float value strings as characters" do
@@ -43,15 +41,13 @@ describe "String#to_c" do
     }.should raise_error(Encoding::CompatibilityError, "ASCII incompatible encoding: UTF-16")
   end
 
-  ruby_version_is "3.2" do
-    it "treats a sequence of underscores as an end of Complex string" do
-      "5+3_1i".to_c.should == Complex(5, 31)
-      "5+3__1i".to_c.should == Complex(5)
-      "5+3___1i".to_c.should == Complex(5)
+  it "treats a sequence of underscores as an end of Complex string" do
+    "5+3_1i".to_c.should == Complex(5, 31)
+    "5+3__1i".to_c.should == Complex(5)
+    "5+3___1i".to_c.should == Complex(5)
 
-      "12_3".to_c.should == Complex(123)
-      "12__3".to_c.should == Complex(12)
-      "12___3".to_c.should == Complex(12)
-    end
+    "12_3".to_c.should == Complex(123)
+    "12__3".to_c.should == Complex(12)
+    "12___3".to_c.should == Complex(12)
   end
 end
diff --git a/spec/ruby/core/string/to_f_spec.rb b/spec/ruby/core/string/to_f_spec.rb
index 72e2a90b13..ab1ba43fb3 100644
--- a/spec/ruby/core/string/to_f_spec.rb
+++ b/spec/ruby/core/string/to_f_spec.rb
@@ -120,11 +120,9 @@ describe "String#to_f" do
     "\3771.2".b.to_f.should == 0
   end
 
-  ruby_version_is "3.2" do
-    it "raises Encoding::CompatibilityError if String is in not ASCII-compatible encoding" do
-      -> {
-        '1.2'.encode("UTF-16").to_f
-      }.should raise_error(Encoding::CompatibilityError, "ASCII incompatible encoding: UTF-16")
-    end
+  it "raises Encoding::CompatibilityError if String is in not ASCII-compatible encoding" do
+    -> {
+      '1.2'.encode("UTF-16").to_f
+    }.should raise_error(Encoding::CompatibilityError, "ASCII incompatible encoding: UTF-16")
   end
 end
diff --git a/spec/ruby/core/string/unpack_spec.rb b/spec/ruby/core/string/unpack_spec.rb
index 083484ebe9..a0abf8fa99 100644
--- a/spec/ruby/core/string/unpack_spec.rb
+++ b/spec/ruby/core/string/unpack_spec.rb
@@ -26,7 +26,7 @@ describe "String#unpack" do
     "a".unpack("C", offset: 1).should == [nil]
   end
 
-  it "raises an ArgumentError when the offset is larget than the string" do
+  it "raises an ArgumentError when the offset is larger than the string" do
     -> { "a".unpack("C", offset: 2) }.should raise_error(ArgumentError, "offset outside of string")
   end
 end
diff --git a/spec/ruby/core/struct/constants_spec.rb b/spec/ruby/core/struct/constants_spec.rb
index fa61a4b912..7e8af1a211 100644
--- a/spec/ruby/core/struct/constants_spec.rb
+++ b/spec/ruby/core/struct/constants_spec.rb
@@ -1,15 +1,13 @@
 require_relative '../../spec_helper'
 
-ruby_version_is "3.2" do
-  describe "Struct::Group" do
-    it "is no longer defined" do
-      Struct.should_not.const_defined?(:Group)
-    end
+describe "Struct::Group" do
+  it "is no longer defined" do
+    Struct.should_not.const_defined?(:Group)
   end
+end
 
-  describe "Struct::Passwd" do
-    it "is no longer defined" do
-      Struct.should_not.const_defined?(:Passwd)
-    end
+describe "Struct::Passwd" do
+  it "is no longer defined" do
+    Struct.should_not.const_defined?(:Passwd)
   end
 end
diff --git a/spec/ruby/core/struct/deconstruct_keys_spec.rb b/spec/ruby/core/struct/deconstruct_keys_spec.rb
index cd05aee056..602403d183 100644
--- a/spec/ruby/core/struct/deconstruct_keys_spec.rb
+++ b/spec/ruby/core/struct/deconstruct_keys_spec.rb
@@ -80,7 +80,7 @@ describe "Struct#deconstruct_keys" do
     obj.deconstruct_keys(nil).should == {x: 1, y: 2}
   end
 
-  it "raises TypeError if index is not a String, a Symbol and not convertible to Integer " do
+  it "raises TypeError if index is not a String, a Symbol and not convertible to Integer" do
     struct = Struct.new(:x, :y)
     s = struct.new(1, 2)
 
diff --git a/spec/ruby/core/struct/initialize_spec.rb b/spec/ruby/core/struct/initialize_spec.rb
index 1861bcafb0..06055594d5 100644
--- a/spec/ruby/core/struct/initialize_spec.rb
+++ b/spec/ruby/core/struct/initialize_spec.rb
@@ -41,21 +41,11 @@ describe "Struct#initialize" do
     StructClasses::SubclassX.new(:y).new.key.should == :value
   end
 
-  ruby_version_is ""..."3.2" do
-    it "warns about passing only keyword arguments" do
-      -> {
-        StructClasses::Ruby.new(version: "3.1", platform: "OS")
-      }.should complain(/warning: Passing only keyword arguments/)
-    end
-  end
+  it "can be initialized with keyword arguments" do
+    positional_args = StructClasses::Ruby.new("3.2", "OS")
+    keyword_args = StructClasses::Ruby.new(version: "3.2", platform: "OS")
 
-  ruby_version_is "3.2" do
-    it "can be initialized with keyword arguments" do
-      positional_args = StructClasses::Ruby.new("3.2", "OS")
-      keyword_args = StructClasses::Ruby.new(version: "3.2", platform: "OS")
-
-      positional_args.version.should == keyword_args.version
-      positional_args.platform.should == keyword_args.platform
-    end
+    positional_args.version.should == keyword_args.version
+    positional_args.platform.should == keyword_args.platform
   end
 end
diff --git a/spec/ruby/core/struct/new_spec.rb b/spec/ruby/core/struct/new_spec.rb
index 73e88a81c1..6d014cb94d 100644
--- a/spec/ruby/core/struct/new_spec.rb
+++ b/spec/ruby/core/struct/new_spec.rb
@@ -73,20 +73,8 @@ describe "Struct.new" do
     -> { Struct.new(:animal, ['chris', 'evan'])    }.should raise_error(TypeError)
   end
 
-  ruby_version_is ""..."3.2" do
-    it "raises a TypeError or ArgumentError if passed a Hash with an unknown key" do
-      # CRuby < 3.2 raises ArgumentError: unknown keyword: :name, but that seems a bug:
-      # https://bugs.ruby-lang.org/issues/18632
-      -> { Struct.new(:animal, { name: 'chris' }) }.should raise_error(StandardError) { |e|
-        [ArgumentError, TypeError].should.include?(e.class)
-      }
-    end
-  end
-
-  ruby_version_is "3.2" do
-    it "raises a TypeError if passed a Hash with an unknown key" do
-      -> { Struct.new(:animal, { name: 'chris' }) }.should raise_error(TypeError)
-    end
+  it "raises a TypeError if passed a Hash with an unknown key" do
+    -> { Struct.new(:animal, { name: 'chris' }) }.should raise_error(TypeError)
   end
 
   ruby_version_is ""..."3.3" do
@@ -166,17 +154,15 @@ describe "Struct.new" do
       -> { StructClasses::Ruby.new('2.0', 'i686', true) }.should raise_error(ArgumentError)
     end
 
-    ruby_version_is '3.2' do
-      it "accepts keyword arguments to initialize" do
-        type = Struct.new(:args)
+    it "accepts keyword arguments to initialize" do
+      type = Struct.new(:args)
 
-        obj = type.new(args: 42)
-        obj2 = type.new(42)
+      obj = type.new(args: 42)
+      obj2 = type.new(42)
 
-        obj.should == obj2
-        obj.args.should == 42
-        obj2.args.should == 42
-      end
+      obj.should == obj2
+      obj.args.should == 42
+      obj2.args.should == 42
     end
   end
 
diff --git a/spec/ruby/core/symbol/to_proc_spec.rb b/spec/ruby/core/symbol/to_proc_spec.rb
index 54eccdba11..def5d6d344 100644
--- a/spec/ruby/core/symbol/to_proc_spec.rb
+++ b/spec/ruby/core/symbol/to_proc_spec.rb
@@ -27,31 +27,29 @@ describe "Symbol#to_proc" do
     pr.parameters.should == [[:req], [:rest]]
   end
 
-  ruby_version_is "3.2" do
-    it "only calls public methods" do
-      body = proc do
-        public def pub; @a << :pub end
-        protected def pro; @a << :pro end
-        private def pri; @a << :pri end
-        attr_reader :a
-      end
+  it "only calls public methods" do
+    body = proc do
+      public def pub; @a << :pub end
+      protected def pro; @a << :pro end
+      private def pri; @a << :pri end
+      attr_reader :a
+    end
 
-      @a = []
-      singleton_class.class_eval(&body)
-      tap(&:pub)
-      proc{tap(&:pro)}.should raise_error(NoMethodError, /protected method [`']pro' called/)
-      proc{tap(&:pri)}.should raise_error(NoMethodError, /private method [`']pri' called/)
-      @a.should == [:pub]
+    @a = []
+    singleton_class.class_eval(&body)
+    tap(&:pub)
+    proc{tap(&:pro)}.should raise_error(NoMethodError, /protected method [`']pro' called/)
+    proc{tap(&:pri)}.should raise_error(NoMethodError, /private method [`']pri' called/)
+    @a.should == [:pub]
 
-      @a = []
-      c = Class.new(&body)
-      o = c.new
-      o.instance_variable_set(:@a, [])
-      o.tap(&:pub)
-      proc{tap(&:pro)}.should raise_error(NoMethodError, /protected method [`']pro' called/)
-      proc{o.tap(&:pri)}.should raise_error(NoMethodError, /private method [`']pri' called/)
-      o.a.should == [:pub]
-    end
+    @a = []
+    c = Class.new(&body)
+    o = c.new
+    o.instance_variable_set(:@a, [])
+    o.tap(&:pub)
+    proc{tap(&:pro)}.should raise_error(NoMethodError, /protected method [`']pro' called/)
+    proc{o.tap(&:pri)}.should raise_error(NoMethodError, /private method [`']pri' called/)
+    o.a.should == [:pub]
   end
 
   it "raises an ArgumentError when calling #call on the Proc without receiver" do
diff --git a/spec/ruby/core/thread/each_caller_location_spec.rb b/spec/ruby/core/thread/each_caller_location_spec.rb
index 29c271789b..aa7423675b 100644
--- a/spec/ruby/core/thread/each_caller_location_spec.rb
+++ b/spec/ruby/core/thread/each_caller_location_spec.rb
@@ -1,49 +1,47 @@
 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; }
+  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
+    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 }
+  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
+    (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)
+  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
 
-    it "returns nil" do
-      Thread.each_caller_location {}.should == nil
-    end
+    ar.map(&:to_s).should == caller_locations(1, 2).map(&:to_s)
+    ecl.should be_kind_of(Thread::Backtrace::Location)
+  end
 
-    it "raises LocalJumpError when called without a block" do
-      -> {
-        Thread.each_caller_location
-      }.should raise_error(LocalJumpError, "no block given")
-    end
+  it "returns nil" do
+    Thread.each_caller_location {}.should == nil
+  end
 
-    it "doesn't accept keyword arguments" do
-      -> {
-        Thread.each_caller_location(12, foo: 10) {}
-      }.should raise_error(ArgumentError);
-    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 keyword arguments" do
+    -> {
+      Thread.each_caller_location(12, foo: 10) {}
+    }.should raise_error(ArgumentError);
   end
 end
diff --git a/spec/ruby/core/time/deconstruct_keys_spec.rb b/spec/ruby/core/time/deconstruct_keys_spec.rb
index ee17e7dbd4..b5cfdaa93f 100644
--- a/spec/ruby/core/time/deconstruct_keys_spec.rb
+++ b/spec/ruby/core/time/deconstruct_keys_spec.rb
@@ -1,45 +1,43 @@
 require_relative '../../spec_helper'
 
-ruby_version_is "3.2" do
-  describe "Time#deconstruct_keys" do
-    it "returns whole hash for nil as an argument" do
-      d = Time.utc(2022, 10, 5, 13, 30)
-      res = { year: 2022, month: 10, day: 5, yday: 278, wday: 3, hour: 13,
-              min: 30, sec: 0, subsec: 0, dst: false, zone: "UTC" }
-      d.deconstruct_keys(nil).should == res
-    end
-
-    it "returns only specified keys" do
-      d = Time.utc(2022, 10, 5, 13, 39)
-      d.deconstruct_keys([:zone, :subsec]).should == { zone: "UTC", subsec: 0 }
-    end
-
-    it "requires one argument" do
-      -> {
-        Time.new(2022, 10, 5, 13, 30).deconstruct_keys
-      }.should raise_error(ArgumentError)
-    end
-
-    it "it raises error when argument is neither nil nor array" do
-      d = Time.new(2022, 10, 5, 13, 30)
-
-      -> { d.deconstruct_keys(1) }.should raise_error(TypeError, "wrong argument type Integer (expected Array or nil)")
-      -> { d.deconstruct_keys("asd") }.should raise_error(TypeError, "wrong argument type String (expected Array or nil)")
-      -> { d.deconstruct_keys(:x) }.should raise_error(TypeError, "wrong argument type Symbol (expected Array or nil)")
-      -> { d.deconstruct_keys({}) }.should raise_error(TypeError, "wrong argument type Hash (expected Array or nil)")
-    end
-
-    it "returns {} when passed []" do
-      Time.new(2022, 10, 5, 13, 30).deconstruct_keys([]).should == {}
-    end
-
-    it "ignores non-Symbol keys" do
-      Time.new(2022, 10, 5, 13, 30).deconstruct_keys(['year', []]).should == {}
-    end
-
-    it "ignores not existing Symbol keys and processes keys after the first non-existing one" do
-      d = Time.utc(2022, 10, 5, 13, 30)
-      d.deconstruct_keys([:year, :a, :month, :b, :day]).should == { year: 2022, month: 10, day: 5 }
-    end
+describe "Time#deconstruct_keys" do
+  it "returns whole hash for nil as an argument" do
+    d = Time.utc(2022, 10, 5, 13, 30)
+    res = { year: 2022, month: 10, day: 5, yday: 278, wday: 3, hour: 13,
+            min: 30, sec: 0, subsec: 0, dst: false, zone: "UTC" }
+    d.deconstruct_keys(nil).should == res
+  end
+
+  it "returns only specified keys" do
+    d = Time.utc(2022, 10, 5, 13, 39)
+    d.deconstruct_keys([:zone, :subsec]).should == { zone: "UTC", subsec: 0 }
+  end
+
+  it "requires one argument" do
+    -> {
+      Time.new(2022, 10, 5, 13, 30).deconstruct_keys
+    }.should raise_error(ArgumentError)
+  end
+
+  it "it raises error when argument is neither nil nor array" do
+    d = Time.new(2022, 10, 5, 13, 30)
+
+    -> { d.deconstruct_keys(1) }.should raise_error(TypeError, "wrong argument type Integer (expected Array or nil)")
+    -> { d.deconstruct_keys("asd") }.should raise_error(TypeError, "wrong argument type String (expected Array or nil)")
+    -> { d.deconstruct_keys(:x) }.should raise_error(TypeError, "wrong argument type Symbol (expected Array or nil)")
+    -> { d.deconstruct_keys({}) }.should raise_error(TypeError, "wrong argument type Hash (expected Array or nil)")
+  end
+
+  it "returns {} when passed []" do
+    Time.new(2022, 10, 5, 13, 30).deconstruct_keys([]).should == {}
+  end
+
+  it "ignores non-Symbol keys" do
+    Time.new(2022, 10, 5, 13, 30).deconstruct_keys(['year', []]).should == {}
+  end
+
+  it "ignores not existing Symbol keys and processes keys after the first non-existing one" do
+    d = Time.utc(2022, 10, 5, 13, 30)
+    d.deconstruct_keys([:year, :a, :month, :b, :day]).should == { year: 2022, month: 10, day: 5 }
   end
 end
diff --git a/spec/ruby/core/time/new_spec.rb b/spec/ruby/core/time/new_spec.rb
index 0fd48640d4..f288da84dd 100644
--- a/spec/ruby/core/time/new_spec.rb
+++ b/spec/ruby/core/time/new_spec.rb
@@ -467,259 +467,253 @@ describe "Time.new with a timezone argument" do
     end
   end
 
-  ruby_version_is "3.2" do
-    describe "Time.new with a String argument" do
-      it "parses an ISO-8601 like format" do
-        t = Time.utc(2020, 12, 24, 15, 56, 17)
-
-        Time.new("2020-12-24T15:56:17Z").should == t
-        Time.new("2020-12-25 00:56:17 +09:00").should == t
-        Time.new("2020-12-25 00:57:47 +09:01:30").should == t
-        Time.new("2020-12-25 00:56:17 +0900").should == t
-        Time.new("2020-12-25 00:57:47 +090130").should == t
-        Time.new("2020-12-25T00:56:17+09:00").should == t
-
-        Time.new("2020-12-25T00:56:17.123456+09:00").should == Time.utc(2020, 12, 24, 15, 56, 17, 123456)
-      end
+  describe "Time.new with a String argument" do
+    it "parses an ISO-8601 like format" do
+      t = Time.utc(2020, 12, 24, 15, 56, 17)
 
-      it "accepts precision keyword argument and truncates specified digits of sub-second part" do
-        Time.new("2021-12-25 00:00:00.123456789876 +09:00").subsec.should == 0.123456789r
-        Time.new("2021-12-25 00:00:00.123456789876 +09:00", precision: nil).subsec.should == 0.123456789876r
-        Time.new("2021-12-25 00:00:00 +09:00", precision: 0).subsec.should == 0
-        Time.new("2021-12-25 00:00:00.123456789876 +09:00", precision: -1).subsec.should == 0.123456789876r
-      end
+      Time.new("2020-12-24T15:56:17Z").should == t
+      Time.new("2020-12-25 00:56:17 +09:00").should == t
+      Time.new("2020-12-25 00:57:47 +09:01:30").should == t
+      Time.new("2020-12-25 00:56:17 +0900").should == t
+      Time.new("2020-12-25 00:57:47 +090130").should == t
+      Time.new("2020-12-25T00:56:17+09:00").should == t
 
-      it "returns Time in local timezone if not provided in the String argument" do
-        Time.new("2021-12-25 00:00:00").zone.should == Time.new(2021, 12, 25).zone
-        Time.new("2021-12-25 00:00:00").utc_offset.should == Time.new(2021, 12, 25).utc_offset
-      end
+      Time.new("2020-12-25T00:56:17.123456+09:00").should == Time.utc(2020, 12, 24, 15, 56, 17, 123456)
+    end
 
-      it "returns Time in timezone specified in the String argument" do
-        Time.new("2021-12-25 00:00:00 +05:00").to_s.should == "2021-12-25 00:00:00 +0500"
-      end
+    it "accepts precision keyword argument and truncates specified digits of sub-second part" do
+      Time.new("2021-12-25 00:00:00.123456789876 +09:00").subsec.should == 0.123456789r
+      Time.new("2021-12-25 00:00:00.123456789876 +09:00", precision: nil).subsec.should == 0.123456789876r
+      Time.new("2021-12-25 00:00:00 +09:00", precision: 0).subsec.should == 0
+      Time.new("2021-12-25 00:00:00.123456789876 +09:00", precision: -1).subsec.should == 0.123456789876r
+    end
 
-      it "returns Time in timezone specified in the String argument even if the in keyword argument provided" do
-        Time.new("2021-12-25 00:00:00 +09:00", in: "-01:00").to_s.should == "2021-12-25 00:00:00 +0900"
-      end
+    it "returns Time in local timezone if not provided in the String argument" do
+      Time.new("2021-12-25 00:00:00").zone.should == Time.new(2021, 12, 25).zone
+      Time.new("2021-12-25 00:00:00").utc_offset.should == Time.new(2021, 12, 25).utc_offset
+    end
 
-      it "returns Time in timezone specified with in keyword argument if timezone isn't provided in the String argument" do
-        Time.new("2021-12-25 00:00:00", in: "-01:00").to_s.should == "2021-12-25 00:00:00 -0100"
-      end
+    it "returns Time in timezone specified in the String argument" do
+      Time.new("2021-12-25 00:00:00 +05:00").to_s.should == "2021-12-25 00:00:00 +0500"
+    end
 
-      it "returns Time of Jan 1 for string with just year" do
-        Time.new("2021").should == Time.new(2021, 1, 1)
-        Time.new("2021").zone.should == Time.new(2021, 1, 1).zone
-        Time.new("2021").utc_offset.should == Time.new(2021, 1, 1).utc_offset
-      end
+    it "returns Time in timezone specified in the String argument even if the in keyword argument provided" do
+      Time.new("2021-12-25 00:00:00 +09:00", in: "-01:00").to_s.should == "2021-12-25 00:00:00 +0900"
+    end
 
-      it "returns Time of Jan 1 for string with just year in timezone specified with in keyword argument" do
-        Time.new("2021", in: "+17:00").to_s.should == "2021-01-01 00:00:00 +1700"
-      end
+    it "returns Time in timezone specified with in keyword argument if timezone isn't provided in the String argument" do
+      Time.new("2021-12-25 00:00:00", in: "-01:00").to_s.should == "2021-12-25 00:00:00 -0100"
+    end
 
-      it "converts precision keyword argument into Integer if is not nil" do
-        obj = Object.new
-        def obj.to_int; 3; end
+    it "returns Time of Jan 1 for string with just year" do
+      Time.new("2021").should == Time.new(2021, 1, 1)
+      Time.new("2021").zone.should == Time.new(2021, 1, 1).zone
+      Time.new("2021").utc_offset.should == Time.new(2021, 1, 1).utc_offset
+    end
 
-        Time.new("2021-12-25 00:00:00.123456789876 +09:00", precision: 1.2).subsec.should == 0.1r
-        Time.new("2021-12-25 00:00:00.123456789876 +09:00", precision: obj).subsec.should == 0.123r
-        Time.new("2021-12-25 00:00:00.123456789876 +09:00", precision: 3r).subsec.should == 0.123r
-      end
+    it "returns Time of Jan 1 for string with just year in timezone specified with in keyword argument" do
+      Time.new("2021", in: "+17:00").to_s.should == "2021-01-01 00:00:00 +1700"
+    end
 
-      ruby_version_is ""..."3.3" do
-        it "raise TypeError is can't convert precision keyword argument into Integer" do
-          -> {
-            Time.new("2021-12-25 00:00:00.123456789876 +09:00", precision: "")
-          }.should raise_error(TypeError, "no implicit conversion from string")
-        end
-      end
+    it "converts precision keyword argument into Integer if is not nil" do
+      obj = Object.new
+      def obj.to_int; 3; end
 
-      ruby_version_is "3.3" do
-        it "raise TypeError is can't convert precision keyword argument into Integer" do
-          -> {
-            Time.new("2021-12-25 00:00:00.123456789876 +09:00", precision: "")
-          }.should raise_error(TypeError, "no implicit conversion of String into Integer")
-        end
-      end
+      Time.new("2021-12-25 00:00:00.123456789876 +09:00", precision: 1.2).subsec.should == 0.1r
+      Time.new("2021-12-25 00:00:00.123456789876 +09:00", precision: obj).subsec.should == 0.123r
+      Time.new("2021-12-25 00:00:00.123456789876 +09:00", precision: 3r).subsec.should == 0.123r
+    end
 
-      it "raises ArgumentError if part of time string is missing" do
+    ruby_version_is ""..."3.3" do
+      it "raise TypeError is can't convert precision keyword argument into Integer" do
         -> {
-          Time.new("2020-12-25 00:56 +09:00")
-        }.should raise_error(ArgumentError, /missing sec part: 00:56 |can't parse:/)
+          Time.new("2021-12-25 00:00:00.123456789876 +09:00", precision: "")
+        }.should raise_error(TypeError, "no implicit conversion from string")
+      end
+    end
 
+    ruby_version_is "3.3" do
+      it "raise TypeError is can't convert precision keyword argument into Integer" do
         -> {
-          Time.new("2020-12-25 00 +09:00")
-        }.should raise_error(ArgumentError, /missing min part: 00 |can't parse:/)
+          Time.new("2021-12-25 00:00:00.123456789876 +09:00", precision: "")
+        }.should raise_error(TypeError, "no implicit conversion of String into Integer")
       end
+    end
 
-      ruby_version_is "3.2.3" do
-        it "raises ArgumentError if the time part is missing" do
-          -> {
-            Time.new("2020-12-25")
-          }.should raise_error(ArgumentError, /no time information|can't parse:/)
-        end
-
-        it "raises ArgumentError if day is missing" do
-          -> {
-            Time.new("2020-12")
-          }.should raise_error(ArgumentError, /no time information|can't parse:/)
-        end
-      end
+    it "raises ArgumentError if part of time string is missing" do
+      -> {
+        Time.new("2020-12-25 00:56 +09:00")
+      }.should raise_error(ArgumentError, /missing sec part: 00:56 |can't parse:/)
 
-      it "raises ArgumentError if subsecond is missing after dot" do
-        -> {
-          Time.new("2020-12-25 00:56:17. +0900")
-        }.should raise_error(ArgumentError, /subsecond expected after dot: 00:56:17. |can't parse:/)
-      end
+      -> {
+        Time.new("2020-12-25 00 +09:00")
+      }.should raise_error(ArgumentError, /missing min part: 00 |can't parse:/)
+    end
 
-      it "raises ArgumentError if String argument is not in the supported format" do
-        -> {
-          Time.new("021-12-25 00:00:00.123456 +09:00")
-        }.should raise_error(ArgumentError, /year must be 4 or more digits: 021|can't parse:/)
+    it "raises ArgumentError if the time part is missing" do
+      -> {
+        Time.new("2020-12-25")
+      }.should raise_error(ArgumentError, /no time information|can't parse:/)
+    end
 
-        -> {
-          Time.new("2020-012-25 00:56:17 +0900")
-        }.should raise_error(ArgumentError, /\Atwo digits mon is expected after [`']-': -012-25 00:\z|can't parse:/)
+    it "raises ArgumentError if day is missing" do
+      -> {
+        Time.new("2020-12")
+      }.should raise_error(ArgumentError, /no time information|can't parse:/)
+    end
 
-        -> {
-          Time.new("2020-2-25 00:56:17 +0900")
-        }.should raise_error(ArgumentError, /\Atwo digits mon is expected after [`']-': -2-25 00:56\z|can't parse:/)
+    it "raises ArgumentError if subsecond is missing after dot" do
+      -> {
+        Time.new("2020-12-25 00:56:17. +0900")
+      }.should raise_error(ArgumentError, /subsecond expected after dot: 00:56:17. |can't parse:/)
+    end
 
-        -> {
-          Time.new("2020-12-215 00:56:17 +0900")
-        }.should raise_error(ArgumentError, /\Atwo digits mday is expected after [`']-': -215 00:56:\z|can't parse:/)
+    it "raises ArgumentError if String argument is not in the supported format" do
+      -> {
+        Time.new("021-12-25 00:00:00.123456 +09:00")
+      }.should raise_error(ArgumentError, /year must be 4 or more digits: 021|can't parse:/)
 
-        -> {
-          Time.new("2020-12-25 000:56:17 +0900")
-        }.should raise_error(ArgumentError, /two digits hour is expected:  000:56:17 |can't parse:/)
+      -> {
+        Time.new("2020-012-25 00:56:17 +0900")
+      }.should raise_error(ArgumentError, /\Atwo digits mon is expected after [`']-': -012-25 00:\z|can't parse:/)
 
-        -> {
-          Time.new("2020-12-25 0:56:17 +0900")
-        }.should raise_error(ArgumentError, /two digits hour is expected:  0:56:17 \+0|can't parse:/)
+      -> {
+        Time.new("2020-2-25 00:56:17 +0900")
+      }.should raise_error(ArgumentError, /\Atwo digits mon is expected after [`']-': -2-25 00:56\z|can't parse:/)
 
-        -> {
-          Time.new("2020-12-25 00:516:17 +0900")
-        }.should raise_error(ArgumentError, /\Atwo digits min is expected after [`']:': :516:17 \+09\z|can't parse:/)
+      -> {
+        Time.new("2020-12-215 00:56:17 +0900")
+      }.should raise_error(ArgumentError, /\Atwo digits mday is expected after [`']-': -215 00:56:\z|can't parse:/)
 
-        -> {
-          Time.new("2020-12-25 00:6:17 +0900")
-        }.should raise_error(ArgumentError, /\Atwo digits min is expected after [`']:': :6:17 \+0900\z|can't parse:/)
+      -> {
+        Time.new("2020-12-25 000:56:17 +0900")
+      }.should raise_error(ArgumentError, /two digits hour is expected:  000:56:17 |can't parse:/)
 
-        -> {
-          Time.new("2020-12-25 00:56:137 +0900")
-        }.should raise_error(ArgumentError, /\Atwo digits sec is expected after [`']:': :137 \+0900\z|can't parse:/)
+      -> {
+        Time.new("2020-12-25 0:56:17 +0900")
+      }.should raise_error(ArgumentError, /two digits hour is expected:  0:56:17 \+0|can't parse:/)
 
-        -> {
-          Time.new("2020-12-25 00:56:7 +0900")
-        }.should raise_error(ArgumentError, /\Atwo digits sec is expected after [`']:': :7 \+0900\z|can't parse:/)
+      -> {
+        Time.new("2020-12-25 00:516:17 +0900")
+      }.should raise_error(ArgumentError, /\Atwo digits min is expected after [`']:': :516:17 \+09\z|can't parse:/)
 
-        -> {
-          Time.new("2020-12-25 00:56. +0900")
-        }.should raise_error(ArgumentError, /fraction min is not supported: 00:56\.|can't parse:/)
+      -> {
+        Time.new("2020-12-25 00:6:17 +0900")
+      }.should raise_error(ArgumentError, /\Atwo digits min is expected after [`']:': :6:17 \+0900\z|can't parse:/)
 
-        -> {
-          Time.new("2020-12-25 00. +0900")
-        }.should raise_error(ArgumentError, /fraction hour is not supported: 00\.|can't parse:/)
-      end
+      -> {
+        Time.new("2020-12-25 00:56:137 +0900")
+      }.should raise_error(ArgumentError, /\Atwo digits sec is expected after [`']:': :137 \+0900\z|can't parse:/)
 
-      it "raises ArgumentError if date/time parts values are not valid" do
-        -> {
-          Time.new("2020-13-25 00:56:17 +09:00")
-        }.should raise_error(ArgumentError, /(mon|argument) out of range/)
+      -> {
+        Time.new("2020-12-25 00:56:7 +0900")
+      }.should raise_error(ArgumentError, /\Atwo digits sec is expected after [`']:': :7 \+0900\z|can't parse:/)
 
-        -> {
-          Time.new("2020-12-32 00:56:17 +09:00")
-        }.should raise_error(ArgumentError, /(mday|argument) out of range/)
+      -> {
+        Time.new("2020-12-25 00:56. +0900")
+      }.should raise_error(ArgumentError, /fraction min is not supported: 00:56\.|can't parse:/)
 
-        -> {
-          Time.new("2020-12-25 25:56:17 +09:00")
-        }.should raise_error(ArgumentError, /(hour|argument) out of range/)
+      -> {
+        Time.new("2020-12-25 00. +0900")
+      }.should raise_error(ArgumentError, /fraction hour is not supported: 00\.|can't parse:/)
+    end
 
-        -> {
-          Time.new("2020-12-25 00:61:17 +09:00")
-        }.should raise_error(ArgumentError, /(min|argument) out of range/)
+    it "raises ArgumentError if date/time parts values are not valid" do
+      -> {
+        Time.new("2020-13-25 00:56:17 +09:00")
+      }.should raise_error(ArgumentError, /(mon|argument) out of range/)
 
-        -> {
-          Time.new("2020-12-25 00:56:61 +09:00")
-        }.should raise_error(ArgumentError, /(sec|argument) out of range/)
+      -> {
+        Time.new("2020-12-32 00:56:17 +09:00")
+      }.should raise_error(ArgumentError, /(mday|argument) out of range/)
 
-        -> {
-          Time.new("2020-12-25 00:56:17 +23:59:60")
-        }.should raise_error(ArgumentError, /utc_offset|argument out of range/)
+      -> {
+        Time.new("2020-12-25 25:56:17 +09:00")
+      }.should raise_error(ArgumentError, /(hour|argument) out of range/)
 
-        -> {
-          Time.new("2020-12-25 00:56:17 +24:00")
-        }.should raise_error(ArgumentError, /(utc_offset|argument) out of range/)
+      -> {
+        Time.new("2020-12-25 00:61:17 +09:00")
+      }.should raise_error(ArgumentError, /(min|argument) out of range/)
 
+      -> {
+        Time.new("2020-12-25 00:56:61 +09:00")
+      }.should raise_error(ArgumentError, /(sec|argument) out of range/)
+
+      -> {
+        Time.new("2020-12-25 00:56:17 +23:59:60")
+      }.should raise_error(ArgumentError, /utc_offset|argument out of range/)
+
+      -> {
+        Time.new("2020-12-25 00:56:17 +24:00")
+      }.should raise_error(ArgumentError, /(utc_offset|argument) out of range/)
+
+      -> {
+        Time.new("2020-12-25 00:56:17 +23:61")
+      }.should raise_error(ArgumentError, /utc_offset/)
+
+      ruby_bug '#20797', ''...'3.4' do
         -> {
-          Time.new("2020-12-25 00:56:17 +23:61")
+          Time.new("2020-12-25 00:56:17 +00:23:61")
         }.should raise_error(ArgumentError, /utc_offset/)
-
-        ruby_bug '#20797', ''...'3.4' do
-          -> {
-            Time.new("2020-12-25 00:56:17 +00:23:61")
-          }.should raise_error(ArgumentError, /utc_offset/)
-        end
       end
+    end
 
-      it "raises ArgumentError if utc offset parts are not valid" do
-        -> { Time.new("2020-12-25 00:56:17 +24:00") }.should raise_error(ArgumentError, "utc_offset out of range")
-        -> { Time.new("2020-12-25 00:56:17 +2400") }.should raise_error(ArgumentError, "utc_offset out of range")
-
-        -> { Time.new("2020-12-25 00:56:17 +99:00") }.should raise_error(ArgumentError, "utc_offset out of range")
-        -> { Time.new("2020-12-25 00:56:17 +9900") }.should raise_error(ArgumentError, "utc_offset out of range")
+    it "raises ArgumentError if utc offset parts are not valid" do
+      -> { Time.new("2020-12-25 00:56:17 +24:00") }.should raise_error(ArgumentError, "utc_offset out of range")
+      -> { Time.new("2020-12-25 00:56:17 +2400") }.should raise_error(ArgumentError, "utc_offset out of range")
 
-        -> { Time.new("2020-12-25 00:56:17 +00:60") }.should raise_error(ArgumentError, '"+HH:MM", "-HH:MM", "UTC" or "A".."I","K".."Z" expected for utc_offset: +00:60')
-        -> { Time.new("2020-12-25 00:56:17 +0060") }.should raise_error(ArgumentError, '"+HH:MM", "-HH:MM", "UTC" or "A".."I","K".."Z" expected for utc_offset: +0060')
+      -> { Time.new("2020-12-25 00:56:17 +99:00") }.should raise_error(ArgumentError, "utc_offset out of range")
+      -> { Time.new("2020-12-25 00:56:17 +9900") }.should raise_error(ArgumentError, "utc_offset out of range")
 
-        -> { Time.new("2020-12-25 00:56:17 +00:99") }.should raise_error(ArgumentError, '"+HH:MM", "-HH:MM", "UTC" or "A".."I","K".."Z" expected for utc_offset: +00:99')
-        -> { Time.new("2020-12-25 00:56:17 +0099") }.should raise_error(ArgumentError, '"+HH:MM", "-HH:MM", "UTC" or "A".."I","K".."Z" expected for utc_offset: +0099')
+      -> { Time.new("2020-12-25 00:56:17 +00:60") }.should raise_error(ArgumentError, '"+HH:MM", "-HH:MM", "UTC" or "A".."I","K".."Z" expected for utc_offset: +00:60')
+      -> { Time.new("2020-12-25 00:56:17 +0060") }.should raise_error(ArgumentError, '"+HH:MM", "-HH:MM", "UTC" or "A".."I","K".."Z" expected for utc_offset: +0060')
 
-        ruby_bug '#20797', ''...'3.4' do
-          -> { Time.new("2020-12-25 00:56:17 +00:00:60") }.should raise_error(ArgumentError, '"+HH:MM", "-HH:MM", "UTC" or "A".."I","K".."Z" expected for utc_offset: +00:00:60')
-          -> { Time.new("2020-12-25 00:56:17 +000060") }.should raise_error(ArgumentError, '"+HH:MM", "-HH:MM", "UTC" or "A".."I","K".."Z" expected for utc_offset: +000060')
+      -> { Time.new("2020-12-25 00:56:17 +00:99") }.should raise_error(ArgumentError, '"+HH:MM", "-HH:MM", "UTC" or "A".."I","K".."Z" expected for utc_offset: +00:99')
+      -> { Time.new("2020-12-25 00:56:17 +0099") }.should raise_error(ArgumentError, '"+HH:MM", "-HH:MM", "UTC" or "A".."I","K".."Z" expected for utc_offset: +0099')
 
-          -> { Time.new("2020-12-25 00:56:17 +00:00:99") }.should raise_error(ArgumentError, '"+HH:MM", "-HH:MM", "UTC" or "A".."I","K".."Z" expected for utc_offset: +00:00:99')
-          -> { Time.new("2020-12-25 00:56:17 +000099") }.should raise_error(ArgumentError, '"+HH:MM", "-HH:MM", "UTC" or "A".."I","K".."Z" expected for utc_offset: +000099')
-        end
-      end
+      ruby_bug '#20797', ''...'3.4' do
+        -> { Time.new("2020-12-25 00:56:17 +00:00:60") }.should raise_error(ArgumentError, '"+HH:MM", "-HH:MM", "UTC" or "A".."I","K".."Z" expected for utc_offset: +00:00:60')
+        -> { Time.new("2020-12-25 00:56:17 +000060") }.should raise_error(ArgumentError, '"+HH:MM", "-HH:MM", "UTC" or "A".."I","K".."Z" expected for utc_offset: +000060')
 
-      it "raises ArgumentError if string has not ascii-compatible encoding" do
-        -> {
-          Time.new("2021-11-31 00:00:60 +09:00".encode("utf-32le"))
-        }.should raise_error(ArgumentError, "time string should have ASCII compatible encoding")
+        -> { Time.new("2020-12-25 00:56:17 +00:00:99") }.should raise_error(ArgumentError, '"+HH:MM", "-HH:MM", "UTC" or "A".."I","K".."Z" expected for utc_offset: +00:00:99')
+        -> { Time.new("2020-12-25 00:56:17 +000099") }.should raise_error(ArgumentError, '"+HH:MM", "-HH:MM", "UTC" or "A".."I","K".."Z" expected for utc_offset: +000099')
       end
+    end
 
-      it "raises ArgumentError if string doesn't start with year" do
-        -> {
-          Time.new("a\nb")
-        }.should raise_error(ArgumentError, "can't parse: \"a\\nb\"")
-      end
+    it "raises ArgumentError if string has not ascii-compatible encoding" do
+      -> {
+        Time.new("2021-11-31 00:00:60 +09:00".encode("utf-32le"))
+      }.should raise_error(ArgumentError, "time string should have ASCII compatible encoding")
+    end
 
-      it "raises ArgumentError if string has extra characters after offset" do
-        -> {
-          Time.new("2021-11-31 00:00:59 +09:00 abc")
-        }.should raise_error(ArgumentError, /can't parse.+ abc/)
-      end
+    it "raises ArgumentError if string doesn't start with year" do
+      -> {
+        Time.new("a\nb")
+      }.should raise_error(ArgumentError, "can't parse: \"a\\nb\"")
+    end
 
-      ruby_version_is "3.2.3" do
-        it "raises ArgumentError when there are leading space characters" do
-          -> { Time.new(" 2020-12-02 00:00:00") }.should raise_error(ArgumentError, /can't parse/)
-          -> { Time.new("\t2020-12-02 00:00:00") }.should raise_error(ArgumentError, /can't parse/)
-          -> { Time.new("\n2020-12-02 00:00:00") }.should raise_error(ArgumentError, /can't parse/)
-          -> { Time.new("\v2020-12-02 00:00:00") }.should raise_error(ArgumentError, /can't parse/)
-          -> { Time.new("\f2020-12-02 00:00:00") }.should raise_error(ArgumentError, /can't parse/)
-          -> { Time.new("\r2020-12-02 00:00:00") }.should raise_error(ArgumentError, /can't parse/)
-        end
-
-        it "raises ArgumentError when there are trailing whitespaces" do
-          -> { Time.new("2020-12-02 00:00:00 ") }.should raise_error(ArgumentError, /can't parse/)
-          -> { Time.new("2020-12-02 00:00:00\t") }.should raise_error(ArgumentError, /can't parse/)
-          -> { Time.new("2020-12-02 00:00:00\n") }.should raise_error(ArgumentError, /can't parse/)
-          -> { Time.new("2020-12-02 00:00:00\v") }.should raise_error(ArgumentError, /can't parse/)
-          -> { Time.new("2020-12-02 00:00:00\f") }.should raise_error(ArgumentError, /can't parse/)
-          -> { Time.new("2020-12-02 00:00:00\r") }.should raise_error(ArgumentError, /can't parse/)
-        end
-      end
+    it "raises ArgumentError if string has extra characters after offset" do
+      -> {
+        Time.new("2021-11-31 00:00:59 +09:00 abc")
+      }.should raise_error(ArgumentError, /can't parse.+ abc/)
+    end
+
+    it "raises ArgumentError when there are leading space characters" do
+      -> { Time.new(" 2020-12-02 00:00:00") }.should raise_error(ArgumentError, /can't parse/)
+      -> { Time.new("\t2020-12-02 00:00:00") }.should raise_error(ArgumentError, /can't parse/)
+      -> { Time.new("\n2020-12-02 00:00:00") }.should raise_error(ArgumentError, /can't parse/)
+      -> { Time.new("\v2020-12-02 00:00:00") }.should raise_error(ArgumentError, /can't parse/)
+      -> { Time.new("\f2020-12-02 00:00:00") }.should raise_error(ArgumentError, /can't parse/)
+      -> { Time.new("\r2020-12-02 00:00:00") }.should raise_error(ArgumentError, /can't parse/)
+    end
+
+    it "raises ArgumentError when there are trailing whitespaces" do
+      -> { Time.new("2020-12-02 00:00:00 ") }.should raise_error(ArgumentError, /can't parse/)
+      -> { Time.new("2020-12-02 00:00:00\t") }.should raise_error(ArgumentError, /can't parse/)
+      -> { Time.new("2020-12-02 00:00:00\n") }.should raise_error(ArgumentError, /can't parse/)
+      -> { Time.new("2020-12-02 00:00:00\v") }.should raise_error(ArgumentError, /can't parse/)
+      -> { Time.new("2020-12-02 00:00:00\f") }.should raise_error(ArgumentError, /can't parse/)
+      -> { Time.new("2020-12-02 00:00:00\r") }.should raise_error(ArgumentError, /can't parse/)
     end
   end
 end
diff --git a/spec/ruby/core/time/now_spec.rb b/spec/ruby/core/time/now_spec.rb
index f19e015461..e3fe6edad6 100644
--- a/spec/ruby/core/time/now_spec.rb
+++ b/spec/ruby/core/time/now_spec.rb
@@ -84,99 +84,97 @@ describe "Time.now" do
     end
   end
 
-  ruby_version_is '3.1' do # https://bugs.ruby-lang.org/issues/17485
-    describe "Timezone object" do
-      it "raises TypeError if timezone does not implement #utc_to_local method" do
+  describe "Timezone object" do # https://bugs.ruby-lang.org/issues/17485
+    it "raises TypeError if timezone does not implement #utc_to_local method" do
+      zone = Object.new
+      def zone.local_to_utc(time)
+        time
+      end
+
+      -> {
+        Time.now(in: zone)
+      }.should raise_error(TypeError, /can't convert Object into an exact number/)
+    end
+
+    it "does not raise exception if timezone does not implement #local_to_utc method" do
+      zone = Object.new
+      def zone.utc_to_local(time)
+        time
+      end
+
+      Time.now(in: zone).should be_kind_of(Time)
+    end
+
+    # The result also should be a Time or Time-like object (not necessary to be the same class)
+    # or Integer. The zone of the result is just ignored.
+    describe "returned value by #utc_to_local and #local_to_utc methods" do
+      it "could be Time instance" do
         zone = Object.new
-        def zone.local_to_utc(time)
-          time
+        def zone.utc_to_local(t)
+          time = Time.new(t.year, t.mon, t.day, t.hour, t.min, t.sec, t.utc_offset)
+          time + 60 * 60 # + 1 hour
         end
 
-        -> {
-          Time.now(in: zone)
-        }.should raise_error(TypeError, /can't convert Object into an exact number/)
+        Time.now(in: zone).should be_kind_of(Time)
+        Time.now(in: zone).utc_offset.should == 3600
       end
 
-      it "does not raise exception if timezone does not implement #local_to_utc method" do
+      it "could be Time subclass instance" do
         zone = Object.new
-        def zone.utc_to_local(time)
-          time
+        def zone.utc_to_local(t)
+          time = Time.new(t.year, t.mon, t.day, t.hour, t.min, t.sec, t.utc_offset)
+          time += 60 * 60 # + 1 hour
+
+          Class.new(Time).new(time.year, time.mon, time.day, time.hour, time.min, time.sec, time.utc_offset)
         end
 
         Time.now(in: zone).should be_kind_of(Time)
+        Time.now(in: zone).utc_offset.should == 3600
       end
 
-      # The result also should be a Time or Time-like object (not necessary to be the same class)
-      # or Integer. The zone of the result is just ignored.
-      describe "returned value by #utc_to_local and #local_to_utc methods" do
-        it "could be Time instance" do
-          zone = Object.new
-          def zone.utc_to_local(t)
-            time = Time.new(t.year, t.mon, t.day, t.hour, t.min, t.sec, t.utc_offset)
-            time + 60 * 60 # + 1 hour
-          end
-
-          Time.now(in: zone).should be_kind_of(Time)
-          Time.now(in: zone).utc_offset.should == 3600
+      it "could be Integer" do
+        zone = Object.new
+        def zone.utc_to_local(time)
+          time.to_i + 60*60
         end
 
-        it "could be Time subclass instance" do
-          zone = Object.new
-          def zone.utc_to_local(t)
-            time = Time.new(t.year, t.mon, t.day, t.hour, t.min, t.sec, t.utc_offset)
-            time += 60 * 60 # + 1 hour
-
-            Class.new(Time).new(time.year, time.mon, time.day, time.hour, time.min, time.sec, time.utc_offset)
-          end
+        Time.now(in: zone).should be_kind_of(Time)
+        Time.now(in: zone).utc_offset.should == 60*60
+      end
 
-          Time.now(in: zone).should be_kind_of(Time)
-          Time.now(in: zone).utc_offset.should == 3600
+      it "could have any #zone and #utc_offset because they are ignored" do
+        zone = Object.new
+        def zone.utc_to_local(t)
+          Struct.new(:year, :mon, :mday, :hour, :min, :sec, :isdst, :to_i, :zone, :utc_offset) # rubocop:disable Lint/StructNewOverride
+                .new(t.year, t.mon, t.mday, t.hour, t.min, t.sec, t.isdst, t.to_i, 'America/New_York', -5*60*60)
         end
+        Time.now(in: zone).utc_offset.should == 0
 
-        it "could be Integer" do
-          zone = Object.new
-          def zone.utc_to_local(time)
-            time.to_i + 60*60
-          end
-
-          Time.now(in: zone).should be_kind_of(Time)
-          Time.now(in: zone).utc_offset.should == 60*60
+        zone = Object.new
+        def zone.utc_to_local(t)
+          Struct.new(:year, :mon, :mday, :hour, :min, :sec, :isdst, :to_i, :zone, :utc_offset) # rubocop:disable Lint/StructNewOverride
+                .new(t.year, t.mon, t.mday, t.hour, t.min, t.sec, t.isdst, t.to_i, 'Asia/Tokyo', 9*60*60)
         end
+        Time.now(in: zone).utc_offset.should == 0
 
-        it "could have any #zone and #utc_offset because they are ignored" do
-          zone = Object.new
-          def zone.utc_to_local(t)
-            Struct.new(:year, :mon, :mday, :hour, :min, :sec, :isdst, :to_i, :zone, :utc_offset) # rubocop:disable Lint/StructNewOverride
-                  .new(t.year, t.mon, t.mday, t.hour, t.min, t.sec, t.isdst, t.to_i, 'America/New_York', -5*60*60)
-          end
-          Time.now(in: zone).utc_offset.should == 0
-
-          zone = Object.new
-          def zone.utc_to_local(t)
-            Struct.new(:year, :mon, :mday, :hour, :min, :sec, :isdst, :to_i, :zone, :utc_offset) # rubocop:disable Lint/StructNewOverride
-                  .new(t.year, t.mon, t.mday, t.hour, t.min, t.sec, t.isdst, t.to_i, 'Asia/Tokyo', 9*60*60)
-          end
-          Time.now(in: zone).utc_offset.should == 0
-
-          zone = Object.new
-          def zone.utc_to_local(t)
-            Time.new(t.year, t.mon, t.mday, t.hour, t.min, t.sec, 9*60*60)
-          end
-          Time.now(in: zone).utc_offset.should == 0
+        zone = Object.new
+        def zone.utc_to_local(t)
+          Time.new(t.year, t.mon, t.mday, t.hour, t.min, t.sec, 9*60*60)
         end
+        Time.now(in: zone).utc_offset.should == 0
+      end
 
-        it "raises ArgumentError if difference between argument and result is too large" do
-          zone = Object.new
-          def zone.utc_to_local(t)
-            time = Time.utc(t.year, t.mon, t.day, t.hour, t.min, t.sec, t.utc_offset)
-            time -= 24 * 60 * 60 # - 1 day
-            Time.utc(time.year, time.mon, time.day, time.hour, time.min, time.sec, time.utc_offset)
-          end
-
-          -> {
-            Time.now(in: zone)
-          }.should raise_error(ArgumentError, "utc_offset out of range")
+      it "raises ArgumentError if difference between argument and result is too large" do
+        zone = Object.new
+        def zone.utc_to_local(t)
+          time = Time.utc(t.year, t.mon, t.day, t.hour, t.min, t.sec, t.utc_offset)
+          time -= 24 * 60 * 60 # - 1 day
+          Time.utc(time.year, time.mon, time.day, time.hour, time.min, time.sec, time.utc_offset)
         end
+
+        -> {
+          Time.now(in: zone)
+        }.should raise_error(ArgumentError, "utc_offset out of range")
       end
     end
   end
diff --git a/spec/ruby/core/tracepoint/enable_spec.rb b/spec/ruby/core/tracepoint/enable_spec.rb
index 6cc8bb3897..93a6b281e3 100644
--- a/spec/ruby/core/tracepoint/enable_spec.rb
+++ b/spec/ruby/core/tracepoint/enable_spec.rb
@@ -57,50 +57,25 @@ describe 'TracePoint#enable' do
       end.enable { event_name.should equal(:line) }
     end
 
-    ruby_version_is '3.2' do
-      it 'enables the trace object only for the current thread' do
-        threads = []
-        trace = TracePoint.new(:line) do |tp|
-          # Runs on purpose on any Thread
-          threads << Thread.current
-        end
-
-        thread = nil
-        trace.enable do
-          line_event = true
-          thread = Thread.new do
-            event_in_other_thread = true
-          end
-          thread.join
-        end
-
-        threads = threads.uniq
-        threads.should.include?(Thread.current)
-        threads.should_not.include?(thread)
+    it 'enables the trace object only for the current thread' do
+      threads = []
+      trace = TracePoint.new(:line) do |tp|
+        # Runs on purpose on any Thread
+        threads << Thread.current
       end
-    end
 
-    ruby_version_is ''...'3.2' do
-      it 'enables the trace object for any thread' do
-        threads = []
-        trace = TracePoint.new(:line) do |tp|
-          # Runs on purpose on any Thread
-          threads << Thread.current
-        end
-
-        thread = nil
-        trace.enable do
-          line_event = true
-          thread = Thread.new do
-            event_in_other_thread = true
-          end
-          thread.join
+      thread = nil
+      trace.enable do
+        line_event = true
+        thread = Thread.new do
+          event_in_other_thread = true
         end
-
-        threads = threads.uniq
-        threads.should.include?(Thread.current)
-        threads.should.include?(thread)
+        thread.join
       end
+
+      threads = threads.uniq
+      threads.should.include?(Thread.current)
+      threads.should_not.include?(thread)
     end
 
     it 'can accept arguments within a block but it should not yield arguments' do
diff --git a/spec/ruby/core/unboundmethod/equal_value_spec.rb b/spec/ruby/core/unboundmethod/equal_value_spec.rb
index 036c6b7f8c..4d4fc66504 100644
--- a/spec/ruby/core/unboundmethod/equal_value_spec.rb
+++ b/spec/ruby/core/unboundmethod/equal_value_spec.rb
@@ -76,38 +76,19 @@ describe "UnboundMethod#==" do
     (@identical_body == @original_body).should == false
   end
 
-  ruby_version_is ""..."3.2" do
-    it "returns false if same method but one extracted from a subclass" do
-      (@parent == @child1).should == false
-      (@child1 == @parent).should == false
-    end
-
-    it "returns false if same method but extracted from two different subclasses" do
-      (@child2 == @child1).should == false
-      (@child1 == @child2).should == false
-    end
-
-    it "returns false if methods are the same but added from an included Module" do
-      (@includee == @includer).should == false
-      (@includer == @includee).should == false
-    end
+  it "returns true if same method but one extracted from a subclass" do
+    (@parent == @child1).should == true
+    (@child1 == @parent).should == true
   end
 
-  ruby_version_is "3.2" do
-    it "returns true if same method but one extracted from a subclass" do
-      (@parent == @child1).should == true
-      (@child1 == @parent).should == true
-    end
-
-    it "returns false if same method but extracted from two different subclasses" do
-      (@child2 == @child1).should == true
-      (@child1 == @child2).should == true
-    end
+  it "returns false if same method but extracted from two different subclasses" do
+    (@child2 == @child1).should == true
+    (@child1 == @child2).should == true
+  end
 
-    it "returns true if methods are the same but added from an included Module" do
-      (@includee == @includer).should == true
-      (@includer == @includee).should == true
-    end
+  it "returns true if methods are the same but added from an included Module" do
+    (@includee == @includer).should == true
+    (@includer == @includee).should == true
   end
 
   it "returns false if both have same Module, same name, identical body but not the same" do
diff --git a/spec/ruby/core/unboundmethod/owner_spec.rb b/spec/ruby/core/unboundmethod/owner_spec.rb
index e8a734dac4..b099c56de1 100644
--- a/spec/ruby/core/unboundmethod/owner_spec.rb
+++ b/spec/ruby/core/unboundmethod/owner_spec.rb
@@ -25,9 +25,7 @@ describe "UnboundMethod#owner" do
     child_singleton_class.instance_method(:another_class_method).owner.should == child_singleton_class
   end
 
-  ruby_version_is "3.2" do
-    it "returns the class on which public was called for a private method in ancestor" do
-      MethodSpecs::InheritedMethods::C.instance_method(:derp).owner.should == MethodSpecs::InheritedMethods::C
-    end
+  it "returns the class on which public was called for a private method in ancestor" do
+    MethodSpecs::InheritedMethods::C.instance_method(:derp).owner.should == MethodSpecs::InheritedMethods::C
   end
 end
diff --git a/spec/ruby/core/unboundmethod/private_spec.rb b/spec/ruby/core/unboundmethod/private_spec.rb
index 9a890db6fd..5a563939d1 100644
--- a/spec/ruby/core/unboundmethod/private_spec.rb
+++ b/spec/ruby/core/unboundmethod/private_spec.rb
@@ -2,27 +2,8 @@ require_relative '../../spec_helper'
 require_relative 'fixtures/classes'
 
 describe "UnboundMethod#private?" do
-  ruby_version_is ""..."3.2" do
-    it "returns false when the method is public" do
-      obj = UnboundMethodSpecs::Methods.new
-      obj.method(:my_public_method).unbind.private?.should == false
-    end
-
-    it "returns false when the method is protected" do
-      obj = UnboundMethodSpecs::Methods.new
-      obj.method(:my_protected_method).unbind.private?.should == false
-    end
-
-    it "returns true when the method is private" do
-      obj = UnboundMethodSpecs::Methods.new
-      obj.method(:my_private_method).unbind.private?.should == true
-    end
-  end
-
-  ruby_version_is "3.2" do
-    it "has been removed" do
-      obj = UnboundMethodSpecs::Methods.new
-      obj.method(:my_private_method).unbind.should_not.respond_to?(:private?)
-    end
+  it "has been removed" do
+    obj = UnboundMethodSpecs::Methods.new
+    obj.method(:my_private_method).unbind.should_not.respond_to?(:private?)
   end
 end
diff --git a/spec/ruby/core/unboundmethod/protected_spec.rb b/spec/ruby/core/unboundmethod/protected_spec.rb
index b79e2da63b..70622d658d 100644
--- a/spec/ruby/core/unboundmethod/protected_spec.rb
+++ b/spec/ruby/core/unboundmethod/protected_spec.rb
@@ -2,27 +2,8 @@ require_relative '../../spec_helper'
 require_relative 'fixtures/classes'
 
 describe "UnboundMethod#protected?" do
-  ruby_version_is ""..."3.2" do
-    it "returns false when the method is public" do
-      obj = UnboundMethodSpecs::Methods.new
-      obj.method(:my_public_method).unbind.protected?.should == false
-    end
-
-    it "returns true when the method is protected" do
-      obj = UnboundMethodSpecs::Methods.new
-      obj.method(:my_protected_method).unbind.protected?.should == true
-    end
-
-    it "returns false when the method is private" do
-      obj = UnboundMethodSpecs::Methods.new
-      obj.method(:my_private_method).unbind.protected?.should == false
-    end
-  end
-
-  ruby_version_is "3.2" do
-    it "has been removed" do
-      obj = UnboundMethodSpecs::Methods.new
-      obj.method(:my_protected_method).unbind.should_not.respond_to?(:protected?)
-    end
+  it "has been removed" do
+    obj = UnboundMethodSpecs::Methods.new
+    obj.method(:my_protected_method).unbind.should_not.respond_to?(:protected?)
   end
 end
diff --git a/spec/ruby/core/unboundmethod/public_spec.rb b/spec/ruby/core/unboundmethod/public_spec.rb
index c2a2795a84..ae75e2601c 100644
--- a/spec/ruby/core/unboundmethod/public_spec.rb
+++ b/spec/ruby/core/unboundmethod/public_spec.rb
@@ -2,27 +2,8 @@ require_relative '../../spec_helper'
 require_relative 'fixtures/classes'
 
 describe "UnboundMethod#public?" do
-  ruby_version_is ""..."3.2" do
-    it "returns true when the method is public" do
-      obj = UnboundMethodSpecs::Methods.new
-      obj.method(:my_public_method).unbind.public?.should == true
-    end
-
-    it "returns false when the method is protected" do
-      obj = UnboundMethodSpecs::Methods.new
-      obj.method(:my_protected_method).unbind.public?.should == false
-    end
-
-    it "returns false when the method is private" do
-      obj = UnboundMethodSpecs::Methods.new
-      obj.method(:my_private_method).unbind.public?.should == false
-    end
-  end
-
-  ruby_version_is "3.2" do
-    it "has been removed" do
-      obj = UnboundMethodSpecs::Methods.new
-      obj.method(:my_public_method).unbind.should_not.respond_to?(:public?)
-    end
+  it "has been removed" do
+    obj = UnboundMethodSpecs::Methods.new
+    obj.method(:my_public_method).unbind.should_not.respond_to?(:public?)
   end
 end
diff --git a/spec/ruby/core/unboundmethod/shared/to_s.rb b/spec/ruby/core/unboundmethod/shared/to_s.rb
index b92bb0b207..6b2c9c3e79 100644
--- a/spec/ruby/core/unboundmethod/shared/to_s.rb
+++ b/spec/ruby/core/unboundmethod/shared/to_s.rb
@@ -20,22 +20,11 @@ describe :unboundmethod_to_s, shared: true do
   it "the String shows the method name, Module defined in and Module extracted from" do
     @from_module.send(@method).should =~ /\bfrom_mod\b/
     @from_module.send(@method).should =~ /\bUnboundMethodSpecs::Mod\b/
-
-    ruby_version_is ""..."3.2" do
-      @from_method.send(@method).should =~ /\bUnboundMethodSpecs::Methods\b/
-    end
   end
 
   it "returns a String including all details" do
-    ruby_version_is ""..."3.2" do
-      @from_module.send(@method).should.start_with? "#<UnboundMethod: UnboundMethodSpecs::Methods(UnboundMethodSpecs::Mod)#from_mod"
-      @from_method.send(@method).should.start_with? "#<UnboundMethod: UnboundMethodSpecs::Methods(UnboundMethodSpecs::Mod)#from_mod"
-    end
-
-    ruby_version_is "3.2" do
-      @from_module.send(@method).should.start_with? "#<UnboundMethod: UnboundMethodSpecs::Mod#from_mod"
-      @from_method.send(@method).should.start_with? "#<UnboundMethod: UnboundMethodSpecs::Mod#from_mod"
-    end
+    @from_module.send(@method).should.start_with? "#<UnboundMethod: UnboundMethodSpecs::Mod#from_mod"
+    @from_method.send(@method).should.start_with? "#<UnboundMethod: UnboundMethodSpecs::Mod#from_mod"
   end
 
   it "does not show the defining module if it is the same as the origin" do