From 45cf4f218728a15eb36d14a6c9912086525f5e3f Mon Sep 17 00:00:00 2001
From: Benoit Daloze <eregontp@gmail.com>
Date: Mon, 25 Apr 2022 14:53:54 +0200
Subject: Update to ruby/spec@3affe1e

---
 spec/ruby/core/array/clear_spec.rb        | 20 -------
 spec/ruby/core/array/compact_spec.rb      | 30 -----------
 spec/ruby/core/array/concat_spec.rb       | 58 ---------------------
 spec/ruby/core/array/deconstruct_spec.rb  | 10 ++--
 spec/ruby/core/array/delete_at_spec.rb    | 22 --------
 spec/ruby/core/array/delete_if_spec.rb    | 16 ------
 spec/ruby/core/array/delete_spec.rb       | 22 --------
 spec/ruby/core/array/element_set_spec.rb  | 76 +++++++++++++--------------
 spec/ruby/core/array/fill_spec.rb         |  8 ++-
 spec/ruby/core/array/flatten_spec.rb      | 10 ----
 spec/ruby/core/array/intersection_spec.rb | 16 +++---
 spec/ruby/core/array/multiply_spec.rb     | 40 --------------
 spec/ruby/core/array/pack/p_spec.rb       | 24 ---------
 spec/ruby/core/array/pack/shared/basic.rb | 12 -----
 spec/ruby/core/array/pack/shared/taint.rb | 33 ------------
 spec/ruby/core/array/plus_spec.rb         | 16 ------
 spec/ruby/core/array/pop_spec.rb          | 52 -------------------
 spec/ruby/core/array/shared/clone.rb      | 24 ---------
 spec/ruby/core/array/shared/collect.rb    | 31 -----------
 spec/ruby/core/array/shared/inspect.rb    | 26 ----------
 spec/ruby/core/array/shared/join.rb       | 86 +++----------------------------
 spec/ruby/core/array/shared/slice.rb      | 76 +++++++++++++--------------
 spec/ruby/core/array/shift_spec.rb        | 16 ------
 spec/ruby/core/array/slice_spec.rb        | 18 +++----
 spec/ruby/core/array/uniq_spec.rb         | 76 ++++++---------------------
 spec/ruby/core/array/values_at_spec.rb    |  8 ++-
 26 files changed, 123 insertions(+), 703 deletions(-)

(limited to 'spec/ruby/core/array')

diff --git a/spec/ruby/core/array/clear_spec.rb b/spec/ruby/core/array/clear_spec.rb
index bddc672d3b..81ba56e01e 100644
--- a/spec/ruby/core/array/clear_spec.rb
+++ b/spec/ruby/core/array/clear_spec.rb
@@ -20,30 +20,10 @@ describe "Array#clear" do
     a.size.should == 0
   end
 
-  ruby_version_is ''...'2.7' do
-    it "keeps tainted status" do
-      a = [1]
-      a.taint
-      a.tainted?.should be_true
-      a.clear
-      a.tainted?.should be_true
-    end
-  end
-
   it "does not accept any arguments" do
     -> { [1].clear(true) }.should raise_error(ArgumentError)
   end
 
-  ruby_version_is ''...'2.7' do
-    it "keeps untrusted status" do
-      a = [1]
-      a.untrust
-      a.untrusted?.should be_true
-      a.clear
-      a.untrusted?.should be_true
-    end
-  end
-
   it "raises a FrozenError on a frozen array" do
     a = [1]
     a.freeze
diff --git a/spec/ruby/core/array/compact_spec.rb b/spec/ruby/core/array/compact_spec.rb
index aa3c1c0446..83b3fa2a89 100644
--- a/spec/ruby/core/array/compact_spec.rb
+++ b/spec/ruby/core/array/compact_spec.rb
@@ -21,20 +21,6 @@ describe "Array#compact" do
   it "does not return subclass instance for Array subclasses" do
     ArraySpecs::MyArray[1, 2, 3, nil].compact.should be_an_instance_of(Array)
   end
-
-  ruby_version_is ''...'2.7' do
-    it "does not keep tainted status even if all elements are removed" do
-      a = [nil, nil]
-      a.taint
-      a.compact.tainted?.should be_false
-    end
-
-    it "does not keep untrusted status even if all elements are removed" do
-      a = [nil, nil]
-      a.untrust
-      a.compact.untrusted?.should be_false
-    end
-  end
 end
 
 describe "Array#compact!" do
