Deprecate taint/trust and related methods, and make the methods no-ops

This removes the related tests, and puts the related specs behind
version guards.  This affects all code in lib, including some
libraries that may want to support older versions of Ruby.

19 files changed, 485 insertions, 399 deletions

diff --git a/spec/ruby/core/array/clear_spec.rb b/spec/ruby/core/array/clear_spec.rb
index 8f83a012b7..d399d5a373 100644
--- a/spec/ruby/core/array/clear_spec.rb
+++ b/spec/ruby/core/array/clear_spec.rb
@@ -20,24 +20,28 @@ describe "Array#clear" do
     a.size.should == 0
   end
 
-  it "keeps tainted status" do
-    a = [1]
-    a.taint
-    a.tainted?.should be_true
-    a.clear
-    a.tainted?.should be_true
+  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
 
-  it "keeps untrusted status" do
-    a = [1]
-    a.untrust
-    a.untrusted?.should be_true
-    a.clear
-    a.untrusted?.should be_true
+  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 #{frozen_error_class} on a frozen array" do
diff --git a/spec/ruby/core/array/compact_spec.rb b/spec/ruby/core/array/compact_spec.rb
index ecccddeb9f..ee3dfc0ca2 100644
--- a/spec/ruby/core/array/compact_spec.rb
+++ b/spec/ruby/core/array/compact_spec.rb
@@ -22,16 +22,18 @@ describe "Array#compact" do
     ArraySpecs::MyArray[1, 2, 3, nil].compact.should be_an_instance_of(Array)
   end
 
-  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
+  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
+    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
 
@@ -57,18 +59,20 @@ describe "Array#compact!" do
     [1, 2, false, 3].compact!.should == nil
   end
 
-  it "keeps tainted status even if all elements are removed" do
-    a = [nil, nil]
-    a.taint
-    a.compact!
-    a.tainted?.should be_true
-  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
+    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 #{frozen_error_class} on a frozen array" do
diff --git a/spec/ruby/core/array/concat_spec.rb b/spec/ruby/core/array/concat_spec.rb
index cc707d9948..b297c091a3 100644
--- a/spec/ruby/core/array/concat_spec.rb
+++ b/spec/ruby/core/array/concat_spec.rb
@@ -41,60 +41,62 @@ describe "Array#concat" do
     -> { ArraySpecs.frozen_array.concat([]) }.should raise_error(frozen_error_class)
   end
 
-  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
+  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
diff --git a/spec/ruby/core/array/delete_at_spec.rb b/spec/ruby/core/array/delete_at_spec.rb
index c3111fe3d8..0ed56c18bb 100644
--- a/spec/ruby/core/array/delete_at_spec.rb
+++ b/spec/ruby/core/array/delete_at_spec.rb
@@ -39,23 +39,25 @@ describe "Array#delete_at" do
     -> { [1,2,3].freeze.delete_at(0) }.should raise_error(frozen_error_class)
   end
 
-  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
+  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 9f22f7e086..2312917c41 100644
--- a/spec/ruby/core/array/delete_if_spec.rb
+++ b/spec/ruby/core/array/delete_if_spec.rb
@@ -47,18 +47,20 @@ describe "Array#delete_if" do
     -> { ArraySpecs.empty_frozen_array.delete_if {} }.should raise_error(frozen_error_class)
   end
 
-  it "keeps tainted status" do
-    @a.taint
-    @a.tainted?.should be_true
-    @a.delete_if{ true }
-    @a.tainted?.should be_true
-  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
+    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]
diff --git a/spec/ruby/core/array/delete_spec.rb b/spec/ruby/core/array/delete_spec.rb
index c55f4ad672..41e211e660 100644
--- a/spec/ruby/core/array/delete_spec.rb
+++ b/spec/ruby/core/array/delete_spec.rb
@@ -44,23 +44,25 @@ describe "Array#delete" do
     -> { [1, 2, 3].freeze.delete(1) }.should raise_error(frozen_error_class)
   end
 
-  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
+  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
+    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/flatten_spec.rb b/spec/ruby/core/array/flatten_spec.rb
index b506f899b4..66af20ad70 100644
--- a/spec/ruby/core/array/flatten_spec.rb
+++ b/spec/ruby/core/array/flatten_spec.rb
@@ -145,12 +145,14 @@ describe "Array#flatten" do
     end
   end
 
-  it "returns a tainted array if self is tainted" do
-    [].taint.flatten.tainted?.should be_true
-  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
+    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
diff --git a/spec/ruby/core/array/multiply_spec.rb b/spec/ruby/core/array/multiply_spec.rb
index ab654ce489..4060666d4b 100644
--- a/spec/ruby/core/array/multiply_spec.rb
+++ b/spec/ruby/core/array/multiply_spec.rb
@@ -88,42 +88,44 @@ describe "Array#* with an integer" do
     end
   end
 
-  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).tainted?.should == true
-  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).tainted?.should == true
+    end
 
