16 files changed, 184 insertions, 500 deletions

diff --git a/spec/ruby/core/module/autoload_spec.rb b/spec/ruby/core/module/autoload_spec.rb
index 45d18b8608..3cdc48f9ba 100644
--- a/spec/ruby/core/module/autoload_spec.rb
+++ b/spec/ruby/core/module/autoload_spec.rb
@@ -486,42 +486,21 @@ describe "Module#autoload" do
     ScratchPad.recorded.should == [:raise, :raise]
   end
 
-  ruby_version_is "3.1" do
-    it "removes the constant from Module#constants if the loaded file does not define it" do
-      path = fixture(__FILE__, "autoload_o.rb")
-      ScratchPad.record []
-      ModuleSpecs::Autoload.autoload :O, path
-
-      ModuleSpecs::Autoload.const_defined?(:O).should == true
-      ModuleSpecs::Autoload.should have_constant(:O)
-      ModuleSpecs::Autoload.autoload?(:O).should == path
-
-      -> { ModuleSpecs::Autoload::O }.should raise_error(NameError)
-
-      ModuleSpecs::Autoload.const_defined?(:O).should == false
-      ModuleSpecs::Autoload.should_not have_constant(:O)
-      ModuleSpecs::Autoload.autoload?(:O).should == nil
-      -> { ModuleSpecs::Autoload.const_get(:O) }.should raise_error(NameError)
-    end
-  end
-
-  ruby_version_is ""..."3.1" do
-    it "does not remove the constant from Module#constants if the loaded file does not define it, but leaves it as 'undefined'" do
-      path = fixture(__FILE__, "autoload_o.rb")
-      ScratchPad.record []
-      ModuleSpecs::Autoload.autoload :O, path
+  it "removes the constant from Module#constants if the loaded file does not define it" do
+    path = fixture(__FILE__, "autoload_o.rb")
+    ScratchPad.record []
+    ModuleSpecs::Autoload.autoload :O, path
 
-      ModuleSpecs::Autoload.const_defined?(:O).should == true
-      ModuleSpecs::Autoload.should have_constant(:O)
-      ModuleSpecs::Autoload.autoload?(:O).should == path
+    ModuleSpecs::Autoload.const_defined?(:O).should == true
+    ModuleSpecs::Autoload.should have_constant(:O)
+    ModuleSpecs::Autoload.autoload?(:O).should == path
 
-      -> { ModuleSpecs::Autoload::O }.should raise_error(NameError)
+    -> { ModuleSpecs::Autoload::O }.should raise_error(NameError)
 
-      ModuleSpecs::Autoload.const_defined?(:O).should == false
-      ModuleSpecs::Autoload.should have_constant(:O)
-      ModuleSpecs::Autoload.autoload?(:O).should == nil
-      -> { ModuleSpecs::Autoload.const_get(:O) }.should raise_error(NameError)
-    end
+    ModuleSpecs::Autoload.const_defined?(:O).should == false
+    ModuleSpecs::Autoload.should_not have_constant(:O)
+    ModuleSpecs::Autoload.autoload?(:O).should == nil
+    -> { ModuleSpecs::Autoload.const_get(:O) }.should raise_error(NameError)
   end
 
   it "does not try to load the file again if the loaded file did not define the constant" do
@@ -654,48 +633,23 @@ describe "Module#autoload" do
       end
     end
 
-    ruby_version_is "3.1" do
-      it "looks up in parent scope after failed autoload" do
-        @remove << :DeclaredInCurrentDefinedInParent
-        module ModuleSpecs::Autoload
-          ScratchPad.record -> {
-            DeclaredInCurrentDefinedInParent = :declared_in_current_defined_in_parent
-          }
-
-          class LexicalScope
-            autoload :DeclaredInCurrentDefinedInParent, fixture(__FILE__, "autoload_callback.rb")
-            -> { DeclaredInCurrentDefinedInParent }.should_not raise_error(NameError)
-            # Basically, the autoload constant remains in a "undefined" state
-            self.autoload?(:DeclaredInCurrentDefinedInParent).should == nil
-            const_defined?(:DeclaredInCurrentDefinedInParent).should == false
-            -> { const_get(:DeclaredInCurrentDefinedInParent) }.should raise_error(NameError)
-          end
+    it "looks up in parent scope after failed autoload" do
+      @remove << :DeclaredInCurrentDefinedInParent
+      module ModuleSpecs::Autoload
+        ScratchPad.record -> {
+          DeclaredInCurrentDefinedInParent = :declared_in_current_defined_in_parent
+        }
 
-          DeclaredInCurrentDefinedInParent.should == :declared_in_current_defined_in_parent
+        class LexicalScope
+          autoload :DeclaredInCurrentDefinedInParent, fixture(__FILE__, "autoload_callback.rb")
+          -> { DeclaredInCurrentDefinedInParent }.should_not raise_error(NameError)
+          # Basically, the autoload constant remains in a "undefined" state
+          self.autoload?(:DeclaredInCurrentDefinedInParent).should == nil
+          const_defined?(:DeclaredInCurrentDefinedInParent).should == false
+          -> { const_get(:DeclaredInCurrentDefinedInParent) }.should raise_error(NameError)
         end
-      end
-    end
-
-    ruby_version_is ""..."3.1" do
-      it "and fails when finding the undefined autoload constant in the current scope when declared in current and defined in parent" do
-        @remove << :DeclaredInCurrentDefinedInParent
-        module ModuleSpecs::Autoload
-          ScratchPad.record -> {
-            DeclaredInCurrentDefinedInParent = :declared_in_current_defined_in_parent
-          }
 