@@ -59,22 +45,6 @@ describe "Array#compact!" do
     [1, 2, false, 3].compact!.should == nil
   end
 
-  ruby_version_is ''...'2.7' do
-    it "keeps tainted status even if all elements are removed" do
-      a = [nil, nil]
-      a.taint
-      a.compact!
-      a.tainted?.should be_true
-    end
-
-    it "keeps untrusted status even if all elements are removed" do
-      a = [nil, nil]
-      a.untrust
-      a.compact!
-      a.untrusted?.should be_true
-    end
-  end
-
   it "raises a FrozenError on a frozen array" do
     -> { ArraySpecs.frozen_array.compact! }.should raise_error(FrozenError)
   end
diff --git a/spec/ruby/core/array/concat_spec.rb b/spec/ruby/core/array/concat_spec.rb
index da6763bfd6..f3cab9c17c 100644
--- a/spec/ruby/core/array/concat_spec.rb
+++ b/spec/ruby/core/array/concat_spec.rb
@@ -41,64 +41,6 @@ describe "Array#concat" do
     -> { ArraySpecs.frozen_array.concat([]) }.should raise_error(FrozenError)
   end
 
-  ruby_version_is ''...'2.7' do
-    it "keeps tainted status" do
-      ary = [1, 2]
-      ary.taint
-      ary.concat([3])
-      ary.tainted?.should be_true
-      ary.concat([])
-      ary.tainted?.should be_true
-    end
-
-    it "is not infected by the other" do
-      ary = [1,2]
-      other = [3]; other.taint
-      ary.tainted?.should be_false
-      ary.concat(other)
-      ary.tainted?.should be_false
-    end
-
-    it "keeps the tainted status of elements" do
-      ary = [ Object.new, Object.new, Object.new ]
-      ary.each {|x| x.taint }
-
-      ary.concat([ Object.new ])
-      ary[0].tainted?.should be_true
-      ary[1].tainted?.should be_true
-      ary[2].tainted?.should be_true
-      ary[3].tainted?.should be_false
-    end
-
-    it "keeps untrusted status" do
-      ary = [1, 2]
-      ary.untrust
-      ary.concat([3])
-      ary.untrusted?.should be_true
-      ary.concat([])
-      ary.untrusted?.should be_true
-    end
-
-    it "is not infected untrustedness by the other" do
-      ary = [1,2]
-      other = [3]; other.untrust
-      ary.untrusted?.should be_false
-      ary.concat(other)
-      ary.untrusted?.should be_false
-    end
-
-    it "keeps the untrusted status of elements" do
-      ary = [ Object.new, Object.new, Object.new ]
-      ary.each {|x| x.untrust }
-
-      ary.concat([ Object.new ])
-      ary[0].untrusted?.should be_true
-      ary[1].untrusted?.should be_true
-      ary[2].untrusted?.should be_true
-      ary[3].untrusted?.should be_false
-    end
-  end
-
   it "appends elements to an Array with enough capacity that has been shifted" do
     ary = [1, 2, 3, 4, 5]
     2.times { ary.shift }
diff --git a/spec/ruby/core/array/deconstruct_spec.rb b/spec/ruby/core/array/deconstruct_spec.rb
index 2b07152dfc..ad67abe47b 100644
--- a/spec/ruby/core/array/deconstruct_spec.rb
+++ b/spec/ruby/core/array/deconstruct_spec.rb
@@ -1,11 +1,9 @@
 require_relative '../../spec_helper'
 
-ruby_version_is "2.7" do
-  describe "Array#deconstruct" do
-    it "returns self" do
-      array = [1]
+describe "Array#deconstruct" do
+  it "returns self" do
+    array = [1]
 
-      array.deconstruct.should equal array
-    end
+    array.deconstruct.should equal array
   end
 end
diff --git a/spec/ruby/core/array/delete_at_spec.rb b/spec/ruby/core/array/delete_at_spec.rb
index fc225a03f1..80ec643702 100644
--- a/spec/ruby/core/array/delete_at_spec.rb
+++ b/spec/ruby/core/array/delete_at_spec.rb
@@ -38,26 +38,4 @@ describe "Array#delete_at" do
   it "raises a FrozenError on a frozen array" do
     -> { [1,2,3].freeze.delete_at(0) }.should raise_error(FrozenError)
   end