-  it "copies the taint status of the original array even if the array is empty" do
-    ary = []
-    ary.taint
-    (ary * 3).tainted?.should == true
-  end
+    it "copies the taint status of the original array even if the array is empty" do
+      ary = []
+      ary.taint
+      (ary * 3).tainted?.should == true
+    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).tainted?.should == true
-    (ary * 2).tainted?.should == true
-  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).tainted?.should == true
+      (ary * 2).tainted?.should == true
+    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).untrusted?.should == true
-  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).untrusted?.should == true
+    end
 
-  it "copies the untrusted status of the original array even if the array is empty" do
-    ary = []
-    ary.untrust
-    (ary * 3).untrusted?.should == true
-  end
+    it "copies the untrusted status of the original array even if the array is empty" do
+      ary = []
+      ary.untrust
+      (ary * 3).untrusted?.should == true
+    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).untrusted?.should == true
-    (ary * 2).untrusted?.should == true
+    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).untrusted?.should == true
+      (ary * 2).untrusted?.should == true
+    end
   end
 end
 
diff --git a/spec/ruby/core/array/pack/p_spec.rb b/spec/ruby/core/array/pack/p_spec.rb
index 857d403313..d7dff8a4da 100644
--- a/spec/ruby/core/array/pack/p_spec.rb
+++ b/spec/ruby/core/array/pack/p_spec.rb
@@ -15,14 +15,16 @@ describe "Array#pack with format 'P'" do
     ["hello"].pack("P").unpack("P5").should == ["hello"]
   end
 
-  it "taints the input string" do
-    input_string = "hello"
-    [input_string].pack("P")
-    input_string.tainted?.should be_true
-  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
+    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
@@ -42,14 +44,16 @@ describe "Array#pack with format 'p'" do
     ["hello"].pack("p").unpack("p").should == ["hello"]
   end
 
-  it "taints the input string" do
-    input_string = "hello"
-    [input_string].pack("p")
-    input_string.tainted?.should be_true
-  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
+    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
diff --git a/spec/ruby/core/array/pack/shared/basic.rb b/spec/ruby/core/array/pack/shared/basic.rb
index bc366987c8..9061273ad6 100644
--- a/spec/ruby/core/array/pack/shared/basic.rb
+++ b/spec/ruby/core/array/pack/shared/basic.rb
@@ -33,8 +33,10 @@ describe :array_pack_basic_non_float, shared: true do
     [@obj, @obj].pack(d).should be_an_instance_of(String)
   end
 
-  it "taints the output string if the format string is tainted" do
-    [@obj, @obj].pack("x"+pack_format.taint).tainted?.should be_true
+  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
 
@@ -49,8 +51,10 @@ describe :array_pack_basic_float, shared: true do
     [1.2, 4.7].pack(d).should be_an_instance_of(String)
   end
 
-  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
+  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
 
diff --git a/spec/ruby/core/array/pack/shared/taint.rb b/spec/ruby/core/array/pack/shared/taint.rb
index 88f349cb24..565f04b8b9 100644
--- a/spec/ruby/core/array/pack/shared/taint.rb
+++ b/spec/ruby/core/array/pack/shared/taint.rb
@@ -1,33 +1,35 @@
 describe :array_pack_taint, shared: true 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
+  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 "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 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 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 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 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 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
+    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 7692163980..45f8438208 100644
--- a/spec/ruby/core/array/plus_spec.rb
+++ b/spec/ruby/core/array/plus_spec.rb
@@ -41,17 +41,19 @@ describe "Array#+" do
     ([5, 6] + ArraySpecs::ToAryArray[1, 2]).should == [5, 6, 1, 2]
   end
 
-  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
+  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 7dbd6cb3cc..2cfecbb2b4 100644
--- a/spec/ruby/core/array/pop_spec.rb
+++ b/spec/ruby/core/array/pop_spec.rb
@@ -30,12 +30,14 @@ describe "Array#pop" do
     array.pop.should == [1, 'two', 3.0, array, array, array, array]
   end
 
-  it "keeps taint status" do
-    a = [1, 2].taint
-    a.pop
-    a.tainted?.should be_true
-    a.pop
-    a.tainted?.should be_true
+  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 #{frozen_error_class} on a frozen array" do
@@ -46,12 +48,14 @@ describe "Array#pop" do
     -> { ArraySpecs.empty_frozen_array.pop }.should raise_error(frozen_error_class)
   end
 
-  it "keeps untrusted status" do
-    a = [1, 2].untrust
-    a.pop
-    a.untrusted?.should be_true
-    a.pop
-    a.untrusted?.should be_true
+  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
@@ -132,24 +136,26 @@ describe "Array#pop" do
       ArraySpecs::MyArray[1, 2, 3].pop(2).should be_an_instance_of(Array)
     end
 
-    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
+    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 #{frozen_error_class} on a frozen array" do
@@ -157,12 +163,14 @@ describe "Array#pop" do
       -> { ArraySpecs.frozen_array.pop(0) }.should raise_error(frozen_error_class)
     end
 