-          class LexicalScope
-            autoload :DeclaredInCurrentDefinedInParent, fixture(__FILE__, "autoload_callback.rb")
-            -> { DeclaredInCurrentDefinedInParent }.should raise_error(NameError)
-            # Basically, the autoload constant remains in a "undefined" state
-            self.autoload?(:DeclaredInCurrentDefinedInParent).should == nil
-            const_defined?(:DeclaredInCurrentDefinedInParent).should == false
-            self.should have_constant(:DeclaredInCurrentDefinedInParent)
-            -> { const_get(:DeclaredInCurrentDefinedInParent) }.should raise_error(NameError)
-          end
-
-          DeclaredInCurrentDefinedInParent.should == :declared_in_current_defined_in_parent
-        end
+        DeclaredInCurrentDefinedInParent.should == :declared_in_current_defined_in_parent
       end
     end
 
diff --git a/spec/ruby/core/module/const_defined_spec.rb b/spec/ruby/core/module/const_defined_spec.rb
index 027cf5a245..8b137cd134 100644
--- a/spec/ruby/core/module/const_defined_spec.rb
+++ b/spec/ruby/core/module/const_defined_spec.rb
@@ -65,6 +65,8 @@ describe "Module#const_defined?" do
     str = "CS_CONSTλ".encode("euc-jp")
     ConstantSpecs.const_set str, 1
     ConstantSpecs.const_defined?(str).should be_true
+  ensure
+    ConstantSpecs.send(:remove_const, str)
   end
 
   it "returns false if the constant is not defined in the receiver, its superclass, or any included modules" do
diff --git a/spec/ruby/core/module/const_get_spec.rb b/spec/ruby/core/module/const_get_spec.rb
index 0233118f4b..4b53cbe7b3 100644
--- a/spec/ruby/core/module/const_get_spec.rb
+++ b/spec/ruby/core/module/const_get_spec.rb
@@ -131,7 +131,7 @@ describe "Module#const_get" do
   end
 
   it "does read private constants" do
-     ConstantSpecs.const_get(:CS_PRIVATE).should == :cs_private
+    ConstantSpecs.const_get(:CS_PRIVATE).should == :cs_private
   end
 
   it 'does autoload a constant' do
@@ -202,40 +202,60 @@ describe "Module#const_get" do
 
       ConstantSpecs::ContainerA::ChildA::CS_CONST301 = :const301_5
       ConstantSpecs::ContainerA::ChildA.const_get(:CS_CONST301).should == :const301_5
+    ensure
+      ConstantSpecs::ClassA.send(:remove_const, :CS_CONST301)
+      ConstantSpecs::ModuleA.send(:remove_const, :CS_CONST301)
+      ConstantSpecs::ParentA.send(:remove_const, :CS_CONST301)
+      ConstantSpecs::ContainerA::ChildA.send(:remove_const, :CS_CONST301)
     end
 
     it "searches a module included in the immediate class before the superclass" do
       ConstantSpecs::ParentB::CS_CONST302 = :const302_1
       ConstantSpecs::ModuleF::CS_CONST302 = :const302_2
       ConstantSpecs::ContainerB::ChildB.const_get(:CS_CONST302).should == :const302_2
+    ensure
+      ConstantSpecs::ParentB.send(:remove_const, :CS_CONST302)
+      ConstantSpecs::ModuleF.send(:remove_const, :CS_CONST302)
     end
 
     it "searches the superclass before a module included in the superclass" do
       ConstantSpecs::ModuleE::CS_CONST303 = :const303_1
       ConstantSpecs::ParentB::CS_CONST303 = :const303_2
       ConstantSpecs::ContainerB::ChildB.const_get(:CS_CONST303).should == :const303_2
+    ensure
+      ConstantSpecs::ModuleE.send(:remove_const, :CS_CONST303)
+      ConstantSpecs::ParentB.send(:remove_const, :CS_CONST303)
     end
 
     it "searches a module included in the superclass" do
       ConstantSpecs::ModuleA::CS_CONST304 = :const304_1
       ConstantSpecs::ModuleE::CS_CONST304 = :const304_2
       ConstantSpecs::ContainerB::ChildB.const_get(:CS_CONST304).should == :const304_2
+    ensure
+      ConstantSpecs::ModuleA.send(:remove_const, :CS_CONST304)
+      ConstantSpecs::ModuleE.send(:remove_const, :CS_CONST304)
     end
 
     it "searches the superclass chain" do
       ConstantSpecs::ModuleA::CS_CONST305 = :const305
       ConstantSpecs::ContainerB::ChildB.const_get(:CS_CONST305).should == :const305
+    ensure
+      ConstantSpecs::ModuleA.send(:remove_const, :CS_CONST305)
     end
 
     it "returns a toplevel constant when the receiver is a Class" do
       Object::CS_CONST306 = :const306
       ConstantSpecs::ContainerB::ChildB.const_get(:CS_CONST306).should == :const306
+    ensure
+      Object.send(:remove_const, :CS_CONST306)
     end
 
     it "returns a toplevel constant when the receiver is a Module" do
       Object::CS_CONST308 = :const308
       ConstantSpecs.const_get(:CS_CONST308).should == :const308
       ConstantSpecs::ModuleA.const_get(:CS_CONST308).should == :const308
+    ensure
+      Object.send(:remove_const, :CS_CONST308)
     end
 
     it "returns the updated value of a constant" do
@@ -246,6 +266,8 @@ describe "Module#const_get" do
         ConstantSpecs::ClassB::CS_CONST309 = :const309_2
       }.should complain(/already initialized constant/)
       ConstantSpecs::ClassB.const_get(:CS_CONST309).should == :const309_2