-
-  ruby_version_is ''...'2.7' do
-    it "keeps tainted status" do
-      ary = [1, 2]
-      ary.taint
-      ary.tainted?.should be_true
-      ary.delete_at(0)
-      ary.tainted?.should be_true
-      ary.delete_at(0) # now empty
-      ary.tainted?.should be_true
-    end
-
-    it "keeps untrusted status" do
-      ary = [1, 2]
-      ary.untrust
-      ary.untrusted?.should be_true
-      ary.delete_at(0)
-      ary.untrusted?.should be_true
-      ary.delete_at(0) # now empty
-      ary.untrusted?.should be_true
-    end
-  end
 end
diff --git a/spec/ruby/core/array/delete_if_spec.rb b/spec/ruby/core/array/delete_if_spec.rb
index e1931220f5..1459cc8d04 100644
--- a/spec/ruby/core/array/delete_if_spec.rb
+++ b/spec/ruby/core/array/delete_if_spec.rb
@@ -47,22 +47,6 @@ describe "Array#delete_if" do
     -> { ArraySpecs.empty_frozen_array.delete_if {} }.should raise_error(FrozenError)
   end
 
-  ruby_version_is ''...'2.7' do
-    it "keeps tainted status" do
-      @a.taint
-      @a.tainted?.should be_true
-      @a.delete_if{ true }
-      @a.tainted?.should be_true
-    end
-
-    it "keeps untrusted status" do
-      @a.untrust
-      @a.untrusted?.should be_true
-      @a.delete_if{ true }
-      @a.untrusted?.should be_true
-    end
-  end
-
   it_behaves_like :enumeratorized_with_origin_size, :delete_if, [1,2,3]
   it_behaves_like :delete_if, :delete_if
 end
diff --git a/spec/ruby/core/array/delete_spec.rb b/spec/ruby/core/array/delete_spec.rb
index 5d53c74e47..dddbbe6bd3 100644
--- a/spec/ruby/core/array/delete_spec.rb
+++ b/spec/ruby/core/array/delete_spec.rb
@@ -43,26 +43,4 @@ describe "Array#delete" do
   it "raises a FrozenError on a frozen array" do
     -> { [1, 2, 3].freeze.delete(1) }.should raise_error(FrozenError)
   end
-
-  ruby_version_is ''...'2.7' do
-    it "keeps tainted status" do
-      a = [1, 2]
-      a.taint
-      a.tainted?.should be_true
-      a.delete(2)
-      a.tainted?.should be_true
-      a.delete(1) # now empty
-      a.tainted?.should be_true
-    end
-
-    it "keeps untrusted status" do
-      a = [1, 2]
-      a.untrust
-      a.untrusted?.should be_true
-      a.delete(2)
-      a.untrusted?.should be_true
-      a.delete(1) # now empty
-      a.untrusted?.should be_true
-    end
-  end
 end
diff --git a/spec/ruby/core/array/element_set_spec.rb b/spec/ruby/core/array/element_set_spec.rb
index 1e192c100f..df5ca9582e 100644
--- a/spec/ruby/core/array/element_set_spec.rb
+++ b/spec/ruby/core/array/element_set_spec.rb
@@ -481,50 +481,48 @@ describe "Array#[]= with [m..]" do
   end
 end
 
-ruby_version_is "2.7" do
-  describe "Array#[]= with [..n] and [...n]" do
-    it "just sets the section defined by range to nil even if the rhs is nil" do
-      a = [1, 2, 3, 4, 5]
-      a[eval("(..2)")] = nil
-      a.should == [nil, 4, 5]
-      a[eval("(...2)")] = nil
-      a.should == [nil, 5]
-    end
+describe "Array#[]= with [..n] and [...n]" do
+  it "just sets the section defined by range to nil even if the rhs is nil" do
+    a = [1, 2, 3, 4, 5]
+    a[(..2)] = nil
+    a.should == [nil, 4, 5]
+    a[(...2)] = nil
+    a.should == [nil, 5]
+  end
 
-    it "just sets the section defined by range to nil if n < 0 and the rhs is nil" do
-      a = [1, 2, 3, 4, 5]
-      a[eval("(..-3)")] = nil
-      a.should == [nil, 4, 5]
-      a[eval("(...-1)")] = [nil, 5]
-    end
+  it "just sets the section defined by range to nil if n < 0 and the rhs is nil" do
+    a = [1, 2, 3, 4, 5]
+    a[(..-3)] = nil
+    a.should == [nil, 4, 5]
+    a[(...-1)] = [nil, 5]
+  end
 
