Update to ruby/spec@3affe1e

author: Benoit Daloze <[email protected]> 2022-04-25 14:53:54 +0200
committer: Benoit Daloze <[email protected]> 2022-04-25 14:53:54 +0200
commit: 45cf4f218728a15eb36d14a6c9912086525f5e3f (patch)
tree: 2aa93fadcb904c226f722dde47827098b87a9846 /spec/ruby/core/array/shared
parent: 6ae81d49b52563a6720d666a6118ffa6e484f398 (diff)
5 files changed, 45 insertions, 198 deletions
diff --git a/spec/ruby/core/array/shared/clone.rb b/spec/ruby/core/array/shared/clone.rb
index 3c17b1f10f..035b45ec99 100644
--- a/spec/ruby/core/array/shared/clone.rb
+++ b/spec/ruby/core/array/shared/clone.rb
@@ -17,28 +17,4 @@ describe :array_clone, shared: true do
     b.should == a
     b.__id__.should_not == a.__id__
   end
-
-  ruby_version_is ''...'2.7' do
-    it "copies taint status from the original" do
-      a = [1, 2, 3, 4]
-      b = [1, 2, 3, 4]
-      a.taint
-      aa = a.send @method
-      bb = b.send @method
-
-      aa.should.tainted?
-      bb.should_not.tainted?
-    end
-
-    it "copies untrusted status from the original" do
-      a = [1, 2, 3, 4]
-      b = [1, 2, 3, 4]
-      a.untrust
-      aa = a.send @method
-      bb = b.send @method
-
-      aa.should.untrusted?
-      bb.should_not.untrusted?
-    end
-  end
 end
diff --git a/spec/ruby/core/array/shared/collect.rb b/spec/ruby/core/array/shared/collect.rb
index d84432734a..8d75f7db9a 100644
--- a/spec/ruby/core/array/shared/collect.rb
+++ b/spec/ruby/core/array/shared/collect.rb
@@ -42,20 +42,6 @@ describe :array_collect, shared: true do
     }.should raise_error(ArgumentError)
   end
 
-  ruby_version_is ''...'2.7' do
-    it "does not copy tainted status" do
-      a = [1, 2, 3]
-      a.taint
-      a.send(@method){|x| x}.tainted?.should be_false
-    end
-
-    it "does not copy untrusted status" do
-      a = [1, 2, 3]
-      a.untrust
-      a.send(@method){|x| x}.untrusted?.should be_false
-    end
-  end
-
   before :all do
     @object = [1, 2, 3, 4]
   end
@@ -96,23 +82,6 @@ describe :array_collect_b, shared: true do
     a.should == ["1!", "2!", "3!"]
   end
 
-  ruby_version_is ''...'2.7' do
-    it "keeps tainted status" do
-      a = [1, 2, 3]
-      a.taint
-      a.tainted?.should be_true
-      a.send(@method){|x| x}
-      a.tainted?.should be_true
-    end
-
-    it "keeps untrusted status" do
-      a = [1, 2, 3]
-      a.untrust
-      a.send(@method){|x| x}
-      a.untrusted?.should be_true
-    end
-  end
-
   describe "when frozen" do
     it "raises a FrozenError" do
       -> { ArraySpecs.frozen_array.send(@method) {} }.should raise_error(FrozenError)
diff --git a/spec/ruby/core/array/shared/inspect.rb b/spec/ruby/core/array/shared/inspect.rb
index 736f8d946b..a2b43d4959 100644
--- a/spec/ruby/core/array/shared/inspect.rb
+++ b/spec/ruby/core/array/shared/inspect.rb
@@ -64,32 +64,6 @@ describe :array_inspect, shared: true do
     ArraySpecs.empty_recursive_array.send(@method).should == "[[...]]"
   end
 
-  ruby_version_is ''...'2.7' do
-    it "taints the result if the Array is non-empty and tainted" do
-      [1, 2].taint.send(@method).tainted?.should be_true
-    end
-
-    it "does not taint the result if the Array is tainted but empty" do
-      [].taint.send(@method).tainted?.should be_false
-    end
-
-    it "taints the result if an element is tainted" do
-      ["str".taint].send(@method).tainted?.should be_true
-    end
-
-    it "untrusts the result if the Array is untrusted" do
-      [1, 2].untrust.send(@method).untrusted?.should be_true
-    end
-
-    it "does not untrust the result if the Array is untrusted but empty" do
-      [].untrust.send(@method).untrusted?.should be_false
-    end
-
-    it "untrusts the result if an element is untrusted" do
-      ["str".untrust].send(@method).untrusted?.should be_true
-    end
-  end
-
   describe "with encoding" do
     before :each do
       @default_external_encoding = Encoding.default_external
