1 files changed, 39 insertions, 39 deletions

diff --git a/spec/ruby/core/module/include_spec.rb b/spec/ruby/core/module/include_spec.rb
index 862c6976e1..b6201550e4 100644
--- a/spec/ruby/core/module/include_spec.rb
+++ b/spec/ruby/core/module/include_spec.rb
@@ -3,7 +3,7 @@ require_relative 'fixtures/classes'
 
 describe "Module#include" do
   it "is a public method" do
-    Module.should have_public_instance_method(:include, false)
+    Module.public_instance_methods(false).should.include?(:include)
   end
 
   it "calls #append_features(self) in reversed order on each module" do
@@ -33,52 +33,40 @@ describe "Module#include" do
   end
 
   it "adds all ancestor modules when a previously included module is included again" do
-    ModuleSpecs::MultipleIncludes.ancestors.should include(ModuleSpecs::MA, ModuleSpecs::MB)
+    ModuleSpecs::MultipleIncludes.ancestors.to_set.should >= Set[ModuleSpecs::MA, ModuleSpecs::MB]
     ModuleSpecs::MB.include(ModuleSpecs::MC)
     ModuleSpecs::MultipleIncludes.include(ModuleSpecs::MB)
-    ModuleSpecs::MultipleIncludes.ancestors.should include(ModuleSpecs::MA, ModuleSpecs::MB, ModuleSpecs::MC)
+    ModuleSpecs::MultipleIncludes.ancestors.to_set.should >= Set[ModuleSpecs::MA, ModuleSpecs::MB, ModuleSpecs::MC]
   end
 
   it "raises a TypeError when the argument is not a Module" do
-    -> { ModuleSpecs::Basic.include(Class.new) }.should raise_error(TypeError)
+    -> { ModuleSpecs::Basic.include(Class.new) }.should.raise(TypeError)
   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)
-  end
-
-  ruby_version_is ""..."3.2" do
-    it "raises ArgumentError 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(ArgumentError, "refinement module is not allowed")
+    class ModuleSpecs::SubclassSpec::AClass
     end
+    -> { ModuleSpecs::SubclassSpec::AClass.include(ModuleSpecs::Subclass.new) }.should_not.raise(TypeError)
+  ensure
+    ModuleSpecs::SubclassSpec.send(:remove_const, :AClass)
   end
 
-  ruby_version_is "3.2" do
-    it "raises a TypeError 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(TypeError, "Cannot include refinement")
     end
+
+    -> { ModuleSpecs::Basic.include(refinement) }.should.raise(TypeError, "Cannot include refinement")
   end
 
   it "imports constants to modules and classes" do
-    ModuleSpecs::A.constants.should include(:CONSTANT_A)
-    ModuleSpecs::B.constants.should include(:CONSTANT_A, :CONSTANT_B)
-    ModuleSpecs::C.constants.should include(:CONSTANT_A, :CONSTANT_B)
+    ModuleSpecs::A.constants.should.include?(:CONSTANT_A)
+    ModuleSpecs::B.constants.to_set.should >= Set[:CONSTANT_A, :CONSTANT_B]
+    ModuleSpecs::C.constants.to_set.should >= Set[:CONSTANT_A, :CONSTANT_B]
   end
 
   it "shadows constants from ancestors" do
@@ -96,9 +84,9 @@ describe "Module#include" do
   end
 
   it "imports instance methods to modules and classes" do
-    ModuleSpecs::A.instance_methods.should include(:ma)
-    ModuleSpecs::B.instance_methods.should include(:ma,:mb)
-    ModuleSpecs::C.instance_methods.should include(:ma,:mb)
+    ModuleSpecs::A.instance_methods.should.include?(:ma)
+    ModuleSpecs::B.instance_methods.to_set.should >= Set[:ma,:mb]
+    ModuleSpecs::C.instance_methods.to_set.should >= Set[:ma,:mb]
   end
 
   it "does not import methods to modules and classes" do
@@ -158,7 +146,7 @@ describe "Module#include" do
 
       anc = B.ancestors
       [B, U, V, W, A, X].each do |i|
-        anc.include?(i).should be_true
+        anc.include?(i).should == true
       end
 
       class B; include V; end
@@ -166,7 +154,7 @@ describe "Module#include" do
       # the only new module is Y, it is added after U since it follows U in V mixin list:
       anc = B.ancestors
       [B, U, Y, V, W, A, X].each do |i|
-        anc.include?(i).should be_true
+        anc.include?(i).should == true
       end
     end
   end
@@ -190,7 +178,7 @@ describe "Module#include" do
       module ModuleSpecs::M
         include ModuleSpecs::M
       end
-    }.should raise_error(ArgumentError)
+    }.should.raise(ArgumentError)
   end
 
   it "doesn't accept no-arguments" do
@@ -198,7 +186,7 @@ describe "Module#include" do
       Module.new do
         include
       end
-    }.should raise_error(ArgumentError)
+    }.should.raise(ArgumentError)
   end
 
   it "returns the class it's included into" do
@@ -427,6 +415,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 +443,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 +471,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 +501,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 +527,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 +557,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
@@ -622,7 +622,7 @@ describe "Module#include?" do
   end
 
   it "raises a TypeError when no module was given" do
-    -> { ModuleSpecs::Child.include?("Test") }.should raise_error(TypeError)
-    -> { ModuleSpecs::Child.include?(ModuleSpecs::Parent) }.should raise_error(TypeError)
+    -> { ModuleSpecs::Child.include?("Test") }.should.raise(TypeError)
+    -> { ModuleSpecs::Child.include?(ModuleSpecs::Parent) }.should.raise(TypeError)
   end
 end