-    it "replaces the section defined by range" do
-      a = [6, 5, 4, 3, 2, 1]
-      a[eval("(...3)")] = 9
-      a.should == [9, 3, 2, 1]
-      a[eval("(..2)")] = [7, 7, 7, 7, 7]
-      a.should == [7, 7, 7, 7, 7, 1]
-    end
+  it "replaces the section defined by range" do
+    a = [6, 5, 4, 3, 2, 1]
+    a[(...3)] = 9
+    a.should == [9, 3, 2, 1]
+    a[(..2)] = [7, 7, 7, 7, 7]
+    a.should == [7, 7, 7, 7, 7, 1]
+  end
 
-    it "replaces the section if n < 0" do
-      a = [1, 2, 3, 4, 5]
-      a[eval("(..-2)")] = [7, 8, 9]
-      a.should == [7, 8, 9, 5]
-    end
+  it "replaces the section if n < 0" do
+    a = [1, 2, 3, 4, 5]
+    a[(..-2)] = [7, 8, 9]
+    a.should == [7, 8, 9, 5]
+  end
 
-    it "replaces everything if n > the array size" do
-      a = [1, 2, 3]
-      a[eval("(...7)")] = [4]
-      a.should == [4]
-    end
+  it "replaces everything if n > the array size" do
+    a = [1, 2, 3]
+    a[(...7)] = [4]
+    a.should == [4]
+  end
 
-    it "inserts at the beginning if n < negative the array size" do
-      a = [1, 2, 3]
-      a[eval("(..-7)")] = [4]
-      a.should == [4, 1, 2, 3]
-      a[eval("(...-10)")] = [6]
-      a.should == [6, 4, 1, 2, 3]
-    end
+  it "inserts at the beginning if n < negative the array size" do
+    a = [1, 2, 3]
+    a[(..-7)] = [4]
+    a.should == [4, 1, 2, 3]
+    a[(...-10)] = [6]
+    a.should == [6, 4, 1, 2, 3]
   end
 end
 
diff --git a/spec/ruby/core/array/fill_spec.rb b/spec/ruby/core/array/fill_spec.rb
index bfa8db551b..6369f23544 100644
--- a/spec/ruby/core/array/fill_spec.rb
+++ b/spec/ruby/core/array/fill_spec.rb
@@ -323,10 +323,8 @@ describe "Array#fill with (filler, range)" do
     [1, 2, 3, 4].fill(eval("(3...)")) { |x| x + 2 }.should == [1, 2, 3, 5]
   end
 
-  ruby_version_is "2.7" do
-    it "works with beginless ranges" do
-      [1, 2, 3, 4].fill('x', eval("(..2)")).should == ["x", "x", "x", 4]
-      [1, 2, 3, 4].fill(eval("(...2)")) { |x| x + 2 }.should == [2, 3, 3, 4]
-    end
+  it "works with beginless ranges" do
+    [1, 2, 3, 4].fill('x', (..2)).should == ["x", "x", "x", 4]
+    [1, 2, 3, 4].fill((...2)) { |x| x + 2 }.should == [2, 3, 3, 4]
   end
 end
diff --git a/spec/ruby/core/array/flatten_spec.rb b/spec/ruby/core/array/flatten_spec.rb
index 2f9fb8a3ec..1770b5389a 100644
--- a/spec/ruby/core/array/flatten_spec.rb
+++ b/spec/ruby/core/array/flatten_spec.rb
@@ -147,16 +147,6 @@ describe "Array#flatten" do
     end
   end
 
-  ruby_version_is ''...'2.7' do
-    it "returns a tainted array if self is tainted" do
-      [].taint.flatten.tainted?.should be_true
-    end
-
-    it "returns an untrusted array if self is untrusted" do
-      [].untrust.flatten.untrusted?.should be_true
-    end
-  end
-
   it "performs respond_to? and method_missing-aware checks when coercing elements to array" do
     bo = BasicObject.new
     [bo].flatten.should == [bo]