-    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
+    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 95d0d0a3d5..f6f581b17c 100644
--- a/spec/ruby/core/array/shared/clone.rb
+++ b/spec/ruby/core/array/shared/clone.rb
@@ -18,25 +18,27 @@ describe :array_clone, shared: true do
     b.__id__.should_not == a.__id__
   end
 
-  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
+  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.tainted?.should == true
-    bb.tainted?.should == false
-  end
+      aa.tainted?.should == true
+      bb.tainted?.should == false
+    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
+    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.untrusted?.should == true
-    bb.untrusted?.should == false
+      aa.untrusted?.should == true
+      bb.untrusted?.should == false
+    end
   end
 end
diff --git a/spec/ruby/core/array/shared/collect.rb b/spec/ruby/core/array/shared/collect.rb
index 80e2739893..cbe32d2ab4 100644
--- a/spec/ruby/core/array/shared/collect.rb
+++ b/spec/ruby/core/array/shared/collect.rb
@@ -42,16 +42,18 @@ describe :array_collect, shared: true do
     }.should raise_error(ArgumentError)
   end
 
-  it "does not copy tainted status" do
-    a = [1, 2, 3]
-    a.taint
-    a.send(@method){|x| x}.tainted?.should be_false
-  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
+    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
@@ -94,19 +96,21 @@ describe :array_collect_b, shared: true do
     a.should == ["1!", "2!", "3!"]
   end
 
-  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
+  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
+    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
diff --git a/spec/ruby/core/array/shared/inspect.rb b/spec/ruby/core/array/shared/inspect.rb
index 434440c25b..736f8d946b 100644
--- a/spec/ruby/core/array/shared/inspect.rb
+++ b/spec/ruby/core/array/shared/inspect.rb
@@ -64,28 +64,30 @@ describe :array_inspect, shared: true do
     ArraySpecs.empty_recursive_array.send(@method).should == "[[...]]"
   end
 
-  it "taints the result if the Array is non-empty and tainted" do
-    [1, 2].taint.send(@method).tainted?.should be_true
-  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 "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 "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 "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 "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
+    it "untrusts the result if an element is untrusted" do
+      ["str".untrust].send(@method).untrusted?.should be_true
+    end
   end
 
   describe "with encoding" do
diff --git a/spec/ruby/core/array/shared/join.rb b/spec/ruby/core/array/shared/join.rb
index 38bdde9502..5e7193de8a 100644
--- a/spec/ruby/core/array/shared/join.rb
+++ b/spec/ruby/core/array/shared/join.rb
@@ -58,32 +58,34 @@ describe :array_join_with_default_separator, shared: true do
     -> { ArraySpecs.empty_recursive_array.send(@method) }.should raise_error(ArgumentError)
   end
 
-  it "taints the result if the Array is tainted and non-empty" do
-    [1, 2].taint.send(@method).tainted?.should be_true
-  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 "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 "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 "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 "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
+    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
@@ -125,39 +127,41 @@ describe :array_join_with_string_separator, shared: true do
     [1, [2, ArraySpecs::MyArray[3, 4], 5], 6].send(@method, ":").should == "1:2:3:4:5:6"
   end
 
-  describe "with a tainted separator" do
-    before :each do
-      @sep = ":".taint
-    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 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 "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
+      it "taints the result if the array has two or more elements" do
+        [1, 2].send(@method, @sep).tainted?.should be_true
+      end
     end
-  end
 
-  describe "with an untrusted separator" do
-    before :each do
-      @sep = ":".untrust
-    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 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 "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
+      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/shift_spec.rb b/spec/ruby/core/array/shift_spec.rb
index ef3c9fe1cd..13f1abbbfe 100644
--- a/spec/ruby/core/array/shift_spec.rb
+++ b/spec/ruby/core/array/shift_spec.rb
@@ -117,18 +117,20 @@ describe "Array#shift" do
       ArraySpecs::MyArray[1, 2, 3].shift(2).should be_an_instance_of(Array)
     end
 
-    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
+    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/uniq_spec.rb b/spec/ruby/core/array/uniq_spec.rb
index c9bdd3dacd..4b56f3c841 100644
--- a/spec/ruby/core/array/uniq_spec.rb
+++ b/spec/ruby/core/array/uniq_spec.rb
@@ -39,44 +39,76 @@ describe "Array#uniq" do
     [x, y].uniq.should == [x, y]
   end
 
-  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
+  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
 
-      obj
-    end
+      a.uniq.should == a
 
-    a.uniq.should == a
-    a[0].tainted?.should == true
-    a[1].tainted?.should == true
+      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
 
-      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
+        obj
       end
 
-      obj
+      a.uniq.size.should == 1
     end
+  end
 
-    a.uniq.size.should == 1
-    a[0].tainted?.should == true
-    a[1].tainted?.should == true
+  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].tainted?.should == true
+      a[1].tainted?.should == true
+
+      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
+      end
+
+      a.uniq.size.should == 1
+      a[0].tainted?.should == true
+      a[1].tainted?.should == true
+    end
   end
 
   it "compares elements based on the value returned from the block" do