1 files changed, 19 insertions, 50 deletions

diff --git a/spec/ruby/core/string/ljust_spec.rb b/spec/ruby/core/string/ljust_spec.rb
index 0c3b2a2f44..0b2aab2638 100644
--- a/spec/ruby/core/string/ljust_spec.rb
+++ b/spec/ruby/core/string/ljust_spec.rb
@@ -31,16 +31,6 @@ describe "String#ljust with length, padding" do
     "radiology".ljust(8, '-').should == "radiology"
   end
 
-  ruby_version_is ''...'2.7' do
-    it "taints result when self or padstr is tainted" do
-      "x".taint.ljust(4).should.tainted?
-      "x".taint.ljust(0).should.tainted?
-      "".taint.ljust(0).should.tainted?
-      "x".taint.ljust(4, "*").should.tainted?
-      "x".ljust(4, "*".taint).should.tainted?
-    end
-  end
-
   it "tries to convert length to an integer using to_int" do
     "^".ljust(3.8, "_^").should == "^_^"
 
@@ -51,10 +41,10 @@ describe "String#ljust with length, padding" do
   end
 
   it "raises a TypeError when length can't be converted to an integer" do
-    -> { "hello".ljust("x")       }.should raise_error(TypeError)
-    -> { "hello".ljust("x", "y")  }.should raise_error(TypeError)
-    -> { "hello".ljust([])        }.should raise_error(TypeError)
-    -> { "hello".ljust(mock('x')) }.should raise_error(TypeError)
+    -> { "hello".ljust("x")       }.should.raise(TypeError)
+    -> { "hello".ljust("x", "y")  }.should.raise(TypeError)
+    -> { "hello".ljust([])        }.should.raise(TypeError)
+    -> { "hello".ljust(mock('x')) }.should.raise(TypeError)
   end
 
   it "tries to convert padstr to a string using to_str" do
@@ -65,67 +55,46 @@ describe "String#ljust with length, padding" do
   end
 
   it "raises a TypeError when padstr can't be converted" do
-    -> { "hello".ljust(20, [])        }.should raise_error(TypeError)
-    -> { "hello".ljust(20, Object.new)}.should raise_error(TypeError)
-    -> { "hello".ljust(20, mock('x')) }.should raise_error(TypeError)
+    -> { "hello".ljust(20, [])        }.should.raise(TypeError)
+    -> { "hello".ljust(20, Object.new)}.should.raise(TypeError)
+    -> { "hello".ljust(20, mock('x')) }.should.raise(TypeError)
   end
 
   it "raises an ArgumentError when padstr is empty" do
-    -> { "hello".ljust(10, '') }.should raise_error(ArgumentError)
+    -> { "hello".ljust(10, '') }.should.raise(ArgumentError)
   end
 
-  ruby_version_is ''...'3.0' do
-    it "returns subclass instances when called on subclasses" do
-      StringSpecs::MyString.new("").ljust(10).should be_an_instance_of(StringSpecs::MyString)
-      StringSpecs::MyString.new("foo").ljust(10).should be_an_instance_of(StringSpecs::MyString)
-      StringSpecs::MyString.new("foo").ljust(10, StringSpecs::MyString.new("x")).should be_an_instance_of(StringSpecs::MyString)
-
-      "".ljust(10, StringSpecs::MyString.new("x")).should be_an_instance_of(String)
-      "foo".ljust(10, StringSpecs::MyString.new("x")).should be_an_instance_of(String)
-    end
-  end
+  it "returns String instances when called on subclasses" do
+    StringSpecs::MyString.new("").ljust(10).should.instance_of?(String)
+    StringSpecs::MyString.new("foo").ljust(10).should.instance_of?(String)
+    StringSpecs::MyString.new("foo").ljust(10, StringSpecs::MyString.new("x")).should.instance_of?(String)
 
-  ruby_version_is '3.0' do
-    it "returns String instances when called on subclasses" do
-      StringSpecs::MyString.new("").ljust(10).should be_an_instance_of(String)
-      StringSpecs::MyString.new("foo").ljust(10).should be_an_instance_of(String)
-      StringSpecs::MyString.new("foo").ljust(10, StringSpecs::MyString.new("x")).should be_an_instance_of(String)
-
-      "".ljust(10, StringSpecs::MyString.new("x")).should be_an_instance_of(String)
-      "foo".ljust(10, StringSpecs::MyString.new("x")).should be_an_instance_of(String)
-    end
-  end
-
-  ruby_version_is ''...'2.7' do
-    it "when padding is tainted and self is untainted returns a tainted string if and only if length is longer than self" do
-      "hello".ljust(4, 'X'.taint).tainted?.should be_false
-      "hello".ljust(5, 'X'.taint).tainted?.should be_false
-      "hello".ljust(6, 'X'.taint).tainted?.should be_true
-    end
+    "".ljust(10, StringSpecs::MyString.new("x")).should.instance_of?(String)
+    "foo".ljust(10, StringSpecs::MyString.new("x")).should.instance_of?(String)
   end
 
   describe "with width" do
     it "returns a String in the same encoding as the original" do
-      str = "abc".force_encoding Encoding::IBM437
+      str = "abc".dup.force_encoding Encoding::IBM437
       result = str.ljust 5
       result.should == "abc  "
-      result.encoding.should equal(Encoding::IBM437)
+      result.encoding.should.equal?(Encoding::IBM437)
     end
   end
 
   describe "with width, pattern" do
     it "returns a String in the compatible encoding" do
-      str = "abc".force_encoding Encoding::IBM437
+      str = "abc".dup.force_encoding Encoding::IBM437
       result = str.ljust 5, "あ"
       result.should == "abcああ"
-      result.encoding.should equal(Encoding::UTF_8)
+      result.encoding.should.equal?(Encoding::UTF_8)
     end
 
     it "raises an Encoding::CompatibilityError if the encodings are incompatible" do
       pat = "ア".encode Encoding::EUC_JP
       -> do
         "あれ".ljust 5, pat
-      end.should raise_error(Encoding::CompatibilityError)
+      end.should.raise(Encoding::CompatibilityError)
     end
   end
 end