diff --git a/spec/ruby/core/array/intersection_spec.rb b/spec/ruby/core/array/intersection_spec.rb
index 27d90f1e44..e01a68d389 100644
--- a/spec/ruby/core/array/intersection_spec.rb
+++ b/spec/ruby/core/array/intersection_spec.rb
@@ -6,16 +6,14 @@ describe "Array#&" do
   it_behaves_like :array_intersection, :&
 end
 
-ruby_version_is "2.7" do
-  describe "Array#intersection" do
-    it_behaves_like :array_intersection, :intersection
+describe "Array#intersection" do
+  it_behaves_like :array_intersection, :intersection
 
-    it "accepts multiple arguments" do
-      [1, 2, 3, 4].intersection([1, 2, 3], [2, 3, 4]).should == [2, 3]
-    end
+  it "accepts multiple arguments" do
+    [1, 2, 3, 4].intersection([1, 2, 3], [2, 3, 4]).should == [2, 3]
+  end
 
-    it "preserves elements order from original array" do
-      [1, 2, 3, 4].intersection([3, 2, 1]).should == [1, 2, 3]
-    end
+  it "preserves elements order from original array" do
+    [1, 2, 3, 4].intersection([3, 2, 1]).should == [1, 2, 3]
   end
 end
diff --git a/spec/ruby/core/array/multiply_spec.rb b/spec/ruby/core/array/multiply_spec.rb
index 16e407348b..23d5c99f3a 100644
--- a/spec/ruby/core/array/multiply_spec.rb
+++ b/spec/ruby/core/array/multiply_spec.rb
@@ -97,46 +97,6 @@ describe "Array#* with an integer" do
       ScratchPad.recorded.should be_nil
     end
   end
-
-  ruby_version_is ''...'2.7' do
-    it "copies the taint status of the original array even if the passed count is 0" do
-      ary = [1, 2, 3]
-      ary.taint
-      (ary * 0).should.tainted?
-    end
-
-    it "copies the taint status of the original array even if the array is empty" do
-      ary = []
-      ary.taint
-      (ary * 3).should.tainted?
-    end
-
-    it "copies the taint status of the original array if the passed count is not 0" do
-      ary = [1, 2, 3]
-      ary.taint
-      (ary * 1).should.tainted?
-      (ary * 2).should.tainted?
-    end
-
-    it "copies the untrusted status of the original array even if the passed count is 0" do
-      ary = [1, 2, 3]
-      ary.untrust
-      (ary * 0).should.untrusted?
-    end
-
-    it "copies the untrusted status of the original array even if the array is empty" do
-      ary = []
-      ary.untrust
-      (ary * 3).should.untrusted?
-    end
-
-    it "copies the untrusted status of the original array if the passed count is not 0" do
-      ary = [1, 2, 3]
-      ary.untrust
-      (ary * 1).should.untrusted?
-      (ary * 2).should.untrusted?
-    end
-  end
 end
 
 describe "Array#* with a string" do
diff --git a/spec/ruby/core/array/pack/p_spec.rb b/spec/ruby/core/array/pack/p_spec.rb
index d7dff8a4da..b023bf9110 100644
--- a/spec/ruby/core/array/pack/p_spec.rb
+++ b/spec/ruby/core/array/pack/p_spec.rb
@@ -15,18 +15,6 @@ describe "Array#pack with format 'P'" do
     ["hello"].pack("P").unpack("P5").should == ["hello"]
   end
 
-  ruby_version_is ''...'2.7' do
-    it "taints the input string" do
-      input_string = "hello"
-      [input_string].pack("P")
-      input_string.tainted?.should be_true
-    end
-
-    it "does not taint the output string in normal cases" do
-      ["hello"].pack("P").tainted?.should be_false
-    end
-  end
-
   it "with nil gives a null pointer" do
     [nil].pack("P").unpack("J").should == [0]
   end
@@ -44,18 +32,6 @@ describe "Array#pack with format 'p'" do
     ["hello"].pack("p").unpack("p").should == ["hello"]
   end
 
-  ruby_version_is ''...'2.7' do
-    it "taints the input string" do
-      input_string = "hello"
-      [input_string].pack("p")
-      input_string.tainted?.should be_true
-    end
-
-    it "does not taint the output string in normal cases" do
-      ["hello"].pack("p").tainted?.should be_false
-    end
-  end
-
   it "with nil gives a null pointer" do
     [nil].pack("p").unpack("J").should == [0]
   end