+    ensure
+      ConstantSpecs::ClassB.send(:remove_const, :CS_CONST309)
     end
   end
 end
diff --git a/spec/ruby/core/module/const_set_spec.rb b/spec/ruby/core/module/const_set_spec.rb
index 5bdfd7b68f..823768b882 100644
--- a/spec/ruby/core/module/const_set_spec.rb
+++ b/spec/ruby/core/module/const_set_spec.rb
@@ -8,16 +8,23 @@ describe "Module#const_set" do
 
     ConstantSpecs.const_set "CS_CONST402", :const402
     ConstantSpecs.const_get(:CS_CONST402).should == :const402
+  ensure
+    ConstantSpecs.send(:remove_const, :CS_CONST401)
+    ConstantSpecs.send(:remove_const, :CS_CONST402)
   end
 
   it "returns the value set" do
     ConstantSpecs.const_set(:CS_CONST403, :const403).should == :const403
+  ensure
+    ConstantSpecs.send(:remove_const, :CS_CONST403)
   end
 
   it "sets the name of an anonymous module" do
     m = Module.new
     ConstantSpecs.const_set(:CS_CONST1000, m)
     m.name.should == "ConstantSpecs::CS_CONST1000"
+  ensure
+    ConstantSpecs.send(:remove_const, :CS_CONST1000)
   end
 
   it "sets the name of a module scoped by an anonymous module" do
@@ -38,6 +45,8 @@ describe "Module#const_set" do
     b.name.should == "ModuleSpecs_CS3::B"
     c.name.should == "ModuleSpecs_CS3::B::C"
     d.name.should == "ModuleSpecs_CS3::D"
+  ensure
+    Object.send(:remove_const, :ModuleSpecs_CS3)
   end
 
   it "raises a NameError if the name does not start with a capital letter" do
@@ -55,6 +64,8 @@ describe "Module#const_set" do
     ConstantSpecs.const_set("CS_CONST404", :const404).should == :const404
     -> { ConstantSpecs.const_set "Name=", 1 }.should raise_error(NameError)
     -> { ConstantSpecs.const_set "Name?", 1 }.should raise_error(NameError)
+  ensure
+    ConstantSpecs.send(:remove_const, :CS_CONST404)
   end
 
   it "calls #to_str to convert the given name to a String" do
@@ -62,6 +73,8 @@ describe "Module#const_set" do
     name.should_receive(:to_str).and_return("CS_CONST405")
     ConstantSpecs.const_set(name, :const405).should == :const405
     ConstantSpecs::CS_CONST405.should == :const405
+  ensure
+    ConstantSpecs.send(:remove_const, :CS_CONST405)
   end
 
   it "raises a TypeError if conversion to a String by calling #to_str fails" do
diff --git a/spec/ruby/core/module/const_source_location_spec.rb b/spec/ruby/core/module/const_source_location_spec.rb
index c194c9113f..06b3b215c2 100644
--- a/spec/ruby/core/module/const_source_location_spec.rb
+++ b/spec/ruby/core/module/const_source_location_spec.rb
@@ -19,40 +19,60 @@ describe "Module#const_source_location" do
 
       ConstantSpecs::ContainerA::ChildA::CSL_CONST301 = :const301_5
       ConstantSpecs::ContainerA::ChildA.const_source_location(:CSL_CONST301).should == [__FILE__, __LINE__ - 1]
+    ensure
+      ConstantSpecs::ClassA.send(:remove_const, :CSL_CONST301)
+      ConstantSpecs::ModuleA.send(:remove_const, :CSL_CONST301)
+      ConstantSpecs::ParentA.send(:remove_const, :CSL_CONST301)
+      ConstantSpecs::ContainerA::ChildA.send(:remove_const, :CSL_CONST301)
     end
 
     it "searches a path in a module included in the immediate class before the superclass" do
       ConstantSpecs::ParentB::CSL_CONST302 = :const302_1
       ConstantSpecs::ModuleF::CSL_CONST302 = :const302_2
       ConstantSpecs::ContainerB::ChildB.const_source_location(:CSL_CONST302).should == [__FILE__, __LINE__ - 1]
+    ensure
+      ConstantSpecs::ParentB.send(:remove_const, :CSL_CONST302)
+      ConstantSpecs::ModuleF.send(:remove_const, :CSL_CONST302)
     end
 
     it "searches a path in the superclass before a module included in the superclass" do
       ConstantSpecs::ModuleE::CSL_CONST303 = :const303_1
       ConstantSpecs::ParentB::CSL_CONST303 = :const303_2
       ConstantSpecs::ContainerB::ChildB.const_source_location(:CSL_CONST303).should == [__FILE__, __LINE__ - 1]
+    ensure
+      ConstantSpecs::ModuleE.send(:remove_const, :CSL_CONST303)
+      ConstantSpecs::ParentB.send(:remove_const, :CSL_CONST303)
     end
 
     it "searches a path in a module included in the superclass" do
       ConstantSpecs::ModuleA::CSL_CONST304 = :const304_1
       ConstantSpecs::ModuleE::CSL_CONST304 = :const304_2
       ConstantSpecs::ContainerB::ChildB.const_source_location(:CSL_CONST304).should == [__FILE__, __LINE__ - 1]
+    ensure
+      ConstantSpecs::ModuleA.send(:remove_const, :CSL_CONST304)
+      ConstantSpecs::ModuleE.send(:remove_const, :CSL_CONST304)
     end
 
     it "searches a path in the superclass chain" do
       ConstantSpecs::ModuleA::CSL_CONST305 = :const305
       ConstantSpecs::ContainerB::ChildB.const_source_location(:CSL_CONST305).should == [__FILE__, __LINE__ - 1]