diff --git a/spec/ruby/core/array/shared/join.rb b/spec/ruby/core/array/shared/join.rb
index dfdb4ae1e4..507b13e3c8 100644
--- a/spec/ruby/core/array/shared/join.rb
+++ b/spec/ruby/core/array/shared/join.rb
@@ -58,36 +58,6 @@ describe :array_join_with_default_separator, shared: true do
     -> { ArraySpecs.empty_recursive_array.send(@method) }.should raise_error(ArgumentError)
   end
 
-  ruby_version_is ''...'2.7' do
-    it "taints the result if the Array is tainted and non-empty" do
-      [1, 2].taint.send(@method).tainted?.should be_true
-    end
-
-    it "does not taint the result if the Array is tainted but empty" do
-      [].taint.send(@method).tainted?.should be_false
-    end
-
-    it "taints the result if the result of coercing an element is tainted" do
-      s = mock("taint")
-      s.should_receive(:to_s).and_return("str".taint)
-      [s].send(@method).tainted?.should be_true
-    end
-
-    it "untrusts the result if the Array is untrusted and non-empty" do
-      [1, 2].untrust.send(@method).untrusted?.should be_true
-    end
-
-    it "does not untrust the result if the Array is untrusted but empty" do
-      [].untrust.send(@method).untrusted?.should be_false
-    end
-
-    it "untrusts the result if the result of coercing an element is untrusted" do
-      s = mock("untrust")
-      s.should_receive(:to_s).and_return("str".untrust)
-      [s].send(@method).untrusted?.should be_true
-    end
-  end
-
   it "uses the first encoding when other strings are compatible" do
     ary1 = ArraySpecs.array_with_7bit_utf8_and_usascii_strings
     ary2 = ArraySpecs.array_with_usascii_and_7bit_utf8_strings
@@ -114,18 +84,16 @@ describe :array_join_with_default_separator, shared: true do
     -> { ary_utf8_bad_binary.send(@method) }.should raise_error(EncodingError)
   end
 
-  ruby_version_is "2.7" do
-    context "when $, is not nil" do
-      before do
-        suppress_warning do
-          $, = '*'
-        end
+  context "when $, is not nil" do
+    before do
+      suppress_warning do
+        $, = '*'
       end
+    end
 
-      it "warns" do
-        -> { [].join }.should complain(/warning: \$, is set to non-nil value/)
-        -> { [].join(nil) }.should complain(/warning: \$, is set to non-nil value/)
-      end
+    it "warns" do
+      -> { [].join }.should complain(/warning: \$, is set to non-nil value/)
+      -> { [].join(nil) }.should complain(/warning: \$, is set to non-nil value/)
     end
   end
 end
@@ -141,42 +109,4 @@ describe :array_join_with_string_separator, shared: true do
     [1, [2, [3, 4], 5], 6].send(@method, ":").should == "1:2:3:4:5:6"
     [1, [2, ArraySpecs::MyArray[3, 4], 5], 6].send(@method, ":").should == "1:2:3:4:5:6"
   end
-
-  ruby_version_is ''...'2.7' do
-    describe "with a tainted separator" do
-      before :each do
-        @sep = ":".taint
-      end
-
-      it "does not taint the result if the array is empty" do
-        [].send(@method, @sep).tainted?.should be_false
-      end
-
-      it "does not taint the result if the array has only one element" do
-        [1].send(@method, @sep).tainted?.should be_false
-      end
-
-      it "taints the result if the array has two or more elements" do
-        [1, 2].send(@method, @sep).tainted?.should be_true
-      end
-    end
-
-    describe "with an untrusted separator" do
-      before :each do
-        @sep = ":".untrust
-      end
-
-      it "does not untrust the result if the array is empty" do
-        [].send(@method, @sep).untrusted?.should be_false
-      end
-
-      it "does not untrust the result if the array has only one element" do
-        [1].send(@method, @sep).untrusted?.should be_false
-      end
-
-      it "untrusts the result if the array has two or more elements" do
-        [1, 2].send(@method, @sep).untrusted?.should be_true
-      end
-    end
-  end
 end
diff --git a/spec/ruby/core/array/shared/slice.rb b/spec/ruby/core/array/shared/slice.rb
index 540a050130..3b09fdcbc6 100644
--- a/spec/ruby/core/array/shared/slice.rb
+++ b/spec/ruby/core/array/shared/slice.rb
@@ -556,34 +556,34 @@ describe :array_slice, shared: true do
 
       it "has beginless range and positive steps" do
         # end with zero index
-        @array.send(@method, eval("(..0).step(1)")).should == [0]
-        @array.send(@method, eval("(...0).step(1)")).should == []
+        @array.send(@method, (..0).step(1)).should == [0]
+        @array.send(@method, (...0).step(1)).should == []
 
-        @array.send(@method, eval("(..0).step(2)")).should == [0]
-        @array.send(@method, eval("(...0).step(2)")).should == []
+        @array.send(@method, (..0).step(2)).should == [0]
+        @array.send(@method, (...0).step(2)).should == []
 