diff --git a/spec/ruby/core/array/pack/shared/basic.rb b/spec/ruby/core/array/pack/shared/basic.rb
index 9061273ad6..23e239d3de 100644
--- a/spec/ruby/core/array/pack/shared/basic.rb
+++ b/spec/ruby/core/array/pack/shared/basic.rb
@@ -32,12 +32,6 @@ describe :array_pack_basic_non_float, shared: true do
     d.should_receive(:to_str).and_return("x"+pack_format)
     [@obj, @obj].pack(d).should be_an_instance_of(String)
   end
-
-  ruby_version_is ''...'2.7' do
-    it "taints the output string if the format string is tainted" do
-      [@obj, @obj].pack("x"+pack_format.taint).tainted?.should be_true
-    end
-  end
 end
 
 describe :array_pack_basic_float, shared: true do
@@ -50,12 +44,6 @@ describe :array_pack_basic_float, shared: true do
     d.should_receive(:to_str).and_return("x"+pack_format)
     [1.2, 4.7].pack(d).should be_an_instance_of(String)
   end
-
-  ruby_version_is ''...'2.7' do
-    it "taints the output string if the format string is tainted" do
-      [3.2, 2.8].pack("x"+pack_format.taint).tainted?.should be_true
-    end
-  end
 end
 
 describe :array_pack_no_platform, shared: true do
diff --git a/spec/ruby/core/array/pack/shared/taint.rb b/spec/ruby/core/array/pack/shared/taint.rb
index 565f04b8b9..2c2b011c34 100644
--- a/spec/ruby/core/array/pack/shared/taint.rb
+++ b/spec/ruby/core/array/pack/shared/taint.rb
@@ -1,35 +1,2 @@
 describe :array_pack_taint, shared: true do
-  ruby_version_is ''...'2.7' do
-    it "returns a tainted string when a pack argument is tainted" do
-      ["abcd".taint, 0x20].pack(pack_format("3C")).tainted?.should be_true
-    end
-
-    it "does not return a tainted string when the array is tainted" do
-      ["abcd", 0x20].taint.pack(pack_format("3C")).tainted?.should be_false
-    end
-
-    it "returns a tainted string when the format is tainted" do
-      ["abcd", 0x20].pack(pack_format("3C").taint).tainted?.should be_true
-    end
-
-    it "returns a tainted string when an empty format is tainted" do
-      ["abcd", 0x20].pack("".taint).tainted?.should be_true
-    end
-
-    it "returns a untrusted string when the format is untrusted" do
-      ["abcd", 0x20].pack(pack_format("3C").untrust).untrusted?.should be_true
-    end
-
-    it "returns a untrusted string when the empty format is untrusted" do
-      ["abcd", 0x20].pack("".untrust).untrusted?.should be_true
-    end
-
-    it "returns a untrusted string when a pack argument is untrusted" do
-      ["abcd".untrust, 0x20].pack(pack_format("3C")).untrusted?.should be_true
-    end
-
-    it "returns a trusted string when the array is untrusted" do
-      ["abcd", 0x20].untrust.pack(pack_format("3C")).untrusted?.should be_false
-    end
-  end
 end
diff --git a/spec/ruby/core/array/plus_spec.rb b/spec/ruby/core/array/plus_spec.rb
index 45f8438208..3962b05c39 100644
--- a/spec/ruby/core/array/plus_spec.rb
+++ b/spec/ruby/core/array/plus_spec.rb
@@ -40,20 +40,4 @@ describe "Array#+" do
   it "does not call to_ary on array subclasses" do
     ([5, 6] + ArraySpecs::ToAryArray[1, 2]).should == [5, 6, 1, 2]
   end
-
-  ruby_version_is ''...'2.7' do
-    it "does not get infected even if an original array is tainted" do
-      ([1, 2] + [3, 4]).tainted?.should be_false
-      ([1, 2].taint + [3, 4]).tainted?.should be_false
-      ([1, 2] + [3, 4].taint).tainted?.should be_false
-      ([1, 2].taint + [3, 4].taint).tainted?.should be_false
-    end
-
-    it "does not infected even if an original array is untrusted" do
-      ([1, 2] + [3, 4]).untrusted?.should be_false
-      ([1, 2].untrust + [3, 4]).untrusted?.should be_false
-      ([1, 2] + [3, 4].untrust).untrusted?.should be_false
-      ([1, 2].untrust + [3, 4].untrust).untrusted?.should be_false
-    end
-  end
 end