+    ensure
+      ConstantSpecs::ModuleA.send(:remove_const, :CSL_CONST305)
     end
 
     it "returns path to a toplevel constant when the receiver is a Class" do
       Object::CSL_CONST306 = :const306
       ConstantSpecs::ContainerB::ChildB.const_source_location(:CSL_CONST306).should == [__FILE__, __LINE__ - 1]
+    ensure
+      Object.send(:remove_const, :CSL_CONST306)
     end
 
     it "returns path to a toplevel constant when the receiver is a Module" do
       Object::CSL_CONST308 = :const308
       ConstantSpecs.const_source_location(:CSL_CONST308).should == [__FILE__, __LINE__ - 1]
       ConstantSpecs::ModuleA.const_source_location(:CSL_CONST308).should == [__FILE__, __LINE__ - 2]
+    ensure
+      Object.send(:remove_const, :CSL_CONST308)
     end
 
     it "returns path to the updated value of a constant" do
@@ -63,6 +83,8 @@ describe "Module#const_source_location" do
         ConstantSpecs::ClassB::CSL_CONST309 = :const309_2
       }.should complain(/already initialized constant/)
       ConstantSpecs::ClassB.const_source_location(:CSL_CONST309).should == [__FILE__, __LINE__ - 2]
+    ensure
+      ConstantSpecs::ClassB.send(:remove_const, :CSL_CONST309)
     end
   end
 
@@ -207,7 +229,7 @@ describe "Module#const_source_location" do
   end
 
   it "does search private constants path" do
-     ConstantSpecs.const_source_location(:CS_PRIVATE).should == [@constants_fixture_path, ConstantSpecs::CS_PRIVATE_LINE]
+    ConstantSpecs.const_source_location(:CS_PRIVATE).should == [@constants_fixture_path, ConstantSpecs::CS_PRIVATE_LINE]
   end
 
   it "works for eval with a given line" do
diff --git a/spec/ruby/core/module/define_method_spec.rb b/spec/ruby/core/module/define_method_spec.rb
index e04bb87ceb..c5dfc53764 100644
--- a/spec/ruby/core/module/define_method_spec.rb
+++ b/spec/ruby/core/module/define_method_spec.rb
@@ -476,6 +476,9 @@ describe "Module#define_method" do
       ChildClass = Class.new(ParentClass) { define_method(:foo) { :baz } }
       ParentClass.send :define_method, :foo, ChildClass.instance_method(:foo)
     }.should raise_error(TypeError, /bind argument must be a subclass of ChildClass/)
+  ensure
+    Object.send(:remove_const, :ParentClass)
+    Object.send(:remove_const, :ChildClass)
   end
 
   it "raises a TypeError when an UnboundMethod from one class is defined on an unrelated class" do
diff --git a/spec/ruby/core/module/include_spec.rb b/spec/ruby/core/module/include_spec.rb
index 862c6976e1..a1bfd3a6f5 100644
--- a/spec/ruby/core/module/include_spec.rb
+++ b/spec/ruby/core/module/include_spec.rb
@@ -44,7 +44,11 @@ describe "Module#include" do
   end
 
   it "does not raise a TypeError when the argument is an instance of a subclass of Module" do
-    -> { ModuleSpecs::SubclassSpec.include(ModuleSpecs::Subclass.new) }.should_not raise_error(TypeError)
+    class ModuleSpecs::SubclassSpec::AClass
+    end
+    -> { ModuleSpecs::SubclassSpec::AClass.include(ModuleSpecs::Subclass.new) }.should_not raise_error(TypeError)
+  ensure
+    ModuleSpecs::SubclassSpec.send(:remove_const, :AClass)
   end
 
   ruby_version_is ""..."3.2" do
@@ -427,6 +431,8 @@ describe "Module#include" do
       M.const_set(:FOO, 'm')
       B.foo.should == 'm'
     end
+  ensure
+    ModuleSpecs.send(:remove_const, :ConstUpdated)
   end
 
   it "updates the constant when a module included after a call is later updated" do
@@ -453,6 +459,8 @@ describe "Module#include" do
       M.const_set(:FOO, 'm')
       B.foo.should == 'm'
     end
+  ensure
+    ModuleSpecs.send(:remove_const, :ConstLaterUpdated)
   end
 
   it "updates the constant when a module included in another module after a call is later updated" do
@@ -479,6 +487,8 @@ describe "Module#include" do
       M.const_set(:FOO, 'm')
       B.foo.should == 'm'
     end
+  ensure
+    ModuleSpecs.send(:remove_const, :ConstModuleLaterUpdated)
   end
 
   it "updates the constant when a nested included module is updated" do
@@ -507,6 +517,8 @@ describe "Module#include" do
       N.const_set(:FOO, 'n')
       B.foo.should == 'n'
     end
+  ensure
+    ModuleSpecs.send(:remove_const, :ConstUpdatedNestedIncludeUpdated)
   end
 
   it "updates the constant when a new module is included" do
@@ -531,6 +543,8 @@ describe "Module#include" do
       B.include(M)
       B.foo.should == 'm'
     end
+  ensure
+    ModuleSpecs.send(:remove_const, :ConstUpdatedNewInclude)
   end
 
   it "updates the constant when a new module with nested module is included" do
@@ -559,6 +573,8 @@ describe "Module#include" do
       B.include M
       B.foo.should == 'n'
     end
+  ensure
+    ModuleSpecs.send(:remove_const, :ConstUpdatedNestedIncluded)
   end
 
   it "overrides a previous super method call" do