-        @array.send(@method, eval("(..0).step(10)")).should == [0]
-        @array.send(@method, eval("(...0).step(10)")).should == []
+        @array.send(@method, (..0).step(10)).should == [0]
+        @array.send(@method, (...0).step(10)).should == []
 
         # end with positive index
-        @array.send(@method, eval("(..3).step(1)")).should == [0, 1, 2, 3]
-        @array.send(@method, eval("(...3).step(1)")).should == [0, 1, 2]
+        @array.send(@method, (..3).step(1)).should == [0, 1, 2, 3]
+        @array.send(@method, (...3).step(1)).should == [0, 1, 2]
 
-        @array.send(@method, eval("(..3).step(2)")).should == [0, 2]
-        @array.send(@method, eval("(...3).step(2)")).should == [0, 2]
+        @array.send(@method, (..3).step(2)).should == [0, 2]
+        @array.send(@method, (...3).step(2)).should == [0, 2]
 
-        @array.send(@method, eval("(..3).step(10)")).should == [0]
-        @array.send(@method, eval("(...3).step(10)")).should == [0]
+        @array.send(@method, (..3).step(10)).should == [0]
+        @array.send(@method, (...3).step(10)).should == [0]
 
         # end with negative index
-        @array.send(@method, eval("(..-2).step(1)")).should == [0, 1, 2, 3, 4,]
-        @array.send(@method, eval("(...-2).step(1)")).should == [0, 1, 2, 3]
+        @array.send(@method, (..-2).step(1)).should == [0, 1, 2, 3, 4,]
+        @array.send(@method, (...-2).step(1)).should == [0, 1, 2, 3]
 
-        @array.send(@method, eval("(..-2).step(2)")).should == [0, 2, 4]
-        @array.send(@method, eval("(...-2).step(2)")).should == [0, 2]
+        @array.send(@method, (..-2).step(2)).should == [0, 2, 4]
+        @array.send(@method, (...-2).step(2)).should == [0, 2]
 
-        @array.send(@method, eval("(..-2).step(10)")).should == [0]
-        @array.send(@method, eval("(...-2).step(10)")).should == [0]
+        @array.send(@method, (..-2).step(10)).should == [0]
+        @array.send(@method, (...-2).step(10)).should == [0]
       end
 
       it "has endless range and negative steps" do
@@ -770,26 +770,24 @@ describe :array_slice, shared: true do
     end
   end
 
-  ruby_version_is "2.7" do
-    it "can accept beginless ranges" do
-      a = [0, 1, 2, 3, 4, 5]
-      a.send(@method, eval("(..3)")).should == [0, 1, 2, 3]
-      a.send(@method, eval("(...3)")).should == [0, 1, 2]
-      a.send(@method, eval("(..-3)")).should == [0, 1, 2, 3]
-      a.send(@method, eval("(...-3)")).should == [0, 1, 2]
-      a.send(@method, eval("(..0)")).should == [0]
-      a.send(@method, eval("(...0)")).should == []
-      a.send(@method, eval("(..9)")).should == [0, 1, 2, 3, 4, 5]
-      a.send(@method, eval("(...9)")).should == [0, 1, 2, 3, 4, 5]
-      a.send(@method, eval("(..-9)")).should == []
-      a.send(@method, eval("(...-9)")).should == []
-    end
-
-    it "can accept nil...nil ranges" do
-      a = [0, 1, 2, 3, 4, 5]
-      a.send(@method, eval("(nil...nil)")).should == a
-      a.send(@method, eval("(...nil)")).should == a
-      a.send(@method, eval("(nil..)")).should == a
-    end
+  it "can accept beginless ranges" do
+    a = [0, 1, 2, 3, 4, 5]
+    a.send(@method, (..3)).should == [0, 1, 2, 3]
+    a.send(@method, (...3)).should == [0, 1, 2]
+    a.send(@method, (..-3)).should == [0, 1, 2, 3]
+    a.send(@method, (...-3)).should == [0, 1, 2]
+    a.send(@method, (..0)).should == [0]
+    a.send(@method, (...0)).should == []
+    a.send(@method, (..9)).should == [0, 1, 2, 3, 4, 5]
+    a.send(@method, (...9)).should == [0, 1, 2, 3, 4, 5]
+    a.send(@method, (..-9)).should == []
+    a.send(@method, (...-9)).should == []
+  end
+
+  it "can accept nil...nil ranges" do
+    a = [0, 1, 2, 3, 4, 5]
+    a.send(@method, eval("(nil...nil)")).should == a
+    a.send(@method, (...nil)).should == a
+    a.send(@method, eval("(nil..)")).should == a
   end
 end
author	Benoit Daloze <[email protected]>	2022-04-25 14:53:54 +0200
committer	Benoit Daloze <[email protected]>	2022-04-25 14:53:54 +0200
commit	45cf4f218728a15eb36d14a6c9912086525f5e3f (patch)
tree	2aa93fadcb904c226f722dde47827098b87a9846 /spec/ruby/core/array/shared
parent	6ae81d49b52563a6720d666a6118ffa6e484f398 (diff)