diff --git a/spec/ruby/core/array/pop_spec.rb b/spec/ruby/core/array/pop_spec.rb
index 96ef78da32..2a19408660 100644
--- a/spec/ruby/core/array/pop_spec.rb
+++ b/spec/ruby/core/array/pop_spec.rb
@@ -30,16 +30,6 @@ describe "Array#pop" do
     array.pop.should == [1, 'two', 3.0, array, array, array, array]
   end
 
-  ruby_version_is ''...'2.7' do
-    it "keeps taint status" do
-      a = [1, 2].taint
-      a.pop
-      a.tainted?.should be_true
-      a.pop
-      a.tainted?.should be_true
-    end
-  end
-
   it "raises a FrozenError on a frozen array" do
     -> { ArraySpecs.frozen_array.pop }.should raise_error(FrozenError)
   end
@@ -48,16 +38,6 @@ describe "Array#pop" do
     -> { ArraySpecs.empty_frozen_array.pop }.should raise_error(FrozenError)
   end
 
-  ruby_version_is ''...'2.7' do
-    it "keeps untrusted status" do
-      a = [1, 2].untrust
-      a.pop
-      a.untrusted?.should be_true
-      a.pop
-      a.untrusted?.should be_true
-    end
-  end
-
   describe "passed a number n as an argument" do
     it "removes and returns an array with the last n elements of the array" do
       a = [1, 2, 3, 4, 5, 6]
@@ -136,41 +116,9 @@ describe "Array#pop" do
       ArraySpecs::MyArray[1, 2, 3].pop(2).should be_an_instance_of(Array)
     end
 
-    ruby_version_is ''...'2.7' do
-      it "returns an untainted array even if the array is tainted" do
-        ary = [1, 2].taint
-        ary.pop(2).tainted?.should be_false
-        ary.pop(0).tainted?.should be_false
-      end
-
-      it "keeps taint status" do
-        a = [1, 2].taint
-        a.pop(2)
-        a.tainted?.should be_true
-        a.pop(2)
-        a.tainted?.should be_true
-      end
-
-      it "returns a trusted array even if the array is untrusted" do
-        ary = [1, 2].untrust
-        ary.pop(2).untrusted?.should be_false
-        ary.pop(0).untrusted?.should be_false
-      end
-    end
-
     it "raises a FrozenError on a frozen array" do
       -> { ArraySpecs.frozen_array.pop(2) }.should raise_error(FrozenError)
       -> { ArraySpecs.frozen_array.pop(0) }.should raise_error(FrozenError)
     end
-
-    ruby_version_is ''...'2.7' do
-      it "keeps untrusted status" do
-        a = [1, 2].untrust
-        a.pop(2)
-        a.untrusted?.should be_true
-        a.pop(2)
-        a.untrusted?.should be_true
-      end
-    end
   end
 end
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
diff --git a/spec/ruby/core/array/shift_spec.rb b/spec/ruby/core/array/shift_spec.rb
index b998e45d28..6b4ef39f77 100644
--- a/spec/ruby/core/array/shift_spec.rb
+++ b/spec/ruby/core/array/shift_spec.rb
@@ -116,21 +116,5 @@ describe "Array#shift" do
     it "does not return subclass instances with Array subclass" do
       ArraySpecs::MyArray[1, 2, 3].shift(2).should be_an_instance_of(Array)
     end
-
-    ruby_version_is ''...'2.7' do
-      it "returns an untainted array even if the array is tainted" do
-        ary = [1, 2].taint
-        ary.shift(2).tainted?.should be_false
-        ary.shift(0).tainted?.should be_false
-      end
-
-      it "keeps taint status" do
-        a = [1, 2].taint
-        a.shift(2)
-        a.tainted?.should be_true
-        a.shift(2)
-        a.tainted?.should be_true
-      end
-    end
   end
 end
diff --git a/spec/ruby/core/array/slice_spec.rb b/spec/ruby/core/array/slice_spec.rb
index 8c276f9084..8e1499855a 100644
--- a/spec/ruby/core/array/slice_spec.rb
+++ b/spec/ruby/core/array/slice_spec.rb
@@ -172,16 +172,14 @@ describe "Array#slice!" do
     a.should == [1, 2]
   end
 