diff --git a/spec/ruby/core/module/module_function_spec.rb b/spec/ruby/core/module/module_function_spec.rb
index 1c3ec5471b..51f647142e 100644
--- a/spec/ruby/core/module/module_function_spec.rb
+++ b/spec/ruby/core/module/module_function_spec.rb
@@ -38,22 +38,11 @@ describe "Module#module_function with specific method names" do
     m.respond_to?(:test3).should == false
   end
 
-  ruby_version_is ""..."3.1" do
-    it "returns self" do
-      Module.new do
-        def foo; end
-        module_function(:foo).should equal(self)
-      end
-    end
-  end
-
-  ruby_version_is "3.1" do
-    it "returns argument or arguments if given" do
-      Module.new do
-        def foo; end
-        module_function(:foo).should equal(:foo)
-        module_function(:foo, :foo).should == [:foo, :foo]
-      end
+  it "returns argument or arguments if given" do
+    Module.new do
+      def foo; end
+      module_function(:foo).should equal(:foo)
+      module_function(:foo, :foo).should == [:foo, :foo]
     end
   end
 
@@ -216,19 +205,9 @@ describe "Module#module_function as a toggle (no arguments) in a Module body" do
     m.respond_to?(:test2).should == true
   end
 
-  ruby_version_is ""..."3.1" do
-    it "returns self" do
-      Module.new do
-        module_function.should equal(self)
-      end
-    end
-  end
-
-  ruby_version_is "3.1" do
-    it "returns nil" do
-      Module.new do
-        module_function.should equal(nil)
-      end
+  it "returns nil" do
+    Module.new do
+      module_function.should equal(nil)
     end
   end
 
diff --git a/spec/ruby/core/module/name_spec.rb b/spec/ruby/core/module/name_spec.rb
index 33e8400e88..b5c1f771f8 100644
--- a/spec/ruby/core/module/name_spec.rb
+++ b/spec/ruby/core/module/name_spec.rb
@@ -30,6 +30,8 @@ describe "Module#name" do
     m::N.name.should =~ /\A#<Module:0x\h+>::N\z/
     ModuleSpecs::Anonymous::WasAnnon = m::N
     m::N.name.should == "ModuleSpecs::Anonymous::WasAnnon"
+  ensure
+    ModuleSpecs::Anonymous.send(:remove_const, :WasAnnon)
   end
 
   it "may be the repeated in different module objects" do
@@ -76,12 +78,16 @@ describe "Module#name" do
     m = Module.new
     ModuleSpecs::Anonymous::A = m
     m.name.should == "ModuleSpecs::Anonymous::A"
+  ensure
+    ModuleSpecs::Anonymous.send(:remove_const, :A)
   end
 
   it "is set when assigning to a constant (constant path does not match outer module name)" do
     m = Module.new
     ModuleSpecs::Anonymous::SameChild::A = m
     m.name.should == "ModuleSpecs::Anonymous::Child::A"
+  ensure
+    ModuleSpecs::Anonymous::SameChild.send(:remove_const, :A)
   end
 
   it "is not modified when assigning to a new constant after it has been accessed" do
@@ -90,6 +96,9 @@ describe "Module#name" do
     m.name.should == "ModuleSpecs::Anonymous::B"
     ModuleSpecs::Anonymous::C = m
     m.name.should == "ModuleSpecs::Anonymous::B"
+  ensure
+    ModuleSpecs::Anonymous.send(:remove_const, :B)
+    ModuleSpecs::Anonymous.send(:remove_const, :C)
   end
 
   it "is not modified when assigned to a different anonymous module" do
@@ -125,6 +134,8 @@ describe "Module#name" do
     m::N = Module.new
     ModuleSpecs::Anonymous::E = m
     m::N.name.should == "ModuleSpecs::Anonymous::E::N"
+  ensure
+    ModuleSpecs::Anonymous.send(:remove_const, :E)
   end
 
   # https://bugs.ruby-lang.org/issues/19681
@@ -138,6 +149,8 @@ describe "Module#name" do
       "ModuleSpecs::Anonymous::StoredInMultiplePlaces::O"
     ]
     valid_names.should include(m::N.name) # You get one of the two, but you don't know which one.
+  ensure
+    ModuleSpecs::Anonymous.send(:remove_const, :StoredInMultiplePlaces)
   end
 
   ruby_version_is "3.2" do
diff --git a/spec/ruby/core/module/prepend_spec.rb b/spec/ruby/core/module/prepend_spec.rb
index b40d12f0de..9508fbf182 100644
--- a/spec/ruby/core/module/prepend_spec.rb
+++ b/spec/ruby/core/module/prepend_spec.rb
@@ -261,6 +261,8 @@ describe "Module#prepend" do
       B.prepend M
       B.foo.should == 'm'
     end
+  ensure
+    ModuleSpecs.send(:remove_const, :ConstUpdatePrepended)
   end
 
   it "updates the constant when a prepended module is updated" do
@@ -281,6 +283,8 @@ describe "Module#prepend" do
       M.const_set(:FOO, 'm')
       B.foo.should == 'm'
     end
+  ensure
+    ModuleSpecs.send(:remove_const, :ConstPrependedUpdated)
   end
 
   it "updates the constant when there is a base included constant and the prepended module overrides it" do
@@ -302,6 +306,8 @@ describe "Module#prepend" do
       A.prepend M
       A.foo.should == 'm'
     end
+  ensure
+    ModuleSpecs.send(:remove_const, :ConstIncludedPrependedOverride)
   end
 
   it "updates the constant when there is a base included constant and the prepended module is later updated" do
@@ -325,6 +331,8 @@ describe "Module#prepend" do
       M.const_set(:FOO, 'm')
       A.foo.should == 'm'
     end
+  ensure
+    ModuleSpecs.send(:remove_const, :ConstIncludedPrependedLaterUpdated)
   end
 
   it "updates the constant when a module prepended after a constant is later updated" do
@@ -348,6 +356,8 @@ describe "Module#prepend" do
       M.const_set(:FOO, 'm')
       B.foo.should == 'm'
     end
+  ensure
+    ModuleSpecs.send(:remove_const, :ConstUpdatedPrependedAfterLaterUpdated)
   end
 
   it "updates the constant when a module is prepended after another and the constant is defined later on that module" do
@@ -372,6 +382,8 @@ describe "Module#prepend" do
       N.const_set(:FOO, 'n')
       A.foo.should == 'n'
     end
+  ensure
+    ModuleSpecs.send(:remove_const, :ConstUpdatedPrependedAfterConstDefined)
   end
 
   it "updates the constant when a module is included in a prepended module and the constant is defined later" do
@@ -399,6 +411,8 @@ describe "Module#prepend" do
       N.const_set(:FOO, 'n')
       A.foo.should == 'n'
     end
+  ensure
+    ModuleSpecs.send(:remove_const, :ConstUpdatedIncludedInPrependedConstDefinedLater)
   end
 
   it "updates the constant when a new module with an included module is prepended" do
@@ -425,6 +439,8 @@ describe "Module#prepend" do
       B.prepend M
       B.foo.should == 'n'
     end
+  ensure
+    ModuleSpecs.send(:remove_const, :ConstUpdatedNewModuleIncludedPrepended)
   end
 
   it "raises a TypeError when the argument is not a Module" do
@@ -432,7 +448,11 @@ describe "Module#prepend" do
   end
 
   it "does not raise a TypeError when the argument is an instance of a subclass of Module" do
-    -> { ModuleSpecs::SubclassSpec.prepend(ModuleSpecs::Subclass.new) }.should_not raise_error(TypeError)
+    class ModuleSpecs::SubclassSpec::AClass
+    end
+    -> { ModuleSpecs::SubclassSpec::AClass.prepend(ModuleSpecs::Subclass.new) }.should_not raise_error(TypeError)
+  ensure
+    ModuleSpecs::SubclassSpec.send(:remove_const, :AClass)
   end
 
   ruby_version_is ""..."3.2" do
@@ -787,34 +807,17 @@ describe "Module#prepend" do
 
   # https://bugs.ruby-lang.org/issues/17423
   describe "when module already exists in ancestor chain" do
-    ruby_version_is ""..."3.1" do
-      it "does not modify the ancestor chain" do
-        m = Module.new do; end
-        a = Module.new do; end
-        b = Class.new do; end
-
-        b.include(a)
-        a.prepend(m)
-        b.ancestors.take(4).should == [b, m, a, Object]
+    it "modifies the ancestor chain" do
+      m = Module.new do; end
+      a = Module.new do; end
+      b = Class.new do; end
 
-        b.prepend(m)
-        b.ancestors.take(4).should == [b, m, a, Object]
-      end
-    end
+      b.include(a)
+      a.prepend(m)
+      b.ancestors.take(4).should == [b, m, a, Object]
 
-    ruby_version_is "3.1" do
-      it "modifies the ancestor chain" do
-        m = Module.new do; end
-        a = Module.new do; end
-        b = Class.new do; end
-
-        b.include(a)
-        a.prepend(m)
-        b.ancestors.take(4).should == [b, m, a, Object]
-
-        b.prepend(m)
-        b.ancestors.take(5).should == [m, b, m, a, Object]
-      end
+      b.prepend(m)
+      b.ancestors.take(5).should == [m, b, m, a, Object]
     end
   end
 
diff --git a/spec/ruby/core/module/private_spec.rb b/spec/ruby/core/module/private_spec.rb
index ead806637c..9e1a297eea 100644
--- a/spec/ruby/core/module/private_spec.rb
+++ b/spec/ruby/core/module/private_spec.rb
@@ -38,25 +38,13 @@ describe "Module#private" do
                   :module_specs_public_method_on_object_for_kernel_private)
   end
 
-  ruby_version_is ""..."3.1" do
-    it "returns self" do
-      (class << Object.new; self; end).class_eval do
-        def foo; end
-        private(:foo).should equal(self)
-        private.should equal(self)
-      end
-    end
-  end
-
-  ruby_version_is "3.1" do
-    it "returns argument or arguments if given" do
-      (class << Object.new; self; end).class_eval do
-        def foo; end
-        private(:foo).should equal(:foo)
-        private([:foo, :foo]).should == [:foo, :foo]
-        private(:foo, :foo).should == [:foo, :foo]
-        private.should equal(nil)
-      end
+  it "returns argument or arguments if given" do
+    (class << Object.new; self; end).class_eval do
+      def foo; end
+      private(:foo).should equal(:foo)
+      private([:foo, :foo]).should == [:foo, :foo]
+      private(:foo, :foo).should == [:foo, :foo]
+      private.should equal(nil)
     end
   end
 
diff --git a/spec/ruby/core/module/protected_spec.rb b/spec/ruby/core/module/protected_spec.rb
index 058d49d751..9e37223e18 100644
--- a/spec/ruby/core/module/protected_spec.rb
+++ b/spec/ruby/core/module/protected_spec.rb
@@ -39,25 +39,13 @@ describe "Module#protected" do
                   :module_specs_public_method_on_object_for_kernel_protected)
   end
 
-  ruby_version_is ""..."3.1" do
-    it "returns self" do
-      (class << Object.new; self; end).class_eval do
-        def foo; end
-        protected(:foo).should equal(self)
-        protected.should equal(self)
-      end
-    end
-  end
-
-  ruby_version_is "3.1" do
-    it "returns argument or arguments if given" do
-      (class << Object.new; self; end).class_eval do
-        def foo; end
-        protected(:foo).should equal(:foo)
-        protected([:foo, :foo]).should == [:foo, :foo]
-        protected(:foo, :foo).should == [:foo, :foo]
-        protected.should equal(nil)
-      end
+  it "returns argument or arguments if given" do
+    (class << Object.new; self; end).class_eval do
+      def foo; end
+      protected(:foo).should equal(:foo)
+      protected([:foo, :foo]).should == [:foo, :foo]
+      protected(:foo, :foo).should == [:foo, :foo]
+      protected.should equal(nil)
     end
   end
 
diff --git a/spec/ruby/core/module/public_spec.rb b/spec/ruby/core/module/public_spec.rb
index e3b183f228..ce31eb5d0e 100644
--- a/spec/ruby/core/module/public_spec.rb
+++ b/spec/ruby/core/module/public_spec.rb
@@ -27,25 +27,13 @@ describe "Module#public" do
                   :module_specs_private_method_on_object_for_kernel_public)
   end
 
-  ruby_version_is ""..."3.1" do
-    it "returns self" do
-      (class << Object.new; self; end).class_eval do
-        def foo; end
-        public(:foo).should equal(self)
-        public.should equal(self)
-      end
-    end
-  end
-
-  ruby_version_is "3.1" do
-    it "returns argument or arguments if given" do
-      (class << Object.new; self; end).class_eval do
-        def foo; end
-        public(:foo).should equal(:foo)
-        public([:foo, :foo]).should == [:foo, :foo]
-        public(:foo, :foo).should == [:foo, :foo]
-        public.should equal(nil)
-      end
+  it "returns argument or arguments if given" do
+    (class << Object.new; self; end).class_eval do
+      def foo; end
+      public(:foo).should equal(:foo)
+      public([:foo, :foo]).should == [:foo, :foo]
+      public(:foo, :foo).should == [:foo, :foo]
+      public.should equal(nil)
     end
   end
 
diff --git a/spec/ruby/core/module/refine_spec.rb b/spec/ruby/core/module/refine_spec.rb
index 8b9ea5eca8..7a5d607c4f 100644
--- a/spec/ruby/core/module/refine_spec.rb
+++ b/spec/ruby/core/module/refine_spec.rb
@@ -272,7 +272,7 @@ describe "Module#refine" do
     it "looks in later included modules of the refined module first" do
       a = Module.new do
         def foo
-         "foo from A"
+          "foo from A"
         end
       end
 
@@ -300,67 +300,6 @@ describe "Module#refine" do
       result.should == "foo from IncludeMeLater"
     end
 
-    ruby_version_is ""..."3.1" do
-      it "looks in prepended modules from the refinement first" do
-        refined_class = ModuleSpecs.build_refined_class
-
-        refinement = Module.new do
-          refine refined_class do
-            include ModuleSpecs::IncludedModule
-            prepend ModuleSpecs::PrependedModule
-
-            def foo; "foo from refinement"; end
-          end
-        end
-
-        result = nil
-        Module.new do
-          using refinement
-          result = refined_class.new.foo
-        end
-
-        result.should == "foo from prepended module"
-      end
-
-      it "looks in refinement then" do
-        refined_class = ModuleSpecs.build_refined_class
-
-        refinement = Module.new do
-          refine(refined_class) do
-            include ModuleSpecs::IncludedModule
-
-            def foo; "foo from refinement"; end
-          end
-        end
-
-        result = nil
-        Module.new do
-          using refinement
-          result = refined_class.new.foo
-        end
-
-        result.should == "foo from refinement"
-      end
-
-      it "looks in included modules from the refinement then" do
-        refined_class = ModuleSpecs.build_refined_class
-
-        refinement = Module.new do
-          refine refined_class do
-            include ModuleSpecs::IncludedModule
-          end
-        end
-
-        result = nil
-        Module.new do
-          using refinement
-          result = refined_class.new.foo
-        end
-
-        result.should == "foo from included module"
-      end
-    end
-
     it "looks in the class then" do
       refined_class = ModuleSpecs.build_refined_class
 
@@ -606,30 +545,6 @@ describe "Module#refine" do
   end
 
   context "when super is called in a refinement" do
-    ruby_version_is ""..."3.1" do
-      it "looks in the included to refinery module" do
-        refined_class = ModuleSpecs.build_refined_class
-
-        refinement = Module.new do
-          refine refined_class do
-            include ModuleSpecs::IncludedModule
-
-            def foo
-              super
-            end
-          end
-        end
-
-        result = nil
-        Module.new do
-          using refinement
-          result = refined_class.new.foo
-        end
-
-        result.should == "foo from included module"
-      end
-    end
-
     it "looks in the refined class" do
       refined_class = ModuleSpecs.build_refined_class
 
@@ -650,59 +565,6 @@ describe "Module#refine" do
       result.should == "foo"
     end
 
-    ruby_version_is ""..."3.1" do
-      it "looks in the refined class from included module" do
-        refined_class = ModuleSpecs.build_refined_class(for_super: true)
-
-        a = Module.new do
-          def foo
-            [:A] + super
-          end
-        end
-
-        refinement = Module.new do
-          refine refined_class do
-            include a
-          end
-        end
-
-        result = nil
-        Module.new do
-          using refinement
-
-          result = refined_class.new.foo
-        end
-
-        result.should == [:A, :C]
-      end
-
-      it "looks in the refined ancestors from included module" do
-        refined_class = ModuleSpecs.build_refined_class(for_super: true)
-        subclass = Class.new(refined_class)
-
-        a = Module.new do
-          def foo
-            [:A] + super
-          end
-        end
-
-        refinement = Module.new do
-          refine refined_class do
-            include a
-          end
-        end
-
-        result = nil
-        Module.new do
-          using refinement
-
-          result = subclass.new.foo
-        end
-
-        result.should == [:A, :C]
-      end
-    end
-
     # super in a method of a refinement invokes the method in the refined
     # class even if there is another refinement which has been activated
     # in the same context.
@@ -763,179 +625,6 @@ describe "Module#refine" do
         }.should raise_error(NoMethodError)
       end
     end
-
-    ruby_version_is ""..."3.1" do
-      it "does't have access to active refinements for C from included module" do
-        refined_class = ModuleSpecs.build_refined_class
-
-        a = Module.new do
-          def foo
-            super + bar
-          end
-        end
-
-        refinement = Module.new do
-          refine refined_class do
-            include a
-
-            def bar
-              "bar is not seen from A methods"
-            end
-          end
-        end
-
-        Module.new do
-          using refinement
-          -> {
-            refined_class.new.foo
-          }.should raise_error(NameError) { |e| e.name.should == :bar }
-        end
-      end
-
-      it "does't have access to other active refinements from included module" do
-        refined_class = ModuleSpecs.build_refined_class
-
-        refinement_integer = Module.new do
-          refine Integer do
-            def bar
-              "bar is not seen from A methods"
-            end
-          end
-        end
-
-        a = Module.new do
-          def foo
-            super + 1.bar
-          end
-        end
-
-        refinement = Module.new do
-          refine refined_class do
-            include a
-          end
-        end
-
-        Module.new do
-          using refinement
-          using refinement_integer
-          -> {
-            refined_class.new.foo
-          }.should raise_error(NameError) { |e| e.name.should == :bar }
-        end
-      end
-
-      # https://bugs.ruby-lang.org/issues/16977
-      it "looks in the another active refinement if super called from included modules" do
-        refined_class = ModuleSpecs.build_refined_class(for_super: true)
-
-        a = Module.new do
-          def foo
-            [:A] + super
-          end
-        end
-
-        b = Module.new do
-          def foo
-            [:B] + super
-          end
-        end
-
-        refinement_a = Module.new do
-          refine refined_class do
-            include a
-          end
-        end
-
-        refinement_b = Module.new do
-          refine refined_class do
-            include b
-          end
-        end
-
-        result = nil
-        Module.new do
-          using refinement_a
-          using refinement_b
-          result = refined_class.new.foo
-        end
-
-        result.should == [:B, :A, :C]
-      end
-
-      it "looks in the current active refinement from included modules" do
-        refined_class = ModuleSpecs.build_refined_class(for_super: true)
-
-        a = Module.new do
-          def foo
-            [:A] + super
-          end
-        end
-
-        b = Module.new do
-          def foo
-            [:B] + super
-          end
-        end
-
-        refinement = Module.new do
-          refine refined_class do
-            def foo
-              [:LAST] + super
-            end
-          end
-        end
-
-        refinement_a_b = Module.new do
-          refine refined_class do
-            include a
-            include b
-          end
-        end
-
-        result = nil
-        Module.new do
-          using refinement
-          using refinement_a_b
-          result = refined_class.new.foo
-        end
-
-        result.should == [:B, :A, :LAST, :C]
-      end
-
-      it "looks in the lexical scope refinements before other active refinements" do
-        refined_class = ModuleSpecs.build_refined_class(for_super: true)
-
-        refinement_local = Module.new do
-          refine refined_class do
-            def foo
-              [:LOCAL] + super
-            end
-          end
-        end
-
-        a = Module.new do
-          using refinement_local
-
-          def foo
-            [:A] + super
-          end
-        end
-
-        refinement = Module.new do
-          refine refined_class do
-            include a
-          end
-        end
-
-        result = nil
-        Module.new do
-          using refinement
-          result = refined_class.new.foo
-        end
-
-        result.should == [:A, :LOCAL, :C]
-      end
-    end
   end
 
   it 'and alias aliases a method within a refinement module, but not outside it' do
diff --git a/spec/ruby/core/module/remove_const_spec.rb b/spec/ruby/core/module/remove_const_spec.rb
index 0ac23f05a5..35a9d65105 100644
--- a/spec/ruby/core/module/remove_const_spec.rb
+++ b/spec/ruby/core/module/remove_const_spec.rb
@@ -101,5 +101,7 @@ describe "Module#remove_const" do
       A.send(:remove_const,:FOO)
       A.foo.should == 'm'
     end
+  ensure
+    ConstantSpecs.send(:remove_const, :RemovedConstantUpdate)
   end
 end
diff --git a/spec/ruby/core/module/to_s_spec.rb b/spec/ruby/core/module/to_s_spec.rb
index 6b1a615ef9..83c0ae0825 100644
--- a/spec/ruby/core/module/to_s_spec.rb
+++ b/spec/ruby/core/module/to_s_spec.rb
@@ -51,6 +51,8 @@ describe "Module#to_s" do
 
     ModuleSpecs::RefinementInspect::R.name.should == 'ModuleSpecs::RefinementInspect::R'
     ModuleSpecs::RefinementInspect::R.to_s.should == '#<refinement:String@ModuleSpecs::RefinementInspect>'
+  ensure
+    ModuleSpecs.send(:remove_const, :RefinementInspect)
   end
 
   it 'does not call #inspect or #to_s for singleton classes' do