-  ruby_version_is "2.7" do
-    it "works with beginless ranges" do
-      a = [0,1,2,3,4]
-      a.slice!(eval("(..3)")).should == [0, 1, 2, 3]
-      a.should == [4]
-
-      a = [0,1,2,3,4]
-      a.slice!(eval("(...-2)")).should == [0, 1, 2]
-      a.should == [3, 4]
-    end
+  it "works with beginless ranges" do
+    a = [0,1,2,3,4]
+    a.slice!((..3)).should == [0, 1, 2, 3]
+    a.should == [4]
+
+    a = [0,1,2,3,4]
+    a.slice!((...-2)).should == [0, 1, 2]
+    a.should == [3, 4]
   end
 
   describe "with a subclass of Array" do
diff --git a/spec/ruby/core/array/uniq_spec.rb b/spec/ruby/core/array/uniq_spec.rb
index 5911c23e6a..4461cae16b 100644
--- a/spec/ruby/core/array/uniq_spec.rb
+++ b/spec/ruby/core/array/uniq_spec.rb
@@ -39,76 +39,32 @@ describe "Array#uniq" do
     [x, y].uniq.should == [x, y]
   end
 
-  ruby_version_is '2.7' do
-    it "compares elements with matching hash codes with #eql?" do
-      a = Array.new(2) do
-        obj = mock('0')
-        obj.should_receive(:hash).at_least(1).and_return(0)
-
-        def obj.eql?(o)
-          false
-        end
-
-        obj
-      end
-
-      a.uniq.should == a
+  it "compares elements with matching hash codes with #eql?" do
+    a = Array.new(2) do
+      obj = mock('0')
+      obj.should_receive(:hash).at_least(1).and_return(0)
 
-      a = Array.new(2) do
-        obj = mock('0')
-        obj.should_receive(:hash).at_least(1).and_return(0)
-
-        def obj.eql?(o)
-          true
-        end
-
-        obj
+      def obj.eql?(o)
+        false
       end
 
-      a.uniq.size.should == 1
+      obj
     end
-  end
 
-  ruby_version_is ''...'2.7' do
-    it "compares elements with matching hash codes with #eql?" do
-      a = Array.new(2) do
-        obj = mock('0')
-        obj.should_receive(:hash).at_least(1).and_return(0)
-
-        def obj.eql?(o)
-          # It's undefined whether the impl does a[0].eql?(a[1]) or
-          # a[1].eql?(a[0]) so we taint both.
-          taint
-          o.taint
-          false
-        end
-
-        obj
-      end
-
-      a.uniq.should == a
-      a[0].should.tainted?
-      a[1].should.tainted?
+    a.uniq.should == a
 
-      a = Array.new(2) do
-        obj = mock('0')
-        obj.should_receive(:hash).at_least(1).and_return(0)
+    a = Array.new(2) do
+      obj = mock('0')
+      obj.should_receive(:hash).at_least(1).and_return(0)
 
-        def obj.eql?(o)
-          # It's undefined whether the impl does a[0].eql?(a[1]) or
-          # a[1].eql?(a[0]) so we taint both.
-          taint
-          o.taint
-          true
-        end
-
-        obj
+      def obj.eql?(o)
+        true
       end
 
-      a.uniq.size.should == 1
-      a[0].should.tainted?
-      a[1].should.tainted?
+      obj
     end
+
+    a.uniq.size.should == 1
   end
 
   it "compares elements based on the value returned from the block" do
diff --git a/spec/ruby/core/array/values_at_spec.rb b/spec/ruby/core/array/values_at_spec.rb
index f1522e0bfe..2c6fd16947 100644
--- a/spec/ruby/core/array/values_at_spec.rb
+++ b/spec/ruby/core/array/values_at_spec.rb
@@ -66,10 +66,8 @@ describe "Array#values_at" do
     [1, 2, 3, 4].values_at(eval("(3...)")).should == [4]
   end
 
-  ruby_version_is "2.7" do
-    it "works when given beginless ranges" do
-      [1, 2, 3, 4].values_at(eval("(..2)")).should == [1, 2, 3]
-      [1, 2, 3, 4].values_at(eval("(...2)")).should == [1, 2]
-    end
+  it "works when given beginless ranges" do
+    [1, 2, 3, 4].values_at((..2)).should == [1, 2, 3]
+    [1, 2, 3, 4].values_at((...2)).should == [1, 2]
   end
 end
-- 
cgit v1